C++多线程环境中进行内存分配跟踪的接口类设计（全局重载new/delete操作符）

2024-01-23 15:28
文章标签 进行 c++ 设计 全局 内存 分配 多线程 重载 环境 跟踪 new 操作符 delete 接口类

本文主要是介绍C++多线程环境中进行内存分配跟踪的接口类设计（全局重载new/delete操作符），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

通过全局重载new和delete操作符，实现堆区空间的分配和释放的跟踪记录

// Memory.h
#if TRACK_MEMORY
#ifdef PLATFORM_WINDOWS_NODISCARD _Ret_notnull_ _Post_writable_byte_size_(size) _VCRT_ALLOCATOR
void* __CRTDECL operator new(size_t size);_NODISCARD _Ret_notnull_ _Post_writable_byte_size_(size) _VCRT_ALLOCATOR
void* __CRTDECL operator new[](size_t size);_NODISCARD _Ret_notnull_ _Post_writable_byte_size_(size) _VCRT_ALLOCATOR
void* __CRTDECL operator new(size_t size, const char* desc);_NODISCARD _Ret_notnull_ _Post_writable_byte_size_(size) _VCRT_ALLOCATOR
void* __CRTDECL operator new[](size_t size, const char* desc);_NODISCARD _Ret_notnull_ _Post_writable_byte_size_(size) _VCRT_ALLOCATOR
void* __CRTDECL operator new(size_t size, const char* file, int line);_NODISCARD _Ret_notnull_ _Post_writable_byte_size_(size) _VCRT_ALLOCATOR
void* __CRTDECL operator new[](size_t size, const char* file, int line);void __CRTDECL operator delete(void* memory);
void __CRTDECL operator delete(void* memory, const char* desc);
void __CRTDECL operator delete(void* memory, const char* file, int line);
void __CRTDECL operator delete[](void* memory);
void __CRTDECL operator delete[](void* memory, const char* desc);
void __CRTDECL operator delete[](void* memory, const char* file, int line);#define hnew new(__FILE__, __LINE__)	// 源文件、行号，用于跟踪进行内存分配的位置
#define hdelete delete#else#warning "Memory tracking not available on non-Windows platform"
#define hnew new
#define hdelete delete#endif#else#define hnew new
#define hdelete delete#endif

// Memory.cpp
#if TRACK_MEMORY && PLATFORM_WINDOWS// windows平台的MSVC编译器的标注和属性
_NODISCARD _Ret_notnull_ _Post_writable_byte_size_(size) _VCRT_ALLOCATOR	
void* __CRTDECL operator new(size_t size)
{return Allocator::Allocate(size);	// 分配一块大小为 size 字节的内存。
}_NODISCARD _Ret_notnull_ _Post_writable_byte_size_(size) _VCRT_ALLOCATOR
void* __CRTDECL operator new[](size_t size)
{return Allocator::Allocate(size);	
}_NODISCARD _Ret_notnull_ _Post_writable_byte_size_(size) _VCRT_ALLOCATOR
void* __CRTDECL operator new(size_t size, const char* desc)
{return Allocator::Allocate(size, desc);	// 分配一块大小为 size 字节的内存，并附带一个描述字符串。
}_NODISCARD _Ret_notnull_ _Post_writable_byte_size_(size) _VCRT_ALLOCATOR
void* __CRTDECL operator new[](size_t size, const char* desc)
{return Allocator::Allocate(size, desc);
}_NODISCARD _Ret_notnull_ _Post_writable_byte_size_(size) _VCRT_ALLOCATOR
void* __CRTDECL operator new(size_t size, const char* file, int line)
{return Allocator::Allocate(size, file, line);	// 分配一块大小为 size 字节的内存，并记录文件名和行号。
}_NODISCARD _Ret_notnull_ _Post_writable_byte_size_(size) _VCRT_ALLOCATOR
void* __CRTDECL operator new[](size_t size, const char* file, int line)
{return Allocator::Allocate(size, file, line);
}void __CRTDECL operator delete(void* memory)
{return Allocator::Free(memory);
}void __CRTDECL operator delete(void* memory, const char* desc)
{return Allocator::Free(memory);
}void __CRTDECL operator delete(void* memory, const char* file, int line)
{return Allocator::Free(memory);
}void __CRTDECL operator delete[](void* memory)
{return Allocator::Free(memory);
}void __CRTDECL operator delete[](void* memory, const char* desc)
{return Allocator::Free(memory);
}void __CRTDECL operator delete[](void* memory, const char* file, int line)
{return Allocator::Free(memory);
}#endif

自定义内存分配接口

// Memory.h
#pragma once#include <map>
#include <mutex>// 用于记录整个程序内存分配的情况
struct AllocationStats
{size_t TotalAllocated = 0;size_t TotalFreed = 0;
};// 用于记录单个内存分配的信息
struct Allocation
{void* Memory = 0;size_t Size = 0;const char* Category = 0;	// 描述信息，比如记录申请内存分配的代码的位置，该内存的用处等等
};// 对外接口，用于获取记录分配情况的静态对象(仅Memory.cpp可见)
namespace Memory
{const AllocationStats& GetAllocationStats();
}// Map Allocator 自定义的内存分配器，用于管理std::map的键值对的内存分配，
template <class T>
struct Mallocator
{typedef T value_type;Mallocator() = default;template <class U> constexpr Mallocator(const Mallocator <U>&) noexcept {}T* allocate(std::size_t n){
#undef max// 64位操作系统最大寻址内存值为2^64，因此要保证传入的n是小于这个的if (n > std::numeric_limits<std::size_t>::max() / sizeof(T))throw std::bad_array_new_length();if (auto p = static_cast<T*>(std::malloc(n * sizeof(T)))) {return p;}throw std::bad_alloc();}void deallocate(T* p, std::size_t n) noexcept {std::free(p);}
};struct AllocatorData
{// 2个自定义分配器，分别用于管理std::map中的 这种键值对的内存分配: // key:                   value:// const void* const  --  Allocation// const char* const  --  AllocationStatsusing MapAlloc = Mallocator<std::pair<const void* const, Allocation>>;using StatsMapAlloc = Mallocator<std::pair<const char* const, AllocationStats>>;using AllocationStatsMap = std::map<const char*, AllocationStats, std::less<const char*>, StatsMapAlloc>;// 两个std::map容器// key:内存地址；value: Allocation结构体，记录了内存的指针、大小、描述信息std::map<const void*, Allocation, std::less<const void*>, MapAlloc> m_AllocationMap;// key:描述信息；value: 内存总共分配数量、释放数量AllocationStatsMap m_AllocationStatsMap;std::mutex m_Mutex, m_StatsMutex;
};// 内存分配器接口定义
class Allocator
{
public:static void Init();static void* AllocateRaw(size_t size);static void* Allocate(size_t size);static void* Allocate(size_t size, const char* desc);static void* Allocate(size_t size, const char* file, int line);static void Free(void* memory);static const AllocatorData::AllocationStatsMap& GetAllocationStats() { return s_Data->m_AllocationStatsMap; }
private:inline static AllocatorData* s_Data = nullptr;
};

#include "Memory.h"#include <memory>
#include <map>
#include <mutex>#include "Log.h"
// 用于记录全局内存分配、释放的信息
static Hazel::AllocationStats s_GlobalStats;// 分配器是否正在进行初始化操作（应付多线程）
static bool s_InInit = false;// 初始化阶段，主要是分配一个静态的AllocatorData对象（lazy 初始化）
void Allocator::Init()
{if (s_Data)return;s_InInit = true;AllocatorData* data = (AllocatorData*)Allocator::AllocateRaw(sizeof(AllocatorData));new(data) AllocatorData();	// 定位new（placement new）在指定地址构造目标对象，并调用构造函数初始化，释放需要调用operator deletes_Data = data;s_InInit = false;
}// 利用malloc进行原始内存分配（即不会调用构造和析构），记得手动调用Allocator::free
void* Allocator::AllocateRaw(size_t size)
{return malloc(size);
}void* Allocator::Allocate(size_t size)
{// 如果一个线程正在执行Init()函数，分配请求用原始内存分配来处理if (s_InInit)return AllocateRaw(size);if (!s_Data)Init();void* memory = malloc(size);{std::scoped_lock<std::mutex> lock(s_Data->m_Mutex);Allocation& alloc = s_Data->m_AllocationMap[memory];	// 没有该key就创建，有就返回alloc.Memory = memory;alloc.Size = size;s_GlobalStats.TotalAllocated += size;}return memory;
}// 分配带有描述信息的内存，这个内存不仅要记录到总分配内存计数器中，还要把这种类型的内存单独进行计数
void* Allocator::Allocate(size_t size, const char* desc)
{if (!s_Data)Init();void* memory = malloc(size);{std::scoped_lock<std::mutex> lock(s_Data->m_Mutex);Allocation& alloc = s_Data->m_AllocationMap[memory];alloc.Memory = memory;alloc.Size = size;alloc.Category = desc;s_GlobalStats.TotalAllocated += size;if (desc)s_Data->m_AllocationStatsMap[desc].TotalAllocated += size; // 单独计数}return memory;
}
// line没用到，目前只想逐源文件记录内存分配量
void* Allocator::Allocate(size_t size, const char* file, int line)
{if (!s_Data)Init();void* memory = malloc(size);{std::scoped_lock<std::mutex> lock(s_Data->m_Mutex);Allocation& alloc = s_Data->m_AllocationMap[memory];alloc.Memory = memory;alloc.Size = size;alloc.Category = file;s_GlobalStats.TotalAllocated += size;s_Data->m_AllocationStatsMap[file].TotalAllocated += size;}return memory;
}void Allocator::Free(void* memory)
{if (memory == nullptr)return;{// map中有，计数更新并移除bool found = false;{std::scoped_lock<std::mutex> lock(s_Data->m_Mutex);auto allocMapIt = s_Data->m_AllocationMap.find(memory);found = allocMapIt != s_Data->m_AllocationMap.end();if (found)	{const Allocation& alloc = allocMapIt->second;s_GlobalStats.TotalFreed += alloc.Size;if (alloc.Category)s_Data->m_AllocationStatsMap[alloc.Category].TotalFreed += alloc.Size;s_Data->m_AllocationMap.erase(memory);}}if (!found)LOG("Memory", "Memory block {0} not present in alloc map", memory);}free(memory);
}namespace Memory {const AllocationStats& GetAllocationStats() { return s_GlobalStats; }
}

这篇关于C++多线程环境中进行内存分配跟踪的接口类设计（全局重载new/delete操作符）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/636752。

相关文章

Go语言中make和new的区别及说明

Go语言中make和new的区别及说明

《Go语言中make和new的区别及说明》：本文主要介绍Go语言中make和new的区别及说明,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录1 概述2 new 函数2.1 功能2.2 语法2.3 初始化案例3 make 函数3.1 功能3.2 语法3.3 初始化
阅读更多...
Spring Boot @RestControllerAdvice全局异常处理最佳实践

Spring Boot @RestControllerAdvice全局异常处理最佳实践

《SpringBoot@RestControllerAdvice全局异常处理最佳实践》本文详解SpringBoot中通过@RestControllerAdvice实现全局异常处理,强调代码复用、统... 目录前言一、为什么要使用全局异常处理？二、核心注解解析1. @RestControllerAdvice2
阅读更多...
怎样通过分析GC日志来定位Java进程的内存问题

怎样通过分析GC日志来定位Java进程的内存问题

《怎样通过分析GC日志来定位Java进程的内存问题》：本文主要介绍怎样通过分析GC日志来定位Java进程的内存问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、GC 日志基础配置1. 启用详细 GC 日志2. 不同收集器的日志格式二、关键指标与分析维度1.
阅读更多...
Java内存分配与JVM参数详解(推荐)

Java内存分配与JVM参数详解(推荐)

《Java内存分配与JVM参数详解(推荐)》本文详解JVM内存结构与参数调整,涵盖堆分代、元空间、GC选择及优化策略,帮助开发者提升性能、避免内存泄漏,本文给大家介绍Java内存分配与JVM参数详解,... 目录引言JVM内存结构JVM参数概述堆内存分配年轻代与老年代调整堆内存大小调整年轻代与老年代比例元空
阅读更多...
使用Python实现可恢复式多线程下载器

使用Python实现可恢复式多线程下载器

《使用Python实现可恢复式多线程下载器》在数字时代,大文件下载已成为日常操作,本文将手把手教你用Python打造专业级下载器,实现断点续传,多线程加速,速度限制等功能,感兴趣的小伙伴可以了解下... 目录一、智能续传：从崩溃边缘抢救进度二、多线程加速：榨干网络带宽三、速度控制：做网络的好邻居四、终端交互
阅读更多...
MySQL中的锁机制详解之全局锁,表级锁,行级锁

MySQL中的锁机制详解之全局锁,表级锁,行级锁

《MySQL中的锁机制详解之全局锁,表级锁,行级锁》MySQL锁机制通过全局、表级、行级锁控制并发,保障数据一致性与隔离性,全局锁适用于全库备份,表级锁适合读多写少场景,行级锁(InnoDB)实现高并... 目录一、锁机制基础：从并发问题到锁分类1.1 并发访问的三大问题1.2 锁的核心作用1.3 锁粒度分
阅读更多...
从入门到精通C++11 ＜chrono＞ 库特性

从入门到精通C++11 ＜chrono＞ 库特性

《从入门到精通C++11＜chrono＞库特性》chrono库是C++11中一个非常强大和实用的库,它为时间处理提供了丰富的功能和类型安全的接口,通过本文的介绍,我们了解了chrono库的基本概念... 目录一、引言1.1 为什么需要<chrono>库1.2<chrono>库的基本概念二、时间段（Durat
阅读更多...
C++20管道运算符的实现示例

C++20管道运算符的实现示例

《C++20管道运算符的实现示例》本文简要介绍C++20管道运算符的使用与实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录标准库的管道运算符使用自己实现类似的管道运算符我们不打算介绍太多，因为它实际属于c++20最为重要的
阅读更多...
Visual Studio 2022 编译C++20代码的图文步骤

Visual Studio 2022 编译C++20代码的图文步骤

《VisualStudio2022编译C++20代码的图文步骤》在VisualStudio中启用C++20import功能,需设置语言标准为ISOC++20,开启扫描源查找模块依赖及实验性标... 默认创建Visual Studio桌面控制台项目代码包含C++20的import方法。右键项目的属性：
阅读更多...
SQLite3 在嵌入式C环境中存储音频/视频文件的最优方案

SQLite3 在嵌入式C环境中存储音频/视频文件的最优方案

《SQLite3在嵌入式C环境中存储音频/视频文件的最优方案》本文探讨了SQLite3在嵌入式C环境中存储音视频文件的优化方案,推荐采用文件路径存储结合元数据管理,兼顾效率与资源限制,小文件可使用B... 目录SQLite3 在嵌入式C环境中存储音频/视频文件的专业方案一、存储策略选择1. 直接存储 vs
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2