Changeset 2212 for XIOS/dev/dev_ym/XIOS_COUPLING/src/memtrack.cpp

Timestamp:

09/02/21 17:06:35 (3 years ago)

Author:

ymipsl

Message:

Revisiting Memory tracking :

• MemTrack? has been improved
  • Not need anymore to use private external libaddr2line, fork addr2line process internaly and use bidrectionnale pipe to send stack adress et get in return the demangle stack name
  • Can use cxa_demangle in backup
• Block memory leak report is output in separate file (xios_xxx.mem),memory block are ordonned in decreasing size.
• Possibility to output only the n bigest bloc with : "memtrack_blocs" xios parameters
• Possibility to output only bloc over a given size with : "memtrack_size" xios parameters

• Implement new method to retrieve the memory consumed in a time interval very similarely to xios timer :

CMemTracker("xios").resume()
CMemTracker("xios").suspend() ;
etc....

YM

File:

• XIOS/dev/dev_ym/XIOS_COUPLING/src/memtrack.cpp (modified) (4 diffs)

XIOS/dev/dev_ym/XIOS_COUPLING/src/memtrack.cpp

@@ -45 +45 @@
 #include <string>
 #include <execinfo.h>
-
+#include <cxxabi.h>
+#include <dlfcn.h>
+#include <map>
+#include <fstream>
 #include "memtrack.hpp"
+#include "log.hpp"
+#include "addr2line.hpp"
 #undef new    // IMPORTANT!
 
-extern "C"
-{
-  void addr2line(const char *file_name, char** addr, int naddr) ;
-#ifdef XIOS_MEMTRACK_LIGHT
-  void addr2line(const char *file_name, char** addr, int naddr) {} 
-#endif
-}
+
 /* ------------------------------------------------------------ */
 /* -------------------- namespace MemTrack -------------------- */
@@ -98 +97 @@
         
             void Stamp(char const *filename, int lineNum, char const *typeName);
-            void backTrace(void) ;
-        
+            void backTrace(std::ofstream& memReport, xios::CAddr2line& addr2line) ;
+            void backTrace(std::ofstream& memReport) ;
+
             static void AddNode(BlockHeader *node);
             static void RemoveNode(BlockHeader *node);
@@ -139 +139 @@
     }
 
-    void BlockHeader::backTrace(void)
+
+    void BlockHeader::backTrace(std::ofstream& memReport)
+    {
+        char** strings ;
+        strings = backtrace_symbols(stackArray, this->stackSize);
+        int stackSize=this->stackSize-3 ;
+        char* buffer ;
+        char* outputBuffer ;
+        size_t length=10 ;
+        outputBuffer = (char*) malloc(length) ;
+        int status ;
+        Dl_info info;
+        for(int i=0;i<stackSize;i++) 
+        {
+            if (dladdr(stackArray[i+3], &info))
+            {
+              buffer=abi::__cxa_demangle(info.dli_sname,outputBuffer,&length,&status );
+              if (buffer!=nullptr) 
+              {
+                memReport<<buffer<<std::endl ;
+                outputBuffer=buffer ;
+              }
+              else if (info.dli_sname!=nullptr) memReport<<info.dli_sname<<std::endl ;
+              else memReport<<strings[i+3]<<std::endl ;
+            }
+            else memReport<<strings[i+3]<<std::endl ;
+        }
+        free(buffer) ;
+        free(strings) ;
+    }
+
+    void BlockHeader::backTrace(std::ofstream& memReport, xios::CAddr2line& addr2line)
     {   
         
-//        oss<<"addr2line -C -f -i -s -e ../bin/test_client.exe " ;
-        char *addr ;
-        char buffer[20] ;
-        addr=buffer ;
-        for(int i=0;i<stackSize;i++) 
-        {
-          std::ostringstream oss ;
-          oss<<stackArray[i] ;
-          strcpy(addr,oss.str().c_str()) ;
-          addr2line("/proc/self/exe",&addr,1) ;
-        }
+      int stackSize=this->stackSize-3 ;
+      
+      for(int i=0;i<stackSize;i++)
+      {
+        std::ostringstream address;
+        address << stackArray[i+3];
+        addr2line.write(address.str()) ;
+        std::string out ;
+        addr2line.read(out) ;
+        memReport<<out<<std::endl ;
+      }
     }
     /* ---------------------------------------- BlockHeader AddNode */
@@ -439 +470 @@
     /* ---------------------------------------- TrackDumpBlocks */
 
-    void TrackDumpBlocks()
+    void TrackDumpBlocks(std::ofstream& memReport, size_t memtrack_blocks, size_t memtrack_size )
     {
         // Get an array of pointers to all extant blocks.
+        std::ostringstream ostr ;
         size_t numBlocks = BlockHeader::CountBlocks();
         BlockHeader **ppBlockHeader =
             (BlockHeader **)calloc(numBlocks, sizeof(*ppBlockHeader));
         BlockHeader::GetBlocks(ppBlockHeader);
-
         // Dump information about the memory blocks.
-        printf("\n");
-        printf("=====================\n");
-        printf("Current Memory Blocks\n");
-        printf("=====================\n");
-        printf("\n");
+        
+        memReport<<std::endl;
+        memReport<<"=====================" <<std::endl ;
+        memReport<<"Current Memory Blocks" <<std::endl ;
+        memReport<<"=====================" <<std::endl ;
+        memReport<<std::endl ;
+        char strbuff[10000] ;
+        std::multimap<size_t,BlockHeader *,std::greater<int>> orderedBlocks ;
         for (size_t i = 0; i < numBlocks; i++)
         {
-            BlockHeader *pBlockHeader = ppBlockHeader[i];
+          BlockHeader *pBlockHeader = ppBlockHeader[i];
+          size_t size = pBlockHeader->GetRequestedSize();
+          orderedBlocks.insert({size,pBlockHeader}) ;
+        }
+        
+        xios::CAddr2line myaddr2line ;
+        size_t i = 0 ;
+        for(auto& it : orderedBlocks)
+        {
+            BlockHeader *pBlockHeader = it.second ;
             char const *typeName = pBlockHeader->GetTypeName();
             size_t size = pBlockHeader->GetRequestedSize();
             char const *fileName = pBlockHeader->GetFilename();
             int lineNum = pBlockHeader->GetLineNum();
-            printf("*** #%-6d %5d bytes %-50s\n", i, size, typeName);
-            printf("... %s:%d\n", fileName, lineNum);
-            pBlockHeader->backTrace();
-        }
-
+            if (memtrack_blocks>0 && i>memtrack_blocks) break ;            
+            if (memtrack_size>0 && size<memtrack_size) break ;            
+            
+            sprintf(strbuff,"*** #%-6d %5d bytes %-50s\n", i, size, typeName);
+            memReport<<strbuff ;
+            sprintf(strbuff,"... %s:%d\n", fileName, lineNum);
+            memReport<<strbuff ;
+            //pBlockHeader->backTrace(memReport, myaddr2line);
+            pBlockHeader->backTrace(memReport);
+            i++ ;
+        }
         // Clean up.
         free(ppBlockHeader);