mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-03 17:56:21 +03:00
OCC22256 Add mechanism based on malloc/free callback for debugging memory problems
This commit is contained in:
MSV,AGV
bugmaster
parent
ed48237999
commit
7af17f1e1a
@ -57,6 +57,7 @@ static clock_t MDTV_CPU_CURRENT; // cpu time already used at last
|
|||||||
#endif
|
#endif
|
||||||
|
|
||||||
#include <Draw_Chronometer.hxx>
|
#include <Draw_Chronometer.hxx>
|
||||||
|
#include <OSD_MAllocHook.hxx>
|
||||||
|
|
||||||
#if defined (__hpux) || defined ( HPUX )
|
#if defined (__hpux) || defined ( HPUX )
|
||||||
#define RLIM_INFINITY 0x7fffffff
|
#define RLIM_INFINITY 0x7fffffff
|
||||||
@ -249,6 +250,131 @@ static Standard_Integer cpulimit(Draw_Interpretor& di, Standard_Integer n, const
|
|||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : mallochook
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
static Standard_Integer mallochook(Draw_Interpretor& di, Standard_Integer n,
|
||||||
|
const char** a)
|
||||||
|
{
|
||||||
|
if (n < 2)
|
||||||
|
{
|
||||||
|
di << "\
|
||||||
|
usage: mallochook cmd\n\
|
||||||
|
where cmd is one of:\n\
|
||||||
|
set [<op>] - set callback to malloc/free; op is one of the following:\n\
|
||||||
|
0 - set callback to NULL,\n\
|
||||||
|
1 - set callback OSD_MAllocHook::CollectBySize (default)\n\
|
||||||
|
2 - set callback OSD_MAllocHook::LogFileHandler\n\
|
||||||
|
reset - reset the CollectBySize handler\n\
|
||||||
|
report1 [<outfile>]\n\
|
||||||
|
- write report from CollectBySize handler in <outfile>\n\
|
||||||
|
open [<logfile>]\n\
|
||||||
|
- open file for writing the log with LogFileHandler\n\
|
||||||
|
close - close the log file with LogFileHandler\n\
|
||||||
|
report2 [<flag>] [<logfile>] [<outfile>]\n\
|
||||||
|
- scan <logfile> written with LogFileHandler\n\
|
||||||
|
and make synthesized report in <outfile>; <flag> can be:\n\
|
||||||
|
0 - simple stats by sizes (default),\n\
|
||||||
|
1 - with alive allocation numbers\n\
|
||||||
|
By default <logfile> is \"mem-log.txt\", <outfile> is \"mem-stat.txt\""
|
||||||
|
<< "\n";
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
if (strcmp(a[1], "set") == 0)
|
||||||
|
{
|
||||||
|
int aType = (n > 2 ? atoi(a[2]) : 1);
|
||||||
|
if (aType < 0 || aType > 2)
|
||||||
|
{
|
||||||
|
di << "unknown op of the command set" << "\n";
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
else if (aType == 0)
|
||||||
|
{
|
||||||
|
OSD_MAllocHook::SetCallback(NULL);
|
||||||
|
di << "callback is unset" << "\n";
|
||||||
|
}
|
||||||
|
else if (aType == 1)
|
||||||
|
{
|
||||||
|
OSD_MAllocHook::SetCallback(OSD_MAllocHook::GetCollectBySize());
|
||||||
|
di << "callback is set to CollectBySize" << "\n";
|
||||||
|
}
|
||||||
|
else //if (aType == 2)
|
||||||
|
{
|
||||||
|
OSD_MAllocHook::SetCallback(OSD_MAllocHook::GetLogFileHandler());
|
||||||
|
di << "callback is set to LogFileHandler" << "\n";
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (strcmp(a[1], "reset") == 0)
|
||||||
|
{
|
||||||
|
OSD_MAllocHook::GetCollectBySize()->Reset();
|
||||||
|
di << "CollectBySize handler is reset" << "\n";
|
||||||
|
}
|
||||||
|
else if (strcmp(a[1], "open") == 0)
|
||||||
|
{
|
||||||
|
const char* aFileName = (n > 2 ? a[2] : "mem-log.txt");
|
||||||
|
if (!OSD_MAllocHook::GetLogFileHandler()->Open(aFileName))
|
||||||
|
{
|
||||||
|
di << "cannot create file " << aFileName << " for writing" << "\n";
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
di << "log file " << aFileName << " is opened for writing" << "\n";
|
||||||
|
}
|
||||||
|
else if (strcmp(a[1], "close") == 0)
|
||||||
|
{
|
||||||
|
OSD_MAllocHook::GetLogFileHandler()->Close();
|
||||||
|
di << "log file is closed" << "\n";
|
||||||
|
}
|
||||||
|
else if (strcmp(a[1], "report1") == 0)
|
||||||
|
{
|
||||||
|
const char* aOutFile = "mem-stat.txt";
|
||||||
|
if (n > 2)
|
||||||
|
aOutFile = a[2];
|
||||||
|
if (OSD_MAllocHook::GetCollectBySize()->MakeReport(aOutFile))
|
||||||
|
{
|
||||||
|
di << "report " << aOutFile << " has been created" << "\n";
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
di << "cannot create report " << aOutFile << "\n";
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (strcmp(a[1], "report2") == 0)
|
||||||
|
{
|
||||||
|
Standard_Boolean includeAlive = Standard_False;
|
||||||
|
const char* aLogFile = "mem-log.txt";
|
||||||
|
const char* aOutFile = "mem-stat.txt";
|
||||||
|
if (n > 2)
|
||||||
|
{
|
||||||
|
includeAlive = (atoi(a[2]) != 0);
|
||||||
|
if (n > 3)
|
||||||
|
{
|
||||||
|
aLogFile = a[3];
|
||||||
|
if (n > 4)
|
||||||
|
aOutFile = a[4];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (OSD_MAllocHook::LogFileHandler::MakeReport(aLogFile, aOutFile, includeAlive))
|
||||||
|
{
|
||||||
|
di << "report " << aOutFile << " has been created" << "\n";
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
di << "cannot create report " << aOutFile << " from the log file "
|
||||||
|
<< aLogFile << "\n";
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
di << "unrecognized command " << a[1] << "\n";
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
void Draw::BasicCommands(Draw_Interpretor& theCommands)
|
void Draw::BasicCommands(Draw_Interpretor& theCommands)
|
||||||
{
|
{
|
||||||
@ -270,4 +396,7 @@ void Draw::BasicCommands(Draw_Interpretor& theCommands)
|
|||||||
__FILE__,chronom,g);
|
__FILE__,chronom,g);
|
||||||
theCommands.Add("dchrono","dchrono [ name start/stop/reset/show]",
|
theCommands.Add("dchrono","dchrono [ name start/stop/reset/show]",
|
||||||
__FILE__,dchronom,g);
|
__FILE__,dchronom,g);
|
||||||
|
theCommands.Add("mallochook",
|
||||||
|
"debug memory allocation/deallocation, w/o args for help",
|
||||||
|
__FILE__, mallochook, g);
|
||||||
}
|
}
|
||||||
|
|||||||
@ -23,3 +23,5 @@ OSD_Localizer.cxx
|
|||||||
OSD_PerfMeter.c
|
OSD_PerfMeter.c
|
||||||
OSD_PerfMeter.h
|
OSD_PerfMeter.h
|
||||||
OSD_PerfMeter.hxx
|
OSD_PerfMeter.hxx
|
||||||
|
OSD_MAllocHook.cxx
|
||||||
|
OSD_MAllocHook.hxx
|
||||||
|
|||||||
541
src/OSD/OSD_MAllocHook.cxx
Executable file
541
src/OSD/OSD_MAllocHook.cxx
Executable file
@ -0,0 +1,541 @@
|
|||||||
|
// File: OSD_MAllocHook.cxx
|
||||||
|
// Created: 04.02.2011
|
||||||
|
// Author: Mikhail SAZONOV
|
||||||
|
// Copyright: Open CASCADE S.A.S. 2011
|
||||||
|
|
||||||
|
#include <OSD_MAllocHook.hxx>
|
||||||
|
|
||||||
|
#ifndef WNT
|
||||||
|
#if !defined __STDC_LIMIT_MACROS
|
||||||
|
#define __STDC_LIMIT_MACROS
|
||||||
|
#endif
|
||||||
|
#include <stdint.h>
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#include <set>
|
||||||
|
#include <map>
|
||||||
|
|
||||||
|
#define MAX_STR 80
|
||||||
|
|
||||||
|
static OSD_MAllocHook::Callback* MypCurrentCallback = NULL;
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : GetCallback
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
OSD_MAllocHook::Callback* OSD_MAllocHook::GetCallback()
|
||||||
|
{
|
||||||
|
return MypCurrentCallback;
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : GetLogFileHandler
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
OSD_MAllocHook::LogFileHandler* OSD_MAllocHook::GetLogFileHandler()
|
||||||
|
{
|
||||||
|
static LogFileHandler MyHandler;
|
||||||
|
return &MyHandler;
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : GetCollectBySize
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
OSD_MAllocHook::CollectBySize* OSD_MAllocHook::GetCollectBySize()
|
||||||
|
{
|
||||||
|
static CollectBySize MyHandler;
|
||||||
|
return &MyHandler;
|
||||||
|
}
|
||||||
|
|
||||||
|
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||||
|
// Platform-dependent methods
|
||||||
|
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||||
|
|
||||||
|
#ifdef WNT
|
||||||
|
#include <crtdbg.h>
|
||||||
|
|
||||||
|
static long getRequestNum(void* pvData, long lRequest, size_t& theSize)
|
||||||
|
{
|
||||||
|
if (_CrtIsValidHeapPointer(pvData))
|
||||||
|
{
|
||||||
|
#if _MSC_VER == 1500 // VS 2008
|
||||||
|
#define nNoMansLandSize 4
|
||||||
|
// the header struct is taken from crt/src/dbgint.h
|
||||||
|
struct _CrtMemBlockHeader
|
||||||
|
{
|
||||||
|
#ifdef _WIN64
|
||||||
|
int nBlockUse;
|
||||||
|
size_t nDataSize;
|
||||||
|
#else
|
||||||
|
size_t nDataSize;
|
||||||
|
int nBlockUse;
|
||||||
|
#endif
|
||||||
|
long lRequest;
|
||||||
|
unsigned char gap[nNoMansLandSize];
|
||||||
|
};
|
||||||
|
_CrtMemBlockHeader* aHeader = ((_CrtMemBlockHeader*)pvData)-1;
|
||||||
|
theSize = aHeader->nDataSize;
|
||||||
|
return aHeader->lRequest;
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
return lRequest;
|
||||||
|
}
|
||||||
|
|
||||||
|
int __cdecl MyAllocHook(int nAllocType,
|
||||||
|
void * pvData,
|
||||||
|
size_t nSize,
|
||||||
|
int nBlockUse,
|
||||||
|
long lRequest,
|
||||||
|
const unsigned char * /*szFileName*/,
|
||||||
|
int /*nLine*/)
|
||||||
|
{
|
||||||
|
if (nBlockUse == _CRT_BLOCK || // Ignore internal C runtime library allocations
|
||||||
|
MypCurrentCallback == NULL)
|
||||||
|
return(1);
|
||||||
|
|
||||||
|
if (nAllocType == _HOOK_ALLOC)
|
||||||
|
MypCurrentCallback->AllocEvent(nSize, lRequest);
|
||||||
|
else if (nAllocType == _HOOK_FREE)
|
||||||
|
{
|
||||||
|
// for free hook, lRequest is not defined,
|
||||||
|
// but we can take it from the CRT mem block header
|
||||||
|
size_t aSize = 0;
|
||||||
|
lRequest = getRequestNum(pvData, lRequest, aSize);
|
||||||
|
MypCurrentCallback->FreeEvent(pvData, aSize, lRequest);
|
||||||
|
}
|
||||||
|
else // _HOOK_REALLOC
|
||||||
|
{
|
||||||
|
// for realloc hook, lRequest shows the new request,
|
||||||
|
// and we should get request number for old block
|
||||||
|
size_t anOldSize = 0;
|
||||||
|
long anOldRequest = getRequestNum(pvData, 0, anOldSize);
|
||||||
|
MypCurrentCallback->FreeEvent(pvData, anOldSize, anOldRequest);
|
||||||
|
MypCurrentCallback->AllocEvent(nSize, lRequest);
|
||||||
|
}
|
||||||
|
|
||||||
|
return(1); // Allow the memory operation to proceed
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : SetCallback
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
void OSD_MAllocHook::SetCallback(Callback* theCB)
|
||||||
|
{
|
||||||
|
MypCurrentCallback = theCB;
|
||||||
|
if (theCB == NULL)
|
||||||
|
_CrtSetAllocHook(NULL);
|
||||||
|
else
|
||||||
|
_CrtSetAllocHook(MyAllocHook);
|
||||||
|
}
|
||||||
|
|
||||||
|
#else // ! WNT
|
||||||
|
|
||||||
|
// Not yet implemented for non-WNT platform
|
||||||
|
|
||||||
|
void OSD_MAllocHook::SetCallback(Callback* theCB)
|
||||||
|
{
|
||||||
|
MypCurrentCallback = theCB;
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // WNT
|
||||||
|
|
||||||
|
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||||
|
// LogFileHandler handler methods
|
||||||
|
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : LogFileHandler::LogFileHandler
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
OSD_MAllocHook::LogFileHandler::LogFileHandler()
|
||||||
|
: myLogFile(NULL),
|
||||||
|
myBreakSize(0)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : LogFileHandler::~LogFileHandler
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
OSD_MAllocHook::LogFileHandler::~LogFileHandler()
|
||||||
|
{
|
||||||
|
Close();
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : LogFileHandler::Open
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
Standard_Boolean OSD_MAllocHook::LogFileHandler::Open(const char* theFileName)
|
||||||
|
{
|
||||||
|
Close();
|
||||||
|
myLogFile = fopen(theFileName, "w");
|
||||||
|
if (myLogFile != NULL)
|
||||||
|
{
|
||||||
|
fputs("Operation type; Request Number; Block Size\n", myLogFile);
|
||||||
|
fputs("------------------------------------------\n", myLogFile);
|
||||||
|
}
|
||||||
|
return myLogFile != NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : LogFileHandler::Close
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
void OSD_MAllocHook::LogFileHandler::Close()
|
||||||
|
{
|
||||||
|
if (myLogFile != NULL)
|
||||||
|
{
|
||||||
|
fclose(myLogFile);
|
||||||
|
myLogFile = NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : LogFileHandler::MakeReport
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
struct StorageInfo
|
||||||
|
{
|
||||||
|
Standard_Size size;
|
||||||
|
int nbAlloc;
|
||||||
|
int nbFree;
|
||||||
|
int nbLeftPeak;
|
||||||
|
std::set<unsigned long>* alive;
|
||||||
|
StorageInfo()
|
||||||
|
: size(0), nbAlloc(0), nbFree(0), nbLeftPeak(0), alive(NULL) {}
|
||||||
|
StorageInfo(Standard_Size theSize)
|
||||||
|
: size(theSize), nbAlloc(0), nbFree(0), nbLeftPeak(0), alive(NULL) {}
|
||||||
|
~StorageInfo()
|
||||||
|
{
|
||||||
|
if (alive)
|
||||||
|
delete alive;
|
||||||
|
}
|
||||||
|
std::set<unsigned long>& Alive()
|
||||||
|
{
|
||||||
|
if (!alive)
|
||||||
|
alive = new std::set<unsigned long>;
|
||||||
|
return *alive;
|
||||||
|
}
|
||||||
|
const std::set<unsigned long>& Alive() const
|
||||||
|
{
|
||||||
|
return *alive;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
inline bool operator < (const StorageInfo& one, const StorageInfo& two)
|
||||||
|
{
|
||||||
|
return one.size < two.size;
|
||||||
|
}
|
||||||
|
|
||||||
|
Standard_Boolean OSD_MAllocHook::LogFileHandler::MakeReport
|
||||||
|
(const char* theLogFile,
|
||||||
|
const char* theOutFile,
|
||||||
|
const Standard_Boolean theIncludeAlive)
|
||||||
|
{
|
||||||
|
// open log file
|
||||||
|
FILE* aLogFile = fopen(theLogFile, "r");
|
||||||
|
if (aLogFile == NULL)
|
||||||
|
return Standard_False;
|
||||||
|
|
||||||
|
// skip 2 header lines
|
||||||
|
char aStr[MAX_STR];
|
||||||
|
if (fgets(aStr, MAX_STR-1, aLogFile) == NULL)
|
||||||
|
{
|
||||||
|
fclose(aLogFile);
|
||||||
|
return Standard_False;
|
||||||
|
}
|
||||||
|
if (fgets(aStr, MAX_STR-1, aLogFile) == NULL)
|
||||||
|
{
|
||||||
|
fclose(aLogFile);
|
||||||
|
return Standard_False;
|
||||||
|
}
|
||||||
|
|
||||||
|
// scan the log file
|
||||||
|
size_t aTotalLeftSize = 0;
|
||||||
|
size_t aTotalPeakSize = 0;
|
||||||
|
std::set<StorageInfo> aStMap;
|
||||||
|
while (fgets(aStr, MAX_STR-1, aLogFile) != NULL)
|
||||||
|
{
|
||||||
|
// detect operation type, request number and block size
|
||||||
|
unsigned long aReqNum, aSize;
|
||||||
|
char* aType = aStr;
|
||||||
|
char* pStr = aStr;
|
||||||
|
//sscanf(aStr, "%5s %lu %lu", aType, &aReqNum, &aSize);
|
||||||
|
while (*pStr != ' ' && *pStr) pStr++;
|
||||||
|
*pStr++ = '\0';
|
||||||
|
while (*pStr == ' ' && *pStr) pStr++;
|
||||||
|
aReqNum = atol(pStr);
|
||||||
|
while (*pStr != ' ' && *pStr) pStr++;
|
||||||
|
while (*pStr == ' ' && *pStr) pStr++;
|
||||||
|
aSize = atol(pStr);
|
||||||
|
Standard_Boolean isAlloc = Standard_False;
|
||||||
|
if (strcmp(aType, "alloc") == 0)
|
||||||
|
{
|
||||||
|
isAlloc = Standard_True;
|
||||||
|
}
|
||||||
|
else if (strcmp(aType, "free") != 0)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
// collect statistics by storage size
|
||||||
|
StorageInfo aSuchInfo(aSize);
|
||||||
|
std::set<StorageInfo>::iterator aFound = aStMap.find(aSuchInfo);
|
||||||
|
if (aFound == aStMap.end())
|
||||||
|
aFound = aStMap.insert(aSuchInfo).first;
|
||||||
|
StorageInfo& aInfo = const_cast<StorageInfo&>(*aFound);
|
||||||
|
if (isAlloc)
|
||||||
|
{
|
||||||
|
if (aInfo.nbAlloc + 1 > 0)
|
||||||
|
aInfo.nbAlloc++;
|
||||||
|
aTotalLeftSize += aSize;
|
||||||
|
if (aTotalLeftSize > aTotalPeakSize)
|
||||||
|
aTotalPeakSize = aTotalLeftSize;
|
||||||
|
int nbLeft = aInfo.nbAlloc - aInfo.nbFree;
|
||||||
|
if (nbLeft > aInfo.nbLeftPeak)
|
||||||
|
aInfo.nbLeftPeak = nbLeft;
|
||||||
|
aInfo.Alive().insert(aReqNum);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
std::set<unsigned long>::iterator aFoundReqNum =
|
||||||
|
aInfo.Alive().find(aReqNum);
|
||||||
|
if (aFoundReqNum == aInfo.Alive().end())
|
||||||
|
// freeing non-registered block, skip it
|
||||||
|
continue;
|
||||||
|
aTotalLeftSize -= aSize;
|
||||||
|
aInfo.Alive().erase(aFoundReqNum);
|
||||||
|
if (aInfo.nbAlloc + 1 > 0)
|
||||||
|
aInfo.nbFree++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fclose(aLogFile);
|
||||||
|
|
||||||
|
// print the report
|
||||||
|
FILE* aRepFile = fopen(theOutFile, "w");
|
||||||
|
if (aRepFile == NULL)
|
||||||
|
return Standard_False;
|
||||||
|
fprintf(aRepFile, "%10s %10s %10s %10s %10s %10s %10s\n",
|
||||||
|
"BlockSize", "NbAlloc", "NbLeft", "NbLeftPeak",
|
||||||
|
"AllocSize", "LeftSize", "PeakSize");
|
||||||
|
Standard_Size aTotAlloc = 0;
|
||||||
|
for (std::set<StorageInfo>::const_iterator it = aStMap.begin();
|
||||||
|
it != aStMap.end(); ++it)
|
||||||
|
{
|
||||||
|
const StorageInfo& aInfo = *it;
|
||||||
|
Standard_Integer nbLeft = aInfo.nbAlloc - aInfo.nbFree;
|
||||||
|
Standard_Size aSizeAlloc = aInfo.nbAlloc * aInfo.size;
|
||||||
|
Standard_Size aSizeLeft = nbLeft * aInfo.size;
|
||||||
|
Standard_Size aSizePeak = aInfo.nbLeftPeak * aInfo.size;
|
||||||
|
fprintf(aRepFile, "%10d %10d %10d %10d %10Iu %10Iu %10Iu\n", aInfo.size,
|
||||||
|
aInfo.nbAlloc, nbLeft, aInfo.nbLeftPeak,
|
||||||
|
aSizeAlloc, aSizeLeft, aSizePeak);
|
||||||
|
if (aTotAlloc + aSizeAlloc < aTotAlloc) // overflow ?
|
||||||
|
aTotAlloc = SIZE_MAX;
|
||||||
|
else
|
||||||
|
aTotAlloc += aSizeAlloc;
|
||||||
|
if (theIncludeAlive && !aInfo.Alive().empty())
|
||||||
|
{
|
||||||
|
for (std::set<unsigned long>::const_iterator it1 = aInfo.alive->begin();
|
||||||
|
it1 != aInfo.alive->end(); ++it1)
|
||||||
|
fprintf(aRepFile, "%10lu\n", *it1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fprintf(aRepFile, "%10s %10s %10s %10s%c%10Iu %10Iu %10Iu\n", "Total:",
|
||||||
|
"", "", "", (aTotAlloc == SIZE_MAX ? '>' : ' '), aTotAlloc,
|
||||||
|
aTotalLeftSize, aTotalPeakSize);
|
||||||
|
fclose(aRepFile);
|
||||||
|
return Standard_True;
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : LogFileHandler::AllocEvent
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
void OSD_MAllocHook::LogFileHandler::AllocEvent
|
||||||
|
(size_t theSize,
|
||||||
|
long theRequestNum)
|
||||||
|
{
|
||||||
|
if (myLogFile != NULL)
|
||||||
|
{
|
||||||
|
myMutex.Lock();
|
||||||
|
fprintf(myLogFile, "alloc %10lu %10u\n", theRequestNum, theSize);
|
||||||
|
myMutex.Unlock();
|
||||||
|
if (myBreakSize == theSize)
|
||||||
|
{
|
||||||
|
int a = 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : LogFileHandler::FreeEvent
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
void OSD_MAllocHook::LogFileHandler::FreeEvent
|
||||||
|
(void* /*theData*/,
|
||||||
|
size_t theSize,
|
||||||
|
long theRequestNum)
|
||||||
|
{
|
||||||
|
if (myLogFile != NULL)
|
||||||
|
{
|
||||||
|
myMutex.Lock();
|
||||||
|
fprintf(myLogFile, "free %10lu %10u\n", theRequestNum, theSize);
|
||||||
|
myMutex.Unlock();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||||
|
// CollectBySize handler methods
|
||||||
|
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : CollectBySize::CollectBySize
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
OSD_MAllocHook::CollectBySize::CollectBySize()
|
||||||
|
: myArray(NULL),
|
||||||
|
myTotalLeftSize(0),
|
||||||
|
myTotalPeakSize(0),
|
||||||
|
myBreakSize(0)
|
||||||
|
{
|
||||||
|
Reset();
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : CollectBySize::~CollectBySize
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
OSD_MAllocHook::CollectBySize::~CollectBySize()
|
||||||
|
{
|
||||||
|
if (myArray != NULL)
|
||||||
|
delete [] myArray;
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : CollectBySize::Reset
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
#define MAX_ALLOC_SIZE 2000000u
|
||||||
|
|
||||||
|
void OSD_MAllocHook::CollectBySize::Reset()
|
||||||
|
{
|
||||||
|
myMutex.Lock();
|
||||||
|
if (myArray == NULL)
|
||||||
|
myArray = new Numbers[MAX_ALLOC_SIZE];
|
||||||
|
else
|
||||||
|
{
|
||||||
|
for (int i = 0; i < MAX_ALLOC_SIZE; i++)
|
||||||
|
myArray[i] = Numbers();
|
||||||
|
}
|
||||||
|
myTotalLeftSize = 0;
|
||||||
|
myTotalPeakSize = 0;
|
||||||
|
myMutex.Unlock();
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : CollectBySize::MakeReport
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
Standard_Boolean OSD_MAllocHook::CollectBySize::MakeReport(const char* theOutFile)
|
||||||
|
{
|
||||||
|
// print the report
|
||||||
|
FILE* aRepFile = fopen(theOutFile, "w");
|
||||||
|
if (aRepFile == NULL)
|
||||||
|
return Standard_False;
|
||||||
|
fprintf(aRepFile, "%10s %10s %10s %10s %10s %10s %10s\n",
|
||||||
|
"BlockSize", "NbAlloc", "NbLeft", "NbLeftPeak",
|
||||||
|
"AllocSize", "LeftSize", "PeakSize");
|
||||||
|
Standard_Size aTotAlloc = 0;
|
||||||
|
for (int i = 0; i < MAX_ALLOC_SIZE; i++)
|
||||||
|
{
|
||||||
|
if (myArray[i].nbAlloc > 0)
|
||||||
|
{
|
||||||
|
Standard_Integer nbLeft = myArray[i].nbAlloc - myArray[i].nbFree;
|
||||||
|
if (nbLeft < 0)
|
||||||
|
nbLeft = 0;
|
||||||
|
int aSize = i + 1;
|
||||||
|
Standard_Size aSizeAlloc = myArray[i].nbAlloc * aSize;
|
||||||
|
Standard_Size aSizeLeft = nbLeft * aSize;
|
||||||
|
Standard_Size aSizePeak = myArray[i].nbLeftPeak * aSize;
|
||||||
|
fprintf(aRepFile, "%10d %10d %10d %10d %10Iu %10Iu %10Iu\n", aSize,
|
||||||
|
myArray[i].nbAlloc, nbLeft, myArray[i].nbLeftPeak,
|
||||||
|
aSizeAlloc, aSizeLeft, aSizePeak);
|
||||||
|
if (aTotAlloc + aSizeAlloc < aTotAlloc) // overflow ?
|
||||||
|
aTotAlloc = SIZE_MAX;
|
||||||
|
else
|
||||||
|
aTotAlloc += aSizeAlloc;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fprintf(aRepFile, "%10s %10s %10s %10s%c%10Iu %10Iu %10Iu\n", "Total:",
|
||||||
|
"", "", "", (aTotAlloc == SIZE_MAX ? '>' : ' '), aTotAlloc,
|
||||||
|
myTotalLeftSize, myTotalPeakSize);
|
||||||
|
fclose(aRepFile);
|
||||||
|
return Standard_True;
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : CollectBySize::AllocEvent
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
void OSD_MAllocHook::CollectBySize::AllocEvent
|
||||||
|
(size_t theSize,
|
||||||
|
long /*theRequestNum*/)
|
||||||
|
{
|
||||||
|
if (myBreakSize == theSize)
|
||||||
|
{
|
||||||
|
int a = 1;
|
||||||
|
}
|
||||||
|
if (theSize > 0)
|
||||||
|
{
|
||||||
|
myMutex.Lock();
|
||||||
|
int ind = (theSize > MAX_ALLOC_SIZE ? MAX_ALLOC_SIZE-1 : (int)(theSize-1));
|
||||||
|
if (myArray[ind].nbAlloc + 1 > 0)
|
||||||
|
myArray[ind].nbAlloc++;
|
||||||
|
myTotalLeftSize += theSize;
|
||||||
|
int nbLeft = myArray[ind].nbAlloc - myArray[ind].nbFree;
|
||||||
|
if (nbLeft > myArray[ind].nbLeftPeak)
|
||||||
|
myArray[ind].nbLeftPeak = nbLeft;
|
||||||
|
if (myTotalLeftSize > myTotalPeakSize)
|
||||||
|
myTotalPeakSize = myTotalLeftSize;
|
||||||
|
myMutex.Unlock();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
//=======================================================================
|
||||||
|
//function : CollectBySize::FreeEvent
|
||||||
|
//purpose :
|
||||||
|
//=======================================================================
|
||||||
|
|
||||||
|
void OSD_MAllocHook::CollectBySize::FreeEvent
|
||||||
|
(void* /*theData*/,
|
||||||
|
size_t theSize,
|
||||||
|
long /*theRequestNum*/)
|
||||||
|
{
|
||||||
|
if (theSize > 0 && myTotalLeftSize >= theSize)
|
||||||
|
{
|
||||||
|
myMutex.Lock();
|
||||||
|
int ind = (theSize > MAX_ALLOC_SIZE ? MAX_ALLOC_SIZE-1 : (int)(theSize-1));
|
||||||
|
if (myArray[ind].nbFree + 1 > 0)
|
||||||
|
myArray[ind].nbFree++;
|
||||||
|
myTotalLeftSize -= theSize;
|
||||||
|
myMutex.Unlock();
|
||||||
|
}
|
||||||
|
}
|
||||||
156
src/OSD/OSD_MAllocHook.hxx
Executable file
156
src/OSD/OSD_MAllocHook.hxx
Executable file
@ -0,0 +1,156 @@
|
|||||||
|
// File: OSD_MAllocHook.hxx
|
||||||
|
// Created: 03.02.2011
|
||||||
|
// Author: Mikhail SAZONOV
|
||||||
|
// Copyright: Open CASCADE S.A.S. 2011
|
||||||
|
|
||||||
|
#ifndef _OSD_MAllocHook_HeaderFile
|
||||||
|
#define _OSD_MAllocHook_HeaderFile
|
||||||
|
|
||||||
|
#include <Standard_TypeDef.hxx>
|
||||||
|
#include <Standard_Mutex.hxx>
|
||||||
|
#include <stdio.h>
|
||||||
|
|
||||||
|
/**
|
||||||
|
* This class provides the possibility to set callback for memory
|
||||||
|
* allocation/deallocation.
|
||||||
|
* On MS Windows, it works only in Debug builds. It relies on the
|
||||||
|
* debug CRT function _CrtSetAllocHook (see MSDN for help).
|
||||||
|
*/
|
||||||
|
class OSD_MAllocHook
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/**
|
||||||
|
* Interface of a class that should handle allocation/deallocation events
|
||||||
|
*/
|
||||||
|
class Callback
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
//! Allocation event handler
|
||||||
|
/**
|
||||||
|
* It is called when allocation is done
|
||||||
|
* @param theSize
|
||||||
|
* the size of the memory block in bytes
|
||||||
|
* @param theRequestNum
|
||||||
|
* the allocation order number of the memory block
|
||||||
|
*/
|
||||||
|
virtual void AllocEvent
|
||||||
|
(size_t theSize,
|
||||||
|
long theRequestNum) = 0;
|
||||||
|
|
||||||
|
//! Freeing event handler
|
||||||
|
/**
|
||||||
|
* It is called when the block is freed
|
||||||
|
* @param theData
|
||||||
|
* the pointer to the user data section of the memory block
|
||||||
|
* @param theSize
|
||||||
|
* the size of the memory block in bytes
|
||||||
|
* @param theRequestNum
|
||||||
|
* the allocation order number of the memory block
|
||||||
|
*/
|
||||||
|
virtual void FreeEvent
|
||||||
|
(void* theData,
|
||||||
|
size_t theSize,
|
||||||
|
long theRequestNum) = 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Implementation of the handler that collects all events
|
||||||
|
* to the log file. It contains the method to generate the report
|
||||||
|
* from the log file.
|
||||||
|
*/
|
||||||
|
class LogFileHandler: public Callback
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
//! Constructor
|
||||||
|
Standard_EXPORT LogFileHandler();
|
||||||
|
|
||||||
|
//! Destructor
|
||||||
|
Standard_EXPORT ~LogFileHandler();
|
||||||
|
|
||||||
|
//! Create the file and start collecting events.
|
||||||
|
//! Return false if the file with the given name cannot be created.
|
||||||
|
Standard_EXPORT Standard_Boolean Open(const char* theFileName);
|
||||||
|
|
||||||
|
//! Close the file and stop collecting events
|
||||||
|
Standard_EXPORT void Close();
|
||||||
|
|
||||||
|
//! Make synthesized report on the given log file.
|
||||||
|
/**
|
||||||
|
* Generate an easy to use report in the
|
||||||
|
* new file with the given name, taking the given log file as input.
|
||||||
|
* If theIncludeAlive is true then
|
||||||
|
* include into the report the alive allocation numbers.
|
||||||
|
*/
|
||||||
|
Standard_EXPORT static Standard_Boolean MakeReport
|
||||||
|
(const char* theLogFile,
|
||||||
|
const char* theOutFile,
|
||||||
|
const Standard_Boolean theIncludeAlive = Standard_False);
|
||||||
|
|
||||||
|
Standard_EXPORT virtual void AllocEvent(size_t, long);
|
||||||
|
Standard_EXPORT virtual void FreeEvent(void*, size_t, long);
|
||||||
|
|
||||||
|
private:
|
||||||
|
FILE* myLogFile;
|
||||||
|
Standard_Mutex myMutex;
|
||||||
|
size_t myBreakSize;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Implementation of the handler that collects numbers of
|
||||||
|
* allocations/deallocations for each block size directly in the memory.
|
||||||
|
*/
|
||||||
|
class CollectBySize: public Callback
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
//! Constructor
|
||||||
|
Standard_EXPORT CollectBySize();
|
||||||
|
|
||||||
|
//! Destructor
|
||||||
|
Standard_EXPORT ~CollectBySize();
|
||||||
|
|
||||||
|
//! Reset the buffer and start collecting events.
|
||||||
|
Standard_EXPORT void Reset();
|
||||||
|
|
||||||
|
//! Write report in the given file.
|
||||||
|
Standard_EXPORT Standard_Boolean MakeReport(const char* theOutFile);
|
||||||
|
|
||||||
|
Standard_EXPORT virtual void AllocEvent(size_t, long);
|
||||||
|
Standard_EXPORT virtual void FreeEvent(void*, size_t, long);
|
||||||
|
|
||||||
|
private:
|
||||||
|
struct Numbers
|
||||||
|
{
|
||||||
|
int nbAlloc;
|
||||||
|
int nbFree;
|
||||||
|
int nbLeftPeak;
|
||||||
|
Numbers() : nbAlloc(0), nbFree(0), nbLeftPeak(0) {}
|
||||||
|
};
|
||||||
|
|
||||||
|
Standard_Mutex myMutex;
|
||||||
|
Numbers* myArray;
|
||||||
|
size_t myTotalLeftSize;
|
||||||
|
size_t myTotalPeakSize;
|
||||||
|
size_t myBreakSize;
|
||||||
|
};
|
||||||
|
|
||||||
|
//! Set handler of allocation/deallocation events
|
||||||
|
/**
|
||||||
|
* You can pass here any implementation. For easy start, you can try
|
||||||
|
* with the predefined handler LogFileHandler, which static instance
|
||||||
|
* is returned by GetLogFileHandler().
|
||||||
|
* To clear the handler, pass NULL here.
|
||||||
|
*/
|
||||||
|
Standard_EXPORT static void SetCallback
|
||||||
|
(Callback* theCB);
|
||||||
|
|
||||||
|
//! Get current handler of allocation/deallocation events
|
||||||
|
Standard_EXPORT static Callback* GetCallback();
|
||||||
|
|
||||||
|
//! Get static instance of LogFileHandler handler
|
||||||
|
Standard_EXPORT static LogFileHandler* GetLogFileHandler();
|
||||||
|
|
||||||
|
//! Get static instance of CollectBySize handler
|
||||||
|
Standard_EXPORT static CollectBySize* GetCollectBySize();
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif /* _OSD_MAllocHook_HeaderFile */
|
||||||
Loading…
x
Reference in New Issue
Block a user