那些遇到过的问题

如何在C++中找到内存泄漏

7 c++ embedded memory-leaks

在嵌入式环境中检测C++内存泄漏的好方法是什么？我尝试重载新运算符来记录每个数据分配,但我一定做错了,这种方法不起作用.有没有其他人遇到类似的情况？

这是new和delete运算符重载的代码.

编辑:

完全披露:我正在寻找程序中的内存泄漏,我正在使用其他人写的代码来重载new和delete运算符.我的部分问题是我不完全理解它的作用.我知道目标是记录调用者和前一个调用者的地址,分配的大小,如果我们正在分配则为1,如果我们是释放则为2.加上正在运行的线程的名称.

感谢所有的建议,我将尝试一种不同的方法,在这里工作的人建议.如果有效,我会在这里发布.

再次感谢所有一流的程序员花时间回答.

StackOverflow摇滚!

结论

感谢所有的答案.不幸的是,我不得不继续处理另一个更紧迫的问题.这种泄漏只发生在极不可能的情况下.我只是放弃它感到蹩脚,如果我有更多时间,我可以回到它.我选择了我最有可能使用的答案.

#include <stdlib.h>
#include "stdio.h"
#include "nucleus.h"
#include "plus/inc/dm_defs.h"
#include "plus/inc/pm_defs.h"

#include "posix\inc\posix.h"

extern void* TCD_Current_Thread;
extern "C" void rd_write_text(char * text);
extern PM_PCB * PMD_Created_Pools_List;

typedef struct {
    void* addr;
    uint16_t size;
    uint16_t flags;
} MemLogEntryNarrow_t;

typedef struct {
    void* addr;
    uint16_t size;
    uint16_t flags;
    void* caller;
    void* prev_caller;
    void* taskid;
    uint32_t timestamp;
} MemLogEntryWide_t;

//size lookup table
unsigned char MEM_bitLookupTable[] = {
 0,1,1,2,1,2,2,3,1,2,2,3,1,3,3,4
};

//#pragma CODE_SECTION ("section_ramset1_0")
void *::operator new(unsigned int size)
{
   asm(" STR R14, [R13, #0xC]");  //save stack address temp[0]
   asm(" STR R13, [R13, #0x10]");  //save pc return address temp[1]

   if ( loggingEnabled )
   {
      uint32_t savedInterruptState;
      uint32_t currentIndex;

      // protect the thread unsafe section.
      savedInterruptState = NU_Local_Control_Interrupts(NU_DISABLE_INTERRUPTS);

      // Note that this code is FRAGILE.  It peeks backwards on the stack to find the return
      // address of the caller.  The location of the return address on the stack can be easily changed
      // as a result of other changes in this function (i.e. adding local variables, etc).
      // The offsets may need to be adjusted if this function is touched.
      volatile unsigned int temp[2];

      unsigned int *addr = (unsigned int *)temp[0] - 1;
      unsigned int count = 1 + (0x20/4);   //current stack space ***

      //Scan for previous store
      while ((*addr & 0xFFFF0000) != 0xE92D0000)
      {
         if ((*addr & 0xFFFFF000) == 0xE24DD000)
         {
            //add offset in words
            count += ((*addr & 0xFFF) >> 2);
         }
         addr--;
      }

      count += MEM_bitLookupTable[*addr & 0xF];
      count += MEM_bitLookupTable[(*addr >>4) & 0xF];
      count += MEM_bitLookupTable[(*addr >> 8) & 0xF];
      count += MEM_bitLookupTable[(*addr >> 12) & 0xF];

      addr = (unsigned int *)temp[1] + count;
      // FRAGILE CODE ENDS HERE

      currentIndex = currentMemLogWriteIndex;
      currentMemLogWriteIndex++;

      if ( memLogNarrow )
      {
         if (currentMemLogWriteIndex >= MEMLOG_SIZE/2 )
         {
            loggingEnabled = false;
            rd_write_text( "Allocation Logging is complete and DISABLED!\r\n\r\n");
         }
         // advance the read index if necessary.
         if ( currentMemLogReadIndex == currentMemLogWriteIndex )
         {
            currentMemLogReadIndex++;
            if ( currentMemLogReadIndex == MEMLOG_SIZE/2 )
            {
               currentMemLogReadIndex = 0;
            }
         }

         NU_Local_Control_Interrupts(savedInterruptState);

         //Standard operator 
         //(For Partition Analysis we have to consider that if we alloc size of 0 always as size of 1 then are partitions must be optimized for this)
         if (size == 0) size = 1;

         ((MemLogEntryNarrow_t*)memLog)[currentIndex].size = size;
         ((MemLogEntryNarrow_t*)memLog)[currentIndex].flags = 1;    //allocated

         //Standard operator
         void * ptr;
         ptr = malloc(size);

         ((MemLogEntryNarrow_t*)memLog)[currentIndex].addr = ptr;

         return ptr;
      }
      else
      {
         if (currentMemLogWriteIndex >= MEMLOG_SIZE/6 )
         {
            loggingEnabled = false;
            rd_write_text( "Allocation Logging is complete and DISABLED!\r\n\r\n");
         }
         // advance the read index if necessary.
         if ( currentMemLogReadIndex == currentMemLogWriteIndex )
         {
            currentMemLogReadIndex++;
            if ( currentMemLogReadIndex == MEMLOG_SIZE/6 )
            {
               currentMemLogReadIndex = 0;
            }
         }

         ((MemLogEntryWide_t*)memLog)[currentIndex].caller = (void *)(temp[0] - 4);
         ((MemLogEntryWide_t*)memLog)[currentIndex].prev_caller = (void *)*addr;
         NU_Local_Control_Interrupts(savedInterruptState);
         ((MemLogEntryWide_t*)memLog)[currentIndex].taskid = (void *)TCD_Current_Thread;
         ((MemLogEntryWide_t*)memLog)[currentIndex].size = size;
         ((MemLogEntryWide_t*)memLog)[currentIndex].flags = 1;    //allocated
         ((MemLogEntryWide_t*)memLog)[currentIndex].timestamp = *(volatile uint32_t *)0xfffbc410;   // for arm9

         //Standard operator
         if (size == 0) size = 1;

         void * ptr;
         ptr = malloc(size);

         ((MemLogEntryWide_t*)memLog)[currentIndex].addr = ptr;

         return ptr;
      }
   }
   else
   {
       //Standard operator
       if (size == 0) size = 1;

       void * ptr;
       ptr = malloc(size);

       return ptr;
   }
}
//#pragma CODE_SECTION ("section_ramset1_0")
void ::operator delete(void *ptr)
{
   uint32_t savedInterruptState;
   uint32_t currentIndex;

   asm(" STR R14, [R13, #0xC]");  //save stack address temp[0]
   asm(" STR R13, [R13, #0x10]");  //save pc return address temp[1]

   if ( loggingEnabled )
   {
      savedInterruptState = NU_Local_Control_Interrupts(NU_DISABLE_INTERRUPTS);

      // Note that this code is FRAGILE.  It peeks backwards on the stack to find the return
      // address of the caller.  The location of the return address on the stack can be easily changed
      // as a result of other changes in this function (i.e. adding local variables, etc).
      // The offsets may need to be adjusted if this function is touched.
      volatile unsigned int temp[2];

      unsigned int *addr = (unsigned int *)temp[0] - 1;
      unsigned int count = 1 + (0x20/4);   //current stack space ***

      //Scan for previous store
      while ((*addr & 0xFFFF0000) != 0xE92D0000)
      {
         if ((*addr & 0xFFFFF000) == 0xE24DD000)
         {
            //add offset in words
            count += ((*addr & 0xFFF) >> 2);
         }
         addr--;
      }

      count += MEM_bitLookupTable[*addr & 0xF];
      count += MEM_bitLookupTable[(*addr >>4) & 0xF];
      count += MEM_bitLookupTable[(*addr >> 8) & 0xF];
      count += MEM_bitLookupTable[(*addr >> 12) & 0xF];

      addr = (unsigned int *)temp[1] + count;
      // FRAGILE CODE ENDS HERE

      currentIndex = currentMemLogWriteIndex;
      currentMemLogWriteIndex++;

      if ( memLogNarrow )
      {
         if ( currentMemLogWriteIndex >= MEMLOG_SIZE/2 )
         {
            loggingEnabled = false;
            rd_write_text( "Allocation Logging is complete and DISABLED!\r\n\r\n");
         }
         // advance the read index if necessary.
         if ( currentMemLogReadIndex == currentMemLogWriteIndex )
         {
            currentMemLogReadIndex++;
            if ( currentMemLogReadIndex == MEMLOG_SIZE/2 )
            {
               currentMemLogReadIndex = 0;
            }
         }

         NU_Local_Control_Interrupts(savedInterruptState);

         // finish logging the fields.  these are thread safe so they dont need to be inside the protected section.
         ((MemLogEntryNarrow_t*)memLog)[currentIndex].addr = ptr;
         ((MemLogEntryNarrow_t*)memLog)[currentIndex].size = 0;
         ((MemLogEntryNarrow_t*)memLog)[currentIndex].flags = 2;    //unallocated
      }
      else
      {
         ((MemLogEntryWide_t*)memLog)[currentIndex].caller = (void *)(temp[0] - 4);
         ((MemLogEntryWide_t*)memLog)[currentIndex].prev_caller = (void *)*addr;

         if ( currentMemLogWriteIndex >= MEMLOG_SIZE/6 )
         {
            loggingEnabled = false;
            rd_write_text( "Allocation Logging is complete and DISABLED!\r\n\r\n");
         }
         // advance the read index if necessary.
         if ( currentMemLogReadIndex == currentMemLogWriteIndex )
         {
            currentMemLogReadIndex++;
            if ( currentMemLogReadIndex == MEMLOG_SIZE/6 )
            {
               currentMemLogReadIndex = 0;
            }
         }
         NU_Local_Control_Interrupts(savedInterruptState);

         // finish logging the fields.  these are thread safe so they dont need to be inside the protected section.
         ((MemLogEntryWide_t*)memLog)[currentIndex].addr = ptr;
         ((MemLogEntryWide_t*)memLog)[currentIndex].size = 0;
         ((MemLogEntryWide_t*)memLog)[currentIndex].flags = 2;    //unallocated
         ((MemLogEntryWide_t*)memLog)[currentIndex].taskid = (void *)TCD_Current_Thread;
         ((MemLogEntryWide_t*)memLog)[currentIndex].timestamp = *(volatile uint32_t *)0xfffbc410;   // for arm9
      }

      //Standard operator
      if (ptr != NULL) {
         free(ptr);
      }
   }
   else
   {
      //Standard operator
      if (ptr != NULL) {
        free(ptr);
      }
   }
}
Run Code Online (Sandbox Code Playgroud)

Mic*_*ael 8

如果你正在运行Linux,我建议尝试Valgrind.

Ski*_*izz 6

有几种形式的运营商新:

void *operator new (size_t);
void *operator new [] (size_t);
void *operator new (size_t, void *);
void *operator new [] (size_t, void *);
void *operator new (size_t, /* parameters of your choosing! */);
void *operator new [] (size_t, /* parameters of your choosing! */);
Run Code Online (Sandbox Code Playgroud)

以上所有都可以存在于全局和类范围内.对于每个operator new,都有一个等效的operator delete.如果您希望这样做,则需要确保将操作数添加到操作员的所有版本.

理想情况下,无论是否存在内存日志记录,您都希望系统的行为相同.例如,MS VC运行时库在调试中分配的内存多于在发布中的内存,因为它为内存分配添加了一个更大的信息块,并在分配的开始和结束时添加了保护块.最好的解决方案是保持所有内存日志记录信息是一个单独的块或内存,并使用映射来跟踪内存.这也可用于验证传递给delete的内存是否有效.

new
  allocate memory
  add entry to logging table

delete
  check address exists in logging table
  free memory
Run Code Online (Sandbox Code Playgroud)

但是,您正在编写嵌入式软件,通常情况下,内存是有限的资源.在这些系统上通常最好避免动态内存分配,原因如下:

  1. 你知道有多少内存,所以你事先知道你可以分配多少对象.分配永远不应该返回null,因为这通常是终端,没有简单的方法回到健康的系统.
  2. 分配和释放内存会导致碎片化.您可以分配的对象数量会随着时间的推移而减少.您可以编写一个内存压缩器来移动已分配的对象以释放更大的内存块,但这会影响性能.如第1点所述,一旦得到null,事情就变得棘手了.

因此,在进行嵌入式工作时,您通常可以预先知道可以为各种对象分配多少内存,并且知道这一点,您可以为每种对象类型编写更高效的内存管理器,以便在内存耗尽时采取适当的操作 - 丢弃旧项目,崩溃等

编辑

如果你想知道什么称为内存分配,最好的办法是使用一个宏(我知道,宏一般都很糟糕):

#define NEW new (__FILE__, __LINE__, __FUNCTION__)
Run Code Online (Sandbox Code Playgroud)

并定义一个新的运算符:

void *operator new (size_t size, char *file, int line, char *function)
{
   // log the allocation somewhere, no need to strcpy file or function, just save the 
   // pointer values
   return malloc (size);
}
Run Code Online (Sandbox Code Playgroud)

并像这样使用它:

SomeObject *obj = NEW SomeObject (parameters);
Run Code Online (Sandbox Code Playgroud)

您的编译器可能没有__FUNCTION__预处理器定义,因此您可以安全地省略它.

War*_*ior 5

http://www.linuxjournal.com/article/6059

实际上根据我的经验,最好为嵌入式系统创建内存池并使用自定义分配器/解除分配器.我们可以轻松识别泄漏.例如,我们为vxworks提供了一个简单的自定义内存管理器,我们将任务ID,时间戳存储在已分配的mem块中.

Jay*_*son 3

一种方法是将分配内存的模块的文件名和行号字符串（通过指针）插入到分配的数据块中。文件和行号是通过使用 C++ 标准“ __FILE__”和“ __LINE__”宏来处理的。当内存被解除分配时，该信息将被删除。

我们的一个系统具有此功能，我们称之为“内存占用报告”。因此，我们可以随时从 CLI 打印出所有分配的内存以及谁分配了内存的大量信息。该列表按分配最多内存的代码模块排序。很多时候，我们会随着时间的推移以这种方式监视内存使用情况，最终内存占用（泄漏）将上升到列表的顶部。

归档时间：

查看次数：

4817 次

最近记录：

13 年，2 月 前
相关归档
静态链接与动态链接 382
为什么类不能为函数和数据成员具有相同的名称？ 29
如何在C++中实现序列化 28
如何找到std :: random_device的"真实"熵？ 25
SSE,内在函数和对齐 24
可能的分段错误:我是否正确使用"this->"运算符？ 24
如何从微控制器转向嵌入式Linux？ 15
如何在C++中检测未分配内存上的双删除或删除？ 4
通过/ dev/mtd更新内核 3
在C中初始化数组 2
难疑归档
package.json中的波浪号(〜)和插入符号(^)有什么区别？ 3111
什么是反思,为什么它有用？ 2011
单身人士有什么不好的？ 1931
根据pandas中列的值从DataFrame中选择行 1649
计算C#中的相对时间 1461
如何计算列表项的出现次数？ 1417
在Python中反转一个字符串 1288
如何使用自定义对象对NSMutableArray进行排序？ 1253
将图像加载到Bitmap对象时出现奇怪的内存不足问题 1252
在JavaScript中将Unix时间戳转换为时间 1054