开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
memprb.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：18k
源码类别：

Symbian

开发平台：

C/C++

memprb.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. /****************************************************************************
  37.  *  Defines
  38.  */
  39. #define MAX_DUMPLINE_LENGTH 1024
  40. #define DUMPBLOCKID_START_CHAR '{'
  41. #define DUMPMEMUSED_START_CHAR ','
  42. #define DUMPDATA_START_STRING " Data:"
  44. #define mem_max(x, y) ((x) > (y) ? (x) : (y))
  47. /****************************************************************************
  48.  *  Includes
  49.  */
  50. #ifdef _DEBUG
  51. #include <io.h>
  53. #include <stdio.h>
  54. #include <string.h>
  55. #include <malloc.h>
  56. #endif // _DEBUG
  58. #include "hxassert.h"
  59. #include "hxmemprb.h"
  62. /****************************************************************************
  63.  *  Locals
  64.  */
  65. #ifdef _DEBUG
  66. static LONG32 CalcUsedMem(_CrtMemState *MemState, BOOL bWithCrt);
  69. static const MemBlockInfo EmptyMemBlockInfo =
  70. {
  71.     0,
  72.     0,
  73.     NULL,
  74.     NULL
  75. };
  77. CHXMemProbe* CHXMemProbe::mz_pActiveProbe = NULL;
  79. BOOL CHXMemProbe::m_bMutexInitialized = FALSE;
  80. CRITICAL_SECTION CHXMemProbe::m_Mutex;
  81. #endif  /* _DEBUG */
  84. CHXMemProbe::CHXMemProbe(BOOL bIsFrozen)
  85. #ifdef _DEBUG
  86.     : m_bIsFrozen(TRUE),
  87. m_MemFreeze(EmptyMemBlockInfo),
  88. m_pMemFreezeIter(NULL),
  89. m_MemUsed(0),
  90. m_MemUsedWithCrt(0),
  91. m_MaxMemUsed(0),
  92. m_MaxMemUsedWithCrt(0),
  93. m_BaseMemUsed(0),
  94. m_BaseMemUsedWithCrt(0),
  95. m_pParent(NULL),
  96. m_pChild(NULL)
  97. #endif /* _DEBUG */
  98. {
  99. #ifdef _DEBUG
  100.     if (!m_bMutexInitialized)
  101.     {
  102. InitializeCriticalSection(&m_Mutex);
  103. m_bMutexInitialized = TRUE;
  104.     }
  106.     _CrtSetDbgFlag( _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) |
  107.     _CRTDBG_ALLOC_MEM_DF | 
  108.     _CRTDBG_CHECK_CRT_DF);
  110.     _CrtMemCheckpoint(&m_MemRefPoint);
  111.     m_MemFreezePoint = m_MemRefPoint;
  113.     if (!bIsFrozen)
  114.     {
  115. Reset();  // activate the probe
  116.     }
  117. #endif  /* _DEBUG */
  118. }
  121. CHXMemProbe::~CHXMemProbe()
  122. {
  123. #ifdef _DEBUG
  124.     if (!m_bIsFrozen)
  125.     {
  126. Freeze();
  127.     }
  128.     DestroyBlockInfo(m_MemFreeze);
  129. #endif  /* _DEBUG */
  130. }
  133. BOOL CHXMemProbe::IsRestored(BOOL bWithCrt)
  134. {
  135. #ifdef _DEBUG
  136.     BOOL bSignificantDiff;
  137.     _CrtMemState MemRefPointDiff;
  139.     if (!m_bIsFrozen)
  140.     {
  141. _CrtMemCheckpoint(&m_MemFreezePoint);
  142.     }
  144.     bSignificantDiff = _CrtMemDifference(&MemRefPointDiff, &m_MemRefPoint, &m_MemFreezePoint);
  146.     if (bWithCrt)
  147.     {
  148. return !bSignificantDiff;
  149.     }
  151.     return ((CalcUsedMem(&MemRefPointDiff, HXDBG_CLIENT_MEM) == 0) ? TRUE : FALSE);
  152. #else  /* _DEBUG */
  153.     return TRUE;
  154. #endif  /* _DEBUG */
  155. }
  158. LONG32 CHXMemProbe::GetMemUsed(BOOL bWithCrt, BOOL bWithBase, CHXMemProbe *pReferenceProbe)
  159. {
  160. #ifdef _DEBUG
  161.     LONG32 BaseMem;
  162.     _CrtMemState MemRefPointDiff;
  163.     
  164.     if (bWithBase)
  165.     {
  166. BaseMem = bWithCrt ? m_BaseMemUsedWithCrt : m_BaseMemUsed;
  168. if (pReferenceProbe != NULL)
  169. {
  170.     BaseMem -= (bWithCrt ? pReferenceProbe->m_BaseMemUsedWithCrt : pReferenceProbe->m_BaseMemUsed);
  171. }
  172.     }
  173.     else
  174.     {
  175. BaseMem = 0;
  176.     }
  178.     if (!m_bIsFrozen)
  179.     {
  180. _CrtMemCheckpoint(&m_MemFreezePoint);
  181.     }
  183.     (void) _CrtMemDifference(&MemRefPointDiff, &m_MemRefPoint, &m_MemFreezePoint);
  185.     return (BaseMem + CalcUsedMem(&MemRefPointDiff, bWithCrt));
  186. #else  /* DEBUG */
  187.     return 0;
  188. #endif  /* _DEBUG */
  189. }
  192. LONG32 CHXMemProbe::GetBaseMemUsed(BOOL bWithCrt)
  193. {
  194. #ifdef _DEBUG
  195.     return bWithCrt ? m_BaseMemUsedWithCrt : m_BaseMemUsed;
  196. #else  /* _DEBUG */
  197.     return 0;
  198. #endif  /* _DEBUG */
  199. }
  202. HX_RESULT CHXMemProbe::DumpMemUsedSinceReset(FILE *pFile, BOOL bWithCrt)
  203. {
  204. #ifdef _DEBUG
  205.     FILE *pTempFile;
  206.     char Buffer[MAX_DUMPLINE_LENGTH]; /* Flawfinder: ignore */
  207.     HX_RESULT RetVal = HXR_OK;
  209.     pTempFile = tmpfile();
  211.     if (pTempFile == NULL)
  212.     {
  213. RetVal = HXR_FAIL;
  214.     }
  216.     if (SUCCEEDED(RetVal))
  217.     {
  218. _DumpMemUsedSinceReset(pTempFile, bWithCrt);
  220. if (fseek(pTempFile, 0, SEEK_SET) != 0)
  221. {
  222.     RetVal = HXR_FAIL;
  223. }
  224.     }
  226.     while (SUCCEEDED(RetVal) && (fgets(Buffer, sizeof(Buffer), pTempFile) != NULL))
  227.     {
  228. if (fputs(Buffer, pFile) == EOF)
  229. {
  230.     RetVal = HXR_FAIL;
  231. }
  232.     }
  234.     if (pTempFile != NULL)
  235.     {
  236. fclose(pTempFile);
  237.     }
  239.     return RetVal;
  240. #endif  /* _DEBUG */
  242.     return HXR_OK;
  243. }
  246. #ifdef _DEBUG
  247. void CHXMemProbe::_DumpMemUsedSinceReset(FILE *pFile, BOOL bWithCrt)
  248. {
  249.     int OldFlag;
  250.     int NewFlag;
  251.     _HFILE hOldFile;
  252.     _HFILE hNewFile;
  253.     int OldMode;
  255.     // Set Debug Flag
  256.     OldFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
  257.     if (bWithCrt)
  258.     {
  259. NewFlag = OldFlag | _CRTDBG_CHECK_CRT_DF;
  260.     }
  261.     else
  262.     {
  263. NewFlag = OldFlag & (~_CRTDBG_CHECK_CRT_DF);
  264.     }
  266.     (void) _CrtSetDbgFlag(NewFlag);
  268.     // Set Output File
  269.     if (pFile == NULL)
  270.     {
  271. pFile = (FILE *) stdout;
  272.     }
  274.     hNewFile = (_HFILE) _get_osfhandle(_fileno(pFile));
  276.     OldMode = _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
  277.     hOldFile = _CrtSetReportFile(_CRT_WARN, hNewFile);
  279.     // Dump
  280.     _CrtMemDumpAllObjectsSince(&m_MemRefPoint);
  281.     
  282.     // Restore Debug Mode
  283.     (void) _CrtSetDbgFlag(OldFlag);
  284.     (void) _CrtSetReportMode(_CRT_WARN, OldMode);
  285.     (void) _CrtSetReportFile(_CRT_WARN, hOldFile);
  286. }
  287. #endif  /* _DEBUG */
  290. ULONG32 CHXMemProbe::GetMaxMemUsed(BOOL bWithCrt, BOOL bWithBase, CHXMemProbe *pReferenceProbe)
  291. {
  292. #ifdef _DEBUG
  293.     LONG32 BaseMem;
  294.     LONG32 MaxMem;
  296.     if (bWithBase)
  297.     {
  298. BaseMem = bWithCrt ? m_BaseMemUsedWithCrt : m_BaseMemUsed;
  300. if (pReferenceProbe != NULL)
  301. {
  302.     BaseMem -= (bWithCrt ? pReferenceProbe->m_BaseMemUsedWithCrt : pReferenceProbe->m_BaseMemUsed);
  303. }
  304.     }
  305.     else
  306.     {
  307. BaseMem = 0;
  308.     }
  310.     if (m_pChild == NULL)
  311.     {
  312. MaxMem = bWithCrt ? m_MaxMemUsedWithCrt : m_MaxMemUsed;
  313.     }
  314.     else
  315.     {
  316. LONG32 uChildMax;
  318. uChildMax = (LONG32) m_pChild->GetMaxMemUsed(bWithCrt, PNDBG_NOBASE_MEM);
  320. if (bWithCrt)
  321. {
  322.     MaxMem = mem_max(uChildMax + m_MemUsedWithCrt, m_MaxMemUsedWithCrt);
  323. }
  324. else
  325. {
  326.     MaxMem = mem_max(uChildMax + m_MemUsed, m_MaxMemUsed);
  327. }
  328.     }
  330.     return mem_max(BaseMem + MaxMem, 0);
  331. #else  /* DEBUG */
  332.     return 0;
  333. #endif  /* _DEBUG */
  334. }
  337. LONG32 CHXMemProbe::GetGlobalMemUsed(BOOL bWithCrt)
  338. {
  339. #ifdef _DEBUG
  340.     _CrtMemState MemRefPoint;
  342.     _CrtMemCheckpoint(&MemRefPoint);
  344.     return CalcUsedMem(&MemRefPoint, bWithCrt);
  345. #else  /* _DEBUG */
  346.     return 0;
  347. #endif  /* _DEBUG */
  348. }
  351. ULONG32 CHXMemProbe::GetGlobalMaxMemUsed(void)
  352. {
  353. #ifdef _DEBUG
  354.     _CrtMemState MemRefPoint;
  356.     _CrtMemCheckpoint(&MemRefPoint);
  358.     return (ULONG32) MemRefPoint.lHighWaterCount;
  359. #else  /* _DEBUG */
  360.     return 0;
  361. #endif  /* _DEBUG */
  362. }
  365. ULONG32 CHXMemProbe::SetGlobalMemBreak(ULONG32 uMemBlockId)
  366. {
  367. #ifdef _DEBUG
  368.     return _CrtSetBreakAlloc(uMemBlockId);
  369. #else  /* _DEBUG */
  370.     return 0;
  371. #endif  /* _DEBUG */
  372. }
  375. HX_RESULT CHXMemProbe::Reset(void)
  376. {
  377. #ifdef _DEBUG
  378.     if (!m_bMutexInitialized)
  379.     {
  380. InitializeCriticalSection(&m_Mutex);
  381. m_bMutexInitialized = TRUE;
  382.     }
  384.     if (!m_bIsFrozen)
  385.     {
  386. Freeze();
  387.     }
  389.     EnterCriticalSection(&m_Mutex);
  391.     DestroyBlockInfo(m_MemFreeze);
  393.     _CrtMemCheckpoint(&m_MemRefPoint);
  395.     m_MemUsed = 0;
  396.     m_MemUsedWithCrt = 0;
  397.     m_MaxMemUsed = 0;
  398.     m_MaxMemUsedWithCrt = 0;
  399.     m_BaseMemUsed = 0;
  400.     m_BaseMemUsedWithCrt = 0;
  402.     m_pChild = NULL;
  403.     m_pParent = mz_pActiveProbe;
  404.     if (m_pParent != NULL)
  405.     {
  406. m_pParent->m_pChild = this;
  408. m_BaseMemUsedWithCrt = m_pParent->m_MemUsedWithCrt + m_pParent->m_BaseMemUsedWithCrt;
  409. m_BaseMemUsed = m_pParent->m_MemUsed + m_pParent->m_BaseMemUsed;
  410.     }
  411.     mz_pActiveProbe = this;
  413.     _CrtSetAllocHook(MemProbeHook);
  415.     m_bIsFrozen = FALSE;
  416.     
  417.     LeaveCriticalSection(&m_Mutex);
  418. #endif  /* _DEBUG */
  420.     return HXR_OK;
  421. }
  424. HX_RESULT CHXMemProbe::Freeze(BOOL bGenerateDetailInfo, BOOL bWithCrt)
  425. {
  426. #ifdef _DEBUG
  427.     HX_RESULT RetVal = HXR_OK;
  429.     if (m_bIsFrozen)
  430.     {
  431. return HXR_UNEXPECTED;
  432.     }
  434.     EnterCriticalSection(&m_Mutex);
  436.     _CrtMemCheckpoint(&m_MemFreezePoint);
  438.     // Fixup Parent
  439.     if (m_pParent != NULL)
  440.     {
  441. m_pParent->m_MaxMemUsedWithCrt = mem_max(  m_pParent->m_MaxMemUsedWithCrt, 
  442. m_pParent->m_MemUsedWithCrt + m_MaxMemUsedWithCrt);
  443. m_pParent->m_MemUsedWithCrt += m_MemUsedWithCrt;
  444. m_pParent->m_MaxMemUsed = mem_max( m_pParent->m_MaxMemUsed, 
  445.     m_pParent->m_MemUsed + m_MaxMemUsed);
  446. m_pParent->m_MemUsed += m_MemUsed;
  448. m_pParent->m_pChild = m_pChild;
  449.     }
  451.     if (m_pChild == NULL)
  452.     {
  453. // Since there are no children, this must be the active probe
  454. HX_ASSERT(mz_pActiveProbe == this);
  455. mz_pActiveProbe = m_pParent;
  456.     }
  457.     else
  458.     {
  459. // Collect Info from child and disown it
  460. LONG32 uChildMax;
  462. HX_ASSERT(!m_pChild->m_bIsFrozen);
  464. uChildMax = (LONG32) m_pChild->GetMaxMemUsed(PNDBG_ALL_MEM, PNDBG_NOBASE_MEM);
  465. m_MaxMemUsedWithCrt = mem_max( m_MaxMemUsedWithCrt,
  466. m_MemUsedWithCrt + uChildMax);
  467.     
  468. uChildMax = m_pChild->GetMaxMemUsed(HXDBG_CLIENT_MEM, PNDBG_NOBASE_MEM);
  469. m_MaxMemUsed = mem_max(m_MaxMemUsed,
  470. m_MemUsed + uChildMax);
  472. m_pChild->m_pParent = m_pParent;
  473.     }
  475.     m_pParent = NULL;
  476.     m_pChild = NULL;
  478.     if (SUCCEEDED(RetVal))
  479.     {
  480. DestroyBlockInfo(m_MemFreeze);
  481. if (bGenerateDetailInfo)
  482. {
  483.     RetVal = MakeBlockInfo(m_MemFreeze, bWithCrt);
  484. }
  485.     }
  486.     
  487.     m_bIsFrozen = TRUE;
  488.     
  489.     if (mz_pActiveProbe == NULL)
  490.     {
  491. m_bMutexInitialized = FALSE;
  492. DeleteCriticalSection(&m_Mutex);
  493.     }
  494.     else
  495.     {
  496. LeaveCriticalSection(&m_Mutex);
  497.     }
  499.     return RetVal;
  500. #else  /* DEBUG */
  501.     return HXR_OK;
  502. #endif  /* _DEBUG */
  503. }
  506. const char* CHXMemProbe::SearchMemFrozen(ULONG32 uMemBlockId)
  507. {
  508. #ifdef _DEBUG
  509.     MemBlockInfo *pInfo;
  511.     for (pInfo = m_MemFreeze.pNext; pInfo != NULL; pInfo = pInfo->pNext)
  512.     {
  513. if (pInfo->uId == uMemBlockId)
  514. {
  515.     return pInfo->pDetail;
  516. }
  517.     }
  518. #endif  /* _DEBUG */
  520.     return NULL;
  521. }
  524. HX_RESULT CHXMemProbe::GetFirstMemFrozen(ULONG32 &uMemBlockId, ULONG32 &uMemUsed)
  525. {
  526. #ifdef _DEBUG
  527.     m_pMemFreezeIter = m_MemFreeze.pNext;
  529.     if (m_pMemFreezeIter != NULL)
  530.     {
  531. uMemBlockId = m_pMemFreezeIter->uId;
  532. uMemUsed = m_pMemFreezeIter->uMemUsed;
  534. return HXR_OK;
  535.     }
  536. #endif  /* _DEBUG */
  538.     return HXR_FAIL;
  539. }
  542. HX_RESULT CHXMemProbe::GetNextMemFrozen(ULONG32 &uMemBlockId, ULONG32 &uMemUsed)
  543. {
  544. #ifdef _DEBUG
  545.     if (m_pMemFreezeIter != NULL)
  546.     {
  547. m_pMemFreezeIter = m_pMemFreezeIter->pNext;
  548.     }
  550.     if (m_pMemFreezeIter != NULL)
  551.     {
  552. uMemBlockId = m_pMemFreezeIter->uId;
  553. uMemUsed = m_pMemFreezeIter->uMemUsed;
  555. return HXR_OK;
  556.     }
  557. #endif  /* _DEBUG */
  559.     return HXR_FAIL;
  560. }
  563. /****************************************************************************
  564.  *  Private Methods
  565.  */
  566. #ifdef _DEBUG
  568. HX_RESULT CHXMemProbe::MakeBlockInfo(MemBlockInfo &Info, BOOL bWithCrt)
  569. {
  570.     FILE *pTempFile;
  571.     HX_RESULT RetVal = HXR_OK;
  572.     char Buffer[MAX_DUMPLINE_LENGTH]; /* Flawfinder: ignore */
  573.     char *pString;
  574.     ULONG32 uId;
  575.     ULONG32 uMemUsed;
  577.     // Create temporary file
  578.     pTempFile = tmpfile();
  580.     if (pTempFile == NULL)
  581.     {
  582. RetVal = HXR_FAIL;
  583.     }
  585.     // Dump Current Heap State
  586.     if (SUCCEEDED(RetVal))
  587.     {
  588. _DumpMemUsedSinceReset(pTempFile, bWithCrt);
  590. if (fseek(pTempFile, 0, SEEK_SET) != 0)
  591. {
  592.     RetVal = HXR_FAIL;
  593. }
  594.     }
  596.     // Parse Dump
  597.     while (SUCCEEDED(RetVal) && (fgets(Buffer, sizeof(Buffer), pTempFile) != NULL))
  598.     {
  599. if (strncmp(Buffer, DUMPDATA_START_STRING, strlen(DUMPDATA_START_STRING)) == 0)
  600. {
  601.     // skip the data section
  602.     continue;
  603. }
  605. pString = strchr(Buffer, DUMPBLOCKID_START_CHAR);
  606. if (pString != NULL)
  607. {
  608.     pString++;
  609.     if (sscanf(pString, "%ld", &uId) != 1)
  610.     {
  611. RetVal = HXR_PARSE_ERROR;
  612.     }
  614.     if (SUCCEEDED(RetVal))
  615.     {
  616. pString = strchr(pString, DUMPMEMUSED_START_CHAR);
  617. if (pString == NULL)
  618. {
  619.     RetVal = HXR_PARSE_ERROR;
  620. }
  621. else
  622. {
  623.     pString++;
  624.     if (sscanf(pString, "%ld", &uMemUsed) != 1)
  625.     {
  626. RetVal = HXR_PARSE_ERROR;
  627.     }
  628. }
  629.     }
  631.     if (SUCCEEDED(RetVal))
  632.     {
  633. pString = strchr(pString, 'n');
  634. if (pString != NULL)
  635. {
  636.     *pString = '';
  637. }
  638.     }
  640.     if (SUCCEEDED(RetVal))
  641.     {
  642. RetVal = AddBlockInfo(Info, uId, uMemUsed, Buffer);
  643.     }
  644. }
  645.     }
  648.     if (pTempFile != NULL)
  649.     {
  650. fclose(pTempFile);
  651.     }
  653.     return RetVal;
  654. }
  657. HX_RESULT CHXMemProbe::AddBlockInfo(MemBlockInfo &Info, ULONG32 uId, ULONG32 uMemUsed, const char *pDetail)
  658. {
  659.     MemBlockInfo *pNewInfo = NULL;
  660.     char *pNewDetail = NULL;
  662.     HX_RESULT RetVal = HXR_OK;
  664.     pNewInfo = (MemBlockInfo *) _malloc_dbg(sizeof(MemBlockInfo),
  665.     _CRT_BLOCK, 
  666.     __FILE__, 
  667.     __LINE__);
  669.     if (pNewInfo == NULL)
  670.     {
  671. RetVal = HXR_OUTOFMEMORY;
  672.     }
  674.     if (SUCCEEDED(RetVal))
  675.     {
  676. if (pDetail != NULL)
  677. {
  678.     pNewDetail = (char *) _calloc_dbg(  strlen(pDetail) + 1, 
  679. sizeof(char), 
  680. _CRT_BLOCK, 
  681. __FILE__, 
  682. __LINE__);
  684.     if (pNewDetail == NULL)
  685.     {
  686. RetVal = HXR_OUTOFMEMORY;
  687.     }
  688.     else
  689.     {
  690. strcpy(pNewDetail, pDetail); /* Flawfinder: ignore */
  691.     }
  692. }
  693.     }
  695.     if (SUCCEEDED(RetVal))
  696.     {
  697. pNewInfo->uId = uId;
  698. pNewInfo->uMemUsed = uMemUsed;
  699. pNewInfo->pDetail = pNewDetail;
  701. pNewInfo->pNext = Info.pNext;
  702. Info.pNext = pNewInfo;
  703.     }
  704.     else
  705.     {
  706. if (pNewInfo != NULL)
  707. {
  708.     free(pNewInfo);
  709. }
  710. if (pNewDetail != NULL)
  711. {
  712.     free(pNewDetail);
  713. }
  714.     }
  716.     return RetVal;
  717. }
  720. void CHXMemProbe::DestroyBlockInfo(MemBlockInfo &Info)
  721. {
  722.     MemBlockInfo *pInfo;
  723.     MemBlockInfo *pDeadInfo;
  725.     m_pMemFreezeIter = NULL;
  727.     pInfo = Info.pNext;
  728.     
  729.     while(pInfo != NULL)
  730.     {
  731. pDeadInfo = pInfo;
  733. pInfo = pInfo->pNext;
  735. if (pDeadInfo->pDetail != NULL)
  736. {
  737.     free(pDeadInfo->pDetail);
  738. }
  739. free(pDeadInfo);
  740.     }
  742.     Info = EmptyMemBlockInfo;
  743. }
  745. #if (defined(_MSC_VER) && (_MSC_VER > 1100) && defined(_BASETSD_H_)) /* VC 6 Check */
  746. int __cdecl CHXMemProbe::MemProbeHook(int allocType, void *userData, size_t size, int blockType,
  747.      long requestNumber, const unsigned char *filename, int lineNumber)
  748. #else
  749. int __cdecl CHXMemProbe::MemProbeHook(int allocType, void *userData, size_t size, int blockType,
  750.      long requestNumber, const char *filename, int lineNumber)
  751. #endif
  752. {
  753.     if (mz_pActiveProbe != NULL)
  754.     {
  755. if (allocType == _HOOK_REALLOC)
  756. {
  757.     size_t old_size;
  759.     old_size = _msize_dbg(userData, blockType);
  761.     if (size > old_size)
  762.     {
  763. size = size - old_size;
  764. allocType = _HOOK_ALLOC;
  765.     }
  766.     else if (size < old_size)
  767.     {
  768. size = old_size - size;
  769. allocType = _HOOK_FREE;
  770.     }
  771. }
  772. else if (allocType == _HOOK_FREE)
  773. {
  774.     size = _msize_dbg(userData, blockType);
  775. }
  777. switch(allocType)
  778. {
  779. case _HOOK_ALLOC:
  780.     mz_pActiveProbe->m_MemUsedWithCrt += size;
  781.     if (mz_pActiveProbe->m_MemUsedWithCrt > ((LONG32) mz_pActiveProbe->m_MaxMemUsedWithCrt))
  782.     {
  783. mz_pActiveProbe->m_MaxMemUsedWithCrt = mz_pActiveProbe->m_MemUsedWithCrt;
  784.     }
  786.     if (blockType != _CRT_BLOCK)
  787.     {
  788. mz_pActiveProbe->m_MemUsed += size;
  789. if (mz_pActiveProbe->m_MemUsed > ((LONG32) mz_pActiveProbe->m_MaxMemUsed))
  790. {
  791.     mz_pActiveProbe->m_MaxMemUsed = mz_pActiveProbe->m_MemUsed;
  792. }
  793.     }
  794.     break;
  796. case _HOOK_FREE:
  797.     mz_pActiveProbe->m_MemUsedWithCrt -= size;
  799.     if (blockType != _CRT_BLOCK)
  800.     {
  801. mz_pActiveProbe->m_MemUsed -= size;
  802.     }
  803.     break;
  805. case _HOOK_REALLOC:
  806.     // nothing to do: no size change
  807.     break;
  809. default:
  810.     HX_ASSERT(FALSE);
  811.     break;
  812. }
  813.     }
  815.     return TRUE;
  816. }
  817. #endif  /* _DEBUG */
  820. /****************************************************************************
  821.  *  Helper Functions
  822.  */
  823. #ifdef _DEBUG
  825. static LONG32 CalcUsedMem(_CrtMemState *MemState, BOOL bWithCrt)
  826. {
  827.     LONG32 UsedMem = 0;
  829.     if (MemState != NULL)
  830.     {
  831. int BlockType;
  833. for (BlockType = 0; BlockType < _MAX_BLOCKS; BlockType++)
  834. {
  835.     if ((BlockType != _FREE_BLOCK) && ((BlockType != _CRT_BLOCK) || bWithCrt))
  836.     {
  837. UsedMem += MemState->lSizes[BlockType];
  838. // printf("BlockType(%ld) Block(%ld) Size = %ldn", BlockType, i, MemState->lSizes[BlockType]);
  839.     }
  840. }
  841.     }
  843.     return UsedMem;
  844. }
  846. #endif  /* _DEBUG */