src/WINNT/talocale/tal_alloc.cpp

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #ifndef DEBUG
  11 #define DEBUG
  12 #endif
  13 #ifdef NO_DEBUG_ALLOC
  14 #undef NO_DEBUG_ALLOC
  15 #endif
  16
  17 #include <windows.h>
  18 #include <commctrl.h>
  19 #include <WINNT/tal_alloc.h>
  20
  21
  22 /*
  23  * PARAMETERS _________________________________________________________________
  24  *
  25  */
  26
  27 #define cDEFAULT_BUCKETS 128
  28
  29 #define dwSIG_AT_END     'Okay'
  30
  31 #define iINVALID         ((size_t)-1)
  32
  33 #define MIN_BUCKETS(_cObjects)     ((_cObjects) / 23)
  34 #define TARGET_BUCKETS(_cObjects)  ((_cObjects) /  5)
  35
  36 #define TRACK_FREED
  37
  38 #define cmsecREFRESH   1000
  39
  40
  41 /*
  42  * DEFINITIONS ________________________________________________________________
  43  *
  44  */
  45
  46 typedef struct
  47    {
  48    PVOID aElements; // = EXPANDARRAYHEAP.aElements + 4;
  49    // Followed by allocated space for aElements
  50    } EXPANDARRAYHEAP, *LPEXPANDARRAYHEAP;
  51
  52 class ALLOCEXPANDARRAY
  53    {
  54    public:
  55       ALLOCEXPANDARRAY (size_t cbElement, size_t cElementsPerHeap = 0);
  56       ~ALLOCEXPANDARRAY (void);
  57
  58       PVOID GetAt (size_t iElement);
  59       void SetAt (size_t iElement, PVOID pData);
  60
  61    private:
  62       size_t m_cbElement;
  63       size_t m_cElementsPerHeap;
  64
  65       size_t m_cHeaps;
  66       LPEXPANDARRAYHEAP *m_aHeaps;
  67    };
  68
  69 typedef struct
  70    {
  71    PVOID pData;
  72    size_t cbData;
  73    LPTSTR pszExpr;
  74    LPTSTR pszFile;
  75    DWORD dwLine;
  76    DWORD dwTick;
  77    DWORD dwEndSig;
  78    BOOL fCPP;
  79    size_t iNext;
  80    size_t iPrev;
  81    BOOL fFreed;
  82    BOOL fInList;
  83    BOOL fTared;
  84    } MEMCHUNK, *PMEMCHUNK;
  85
  86 typedef struct
  87    {
  88    size_t iFirst;
  89    } BUCKET, *PBUCKET;
  90
  91 typedef struct
  92    {
  93    size_t cAllocCpp;
  94    size_t cAllocDyna;
  95    size_t cAllocTotal;
  96    size_t cAllocCppTared;
  97    size_t cAllocDynaTared;
  98    size_t cAllocTotalTared;
  99    size_t cbAllocCpp;
 100    size_t cbAllocDyna;
 101    size_t cbAllocTotal;
 102    size_t cbAllocCppTared;
 103    size_t cbAllocDynaTared;
 104    size_t cbAllocTotalTared;
 105    } STATISTICS;
 106
 107 static struct l
 108    {
 109    CRITICAL_SECTION *pcs;
 110    HWND hManager;
 111    UINT_PTR idTimer;
 112
 113    ALLOCEXPANDARRAY *pHeap;
 114    size_t cChunks;
 115
 116    BUCKET *aBuckets;
 117    size_t cBuckets;
 118
 119    STATISTICS Stats;
 120    } l;
 121
 122 static struct lr
 123    {
 124    RECT rManager;
 125    LONG acxColumns[6];
 126    int iColSort;
 127    BOOL fSortRev;
 128    } lr;
 129
 130 #define HASH(_dw,_cTable)  (((DWORD)(_dw) >> 4) % (_cTable))
 131
 132
 133 /*
 134  * REALLOC ____________________________________________________________________
 135  *
 136  */
 137
 138 #ifndef REALLOC
 139 #define REALLOC(_a,_c,_r,_i) Alloc_ReallocFunction ((LPVOID*)&_a,sizeof(*_a),&_c,_r,_i)
 140 BOOL Alloc_ReallocFunction (LPVOID *ppTarget, size_t cbElement, size_t *pcTarget, size_t cReq, size_t cInc)
 141 {
 142    LPVOID pNew;
 143    size_t cNew;
 144
 145    if (cReq <= *pcTarget)
 146       return TRUE;
 147
 148    if ((cNew = cInc * ((cReq + cInc-1) / cInc)) <= 0)
 149       return FALSE;
 150
 151    if ((pNew = (LPVOID)GlobalAlloc (GMEM_FIXED, cbElement * cNew)) == NULL)
 152       return FALSE;
 153    memset (pNew, 0x00, cbElement * cNew);
 154
 155    if (*pcTarget == 0)
 156       memset (pNew, 0x00, cbElement * cNew);
 157    else
 158       {
 159       memcpy (pNew, *ppTarget, cbElement * (*pcTarget));
 160       memset (&((char*)pNew)[ cbElement * (*pcTarget) ], 0x00, cbElement * (cNew - *pcTarget));
 161       GlobalFree ((HGLOBAL)*ppTarget);
 162       }
 163
 164    *ppTarget = pNew;
 165    *pcTarget = cNew;
 166    return TRUE;
 167 }
 168 #endif
 169
 170
 171 /*
 172  * USER INTERFACE ROUTINES ____________________________________________________
 173  *
 174  */
 175
 176 #define IDC_INITIALIZE           100
 177 #define IDC_BOX_ALLOC            101
 178 #define IDC_LABEL_CPP            102
 179 #define IDC_LABEL_OTHER          103
 180 #define IDC_LABEL_TARED          104
 181 #define IDC_LABEL_TOTAL          106
 182 #define IDC_LABEL_COUNT          107
 183 #define IDC_LABEL_SIZE           108
 184 #define IDC_LABEL_AVERAGE        109
 185 #define IDC_VALUE_CPP_COUNT      110
 186 #define IDC_VALUE_OTHER_COUNT    111
 187 #define IDC_VALUE_TARED_COUNT    112
 188 #define IDC_VALUE_TOTAL_COUNT    113
 189 #define IDC_VALUE_CPP_SIZE       114
 190 #define IDC_VALUE_OTHER_SIZE     115
 191 #define IDC_VALUE_TARED_SIZE     116
 192 #define IDC_VALUE_TOTAL_SIZE     117
 193 #define IDC_VALUE_CPP_AVERAGE    118
 194 #define IDC_VALUE_OTHER_AVERAGE  119
 195 #define IDC_VALUE_TARED_AVERAGE  120
 196 #define IDC_VALUE_TOTAL_AVERAGE  121
 197 #define IDC_BOX_DETAILS          122
 198 #define IDC_LIST                 123
 199 #define IDC_LABEL                124
 200 #define IDC_HIDE                 125
 201 #define IDC_TARE                 126
 202 #define IDC_RESET                127
 203 #define IDC_REFRESH              128
 204 #define IDC_LIST_ADD             129
 205 #define IDC_LIST_REMOVE          130
 206 #define IDC_LIST_REMOVEADD       131
 207
 208 #define cszTITLE        TEXT("Memory Manager")
 209
 210 typedef struct
 211    {
 212    RECT rBoxAlloc;
 213    RECT rLabelCpp;
 214    RECT rLabelOther;
 215    RECT rLabelTared;
 216    RECT rLabelTotal;
 217    RECT rLabelCount;
 218    RECT rLabelSize;
 219    RECT rLabelAverage;
 220    RECT rValueCppCount;
 221    RECT rValueOtherCount;
 222    RECT rValueTaredCount;
 223    RECT rValueTotalCount;
 224    RECT rValueCppSize;
 225    RECT rValueOtherSize;
 226    RECT rValueTaredSize;
 227    RECT rValueTotalSize;
 228    RECT rValueCppAverage;
 229    RECT rValueOtherAverage;
 230    RECT rValueTaredAverage;
 231    RECT rValueTotalAverage;
 232    RECT rBoxDetails;
 233    RECT rList;
 234    RECT rLabel;
 235    RECT rHide;
 236    RECT rTare;
 237    RECT rReset;
 238    RECT rClose;
 239    } WINDOWSIZES;
 240
 241 #define cBORDER      7
 242 #define cxBETWEEN    6
 243 #define cyBETWEEN    6
 244 #define cxBUTTONS   65
 245 #define cyBUTTONS   22
 246 #define cxLABELS    70
 247 #define cxVALUES    70
 248 #define cyLABELS    15
 249
 250
 251 HWND MakeWindow (LPCTSTR pszClass, LPCTSTR pszTitle, DWORD dwStyle, RECT *prSource,
 252                  HWND hParent, UINT idc, DWORD dwStyleEx = 0)
 253 {
 254    RECT rr = { 0, 0, 16, 16 };
 255    if (prSource)
 256       rr = *prSource;
 257    HWND hWnd = CreateWindowEx (dwStyleEx, pszClass, pszTitle, dwStyle,
 258                                rr.left, rr.top, rr.right - rr.left, rr.bottom - rr.top,
 259                                hParent, (HMENU)UIntToPtr(idc), GetModuleHandle(0), 0);
 260    if (IsWindow (hWnd))
 261       SendMessage (hWnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 1);
 262    return hWnd;
 263 }
 264
 265 void SetWindowRect (HWND hWnd, RECT *pr)
 266 {
 267    SetWindowPos (hWnd, 0, pr->left, pr->top, pr->right - pr->left,
 268                  pr->bottom - pr->top, SWP_NOZORDER | SWP_NOACTIVATE);
 269 }
 270
 271 void FormatBytes (LPTSTR pszText, double lfValue)
 272 {
 273    if (lfValue < 0)
 274       {
 275       lfValue = 0-lfValue;
 276       *pszText++ = TEXT('-');
 277       }
 278
 279    if (lfValue >= 1048576)
 280       {
 281       LONG Value = (LONG)(lfValue / 1048576);
 282       lfValue -= Value * 1048576;
 283       LONG Frac = (LONG)(lfValue * 100 / 1048576);
 284       wsprintf (pszText, TEXT("%ld.%ld MB"), Value, Frac);
 285       }
 286    else if (lfValue >= 3072)
 287       {
 288       LONG Value = (LONG)(lfValue / 1024);
 289       lfValue -= Value * 1024;
 290       LONG Frac = (LONG)(lfValue * 100 / 1024);
 291       wsprintf (pszText, TEXT("%ld.%ld kb"), Value, Frac);
 292       }
 293    else // (lfValue < 3072)
 294       {
 295       wsprintf (pszText, TEXT("%ld b"), (LONG)lfValue);
 296       }
 297 }
 298
 299 void FormatTime (LPTSTR pszText, DWORD dwTick)
 300 {
 301    static FILETIME ftTickZero = { 0, 0 };
 302    if (!ftTickZero.dwHighDateTime && !ftTickZero.dwLowDateTime)
 303       {
 304       // We need to find out what FILETIME corresponds with a tick
 305       // count of zero. To do that, first find the FILETIME and tick
 306       // count that represent *now* (in local time).
 307       //
 308       SYSTEMTIME stNow;
 309       GetLocalTime (&stNow);
 310       SystemTimeToFileTime (&stNow, &ftTickZero);
 311
 312       DWORD dwTickNow = GetTickCount();
 313
 314       // A FILETIME is a count-of-100ns-intervals, and a tick count is
 315       // a count of 1ms-intervals.  So we need to subtract off a big
 316       // number times our tick count.
 317       //
 318       if ((dwTickNow * 10000) < (dwTickNow))
 319          ftTickZero.dwHighDateTime --;
 320       dwTickNow *= 10000;   // convert to 100ns intervals
 321       if (dwTickNow > ftTickZero.dwLowDateTime)
 322          ftTickZero.dwHighDateTime --;
 323       ftTickZero.dwLowDateTime -= dwTickNow; // unsigned, so it'll wrap OK
 324       }
 325
 326    // Convert the given tick count into 100ns intervals, and add it
 327    // to our ftTickZero.
 328    //
 329    FILETIME ftTick = ftTickZero;
 330
 331    if ((dwTick * 10000) < (dwTick))
 332       ftTick.dwHighDateTime ++;
 333    dwTick *= 10000;   // convert to 100ns intervals
 334    if (dwTick > (DWORD)(0-ftTick.dwLowDateTime)) // too big to add?
 335       ftTick.dwHighDateTime ++;
 336    ftTick.dwLowDateTime += dwTick; // unsigned, so it'll wrap OK
 337
 338    // Convert to a SYSTEMTIME, and output the time component
 339    //
 340    SYSTEMTIME stTick;
 341    FileTimeToSystemTime (&ftTick, &stTick);
 342
 343    wsprintf (pszText, TEXT("%ld:%02ld:%02ld.%02ld"),
 344               (DWORD)stTick.wHour,
 345               (DWORD)stTick.wMinute,
 346               (DWORD)stTick.wSecond,
 347               (DWORD)(stTick.wMilliseconds / 100));
 348 }
 349
 350 void SetDlgItemBytes (HWND hDlg, int idc, double lfValue)
 351 {
 352    TCHAR szText[ 256 ];
 353    FormatBytes (szText, lfValue);
 354    SetDlgItemText (hDlg, idc, szText);
 355 }
 356
 357
 358 void MemMgr_ShowWarning (PMEMCHUNK pChunk, LPTSTR pszFile, DWORD dwLine, LPTSTR pszDesc)
 359 {
 360    TCHAR szMessage[ 1024 ];
 361    wsprintf (szMessage, TEXT("%s\n\n   Address: 0x%08p (%s)\n   Allocated: %s line %ld\n   Freed: %s line %ld\n\nClick OK for memory details."), pszDesc, pChunk->pData, pChunk->pszExpr, pChunk->pszFile, pChunk->dwLine, pszFile, dwLine);
 362    if (MessageBox (NULL, szMessage, cszTITLE, MB_ICONHAND | MB_OKCANCEL | MB_DEFBUTTON2) == IDOK)
 363       {
 364       // TODO: Show Details
 365       }
 366 }
 367
 368 void MIX (RECT *pr, RECT *pr1, RECT *pr2)
 369 {
 370    pr->left = pr2->left;
 371    pr->top = pr1->top;
 372    pr->right = pr2->right;
 373    pr->bottom = pr1->bottom;
 374 }
 375
 376 void MemMgr_GetWindowSizes (WINDOWSIZES *pSizes)
 377 {
 378    RECT rClient;
 379    GetClientRect (l.hManager, &rClient);
 380    InflateRect (&rClient, 0-cBORDER, 0-cBORDER);
 381
 382    pSizes->rLabelAverage.right = rClient.right -cxBETWEEN*2;
 383    pSizes->rLabelAverage.top = rClient.top +8 +cyBETWEEN;
 384    pSizes->rLabelAverage.left = pSizes->rLabelAverage.right -cxVALUES;
 385    pSizes->rLabelAverage.bottom = pSizes->rLabelAverage.top +cyLABELS;
 386
 387    pSizes->rLabelSize = pSizes->rLabelAverage;
 388    pSizes->rLabelSize.left -= cxBETWEEN + cxVALUES;
 389    pSizes->rLabelSize.right -= cxBETWEEN + cxVALUES;
 390
 391    pSizes->rLabelCount = pSizes->rLabelSize;
 392    pSizes->rLabelCount.left -= cxBETWEEN + cxVALUES;
 393    pSizes->rLabelCount.right -= cxBETWEEN + cxVALUES;
 394
 395    pSizes->rLabelCpp.left = rClient.left +cxBETWEEN;
 396    pSizes->rLabelCpp.top = pSizes->rLabelCount.bottom +cyBETWEEN;
 397    pSizes->rLabelCpp.right = pSizes->rLabelCpp.left +cxLABELS;
 398    pSizes->rLabelCpp.bottom = pSizes->rLabelCpp.top +cyLABELS;
 399
 400    pSizes->rLabelOther = pSizes->rLabelCpp;
 401    pSizes->rLabelOther.top += cyBETWEEN + cyLABELS;
 402    pSizes->rLabelOther.bottom += cyBETWEEN + cyLABELS;
 403
 404    pSizes->rLabelTotal = pSizes->rLabelOther;
 405    pSizes->rLabelTotal.top += cyBETWEEN + cyLABELS;
 406    pSizes->rLabelTotal.bottom += cyBETWEEN + cyLABELS;
 407
 408    pSizes->rLabelTared = pSizes->rLabelTotal;
 409    pSizes->rLabelTared.top += cyBETWEEN + cyLABELS;
 410    pSizes->rLabelTared.bottom += cyBETWEEN + cyLABELS;
 411
 412    pSizes->rBoxAlloc = rClient;
 413    pSizes->rBoxAlloc.bottom = pSizes->rLabelTared.bottom +cyBETWEEN;
 414
 415    MIX (&pSizes->rValueCppCount, &pSizes->rLabelCpp, &pSizes->rLabelCount);
 416    MIX (&pSizes->rValueOtherCount, &pSizes->rLabelOther, &pSizes->rLabelCount);
 417    MIX (&pSizes->rValueTaredCount, &pSizes->rLabelTared, &pSizes->rLabelCount);
 418    MIX (&pSizes->rValueTotalCount, &pSizes->rLabelTotal, &pSizes->rLabelCount);
 419
 420    MIX (&pSizes->rValueCppSize, &pSizes->rLabelCpp, &pSizes->rLabelSize);
 421    MIX (&pSizes->rValueOtherSize, &pSizes->rLabelOther, &pSizes->rLabelSize);
 422    MIX (&pSizes->rValueTaredSize, &pSizes->rLabelTared, &pSizes->rLabelSize);
 423    MIX (&pSizes->rValueTotalSize, &pSizes->rLabelTotal, &pSizes->rLabelSize);
 424
 425    MIX (&pSizes->rValueCppAverage, &pSizes->rLabelCpp, &pSizes->rLabelAverage);
 426    MIX (&pSizes->rValueOtherAverage, &pSizes->rLabelOther, &pSizes->rLabelAverage);
 427    MIX (&pSizes->rValueTaredAverage, &pSizes->rLabelTared, &pSizes->rLabelAverage);
 428    MIX (&pSizes->rValueTotalAverage, &pSizes->rLabelTotal, &pSizes->rLabelAverage);
 429
 430    pSizes->rBoxDetails = rClient;
 431    pSizes->rBoxDetails.top = pSizes->rBoxAlloc.bottom +cyBETWEEN;
 432    pSizes->rBoxDetails.bottom -= cyBUTTONS +cyBETWEEN;
 433
 434    pSizes->rList = pSizes->rBoxDetails;
 435    pSizes->rList.top += 8;
 436    InflateRect (&pSizes->rList, 0-cBORDER, 0-cBORDER);
 437
 438    pSizes->rClose = rClient;
 439    pSizes->rClose.top = pSizes->rClose.bottom - cyBUTTONS;
 440    pSizes->rClose.left = pSizes->rClose.right - cxBUTTONS;
 441
 442    pSizes->rReset = pSizes->rClose;
 443    pSizes->rReset.right = pSizes->rClose.left - cxBETWEEN;
 444    pSizes->rReset.left = pSizes->rReset.right - cxBUTTONS;
 445
 446    pSizes->rTare = pSizes->rClose;
 447    pSizes->rTare.right = pSizes->rReset.left - cxBETWEEN;
 448    pSizes->rTare.left = pSizes->rTare.right - cxBUTTONS;
 449
 450    pSizes->rLabel = pSizes->rTare;
 451    pSizes->rLabel.right = pSizes->rTare.left - cxBETWEEN;
 452    pSizes->rLabel.left = pSizes->rLabel.right - cxBUTTONS;
 453
 454    pSizes->rHide = pSizes->rLabel;
 455    pSizes->rHide.right = pSizes->rLabel.left - cxBETWEEN;
 456    pSizes->rHide.left = pSizes->rHide.right - cxBUTTONS;
 457 }
 458
 459 void MemMgr_OnSize (void)
 460 {
 461    WINDOWSIZES Sizes;
 462    MemMgr_GetWindowSizes (&Sizes);
 463    SetWindowRect (GetDlgItem (l.hManager, IDC_BOX_ALLOC), &Sizes.rBoxAlloc);
 464    SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_CPP), &Sizes.rLabelCpp);
 465    SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_OTHER), &Sizes.rLabelOther);
 466    SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_TARED), &Sizes.rLabelTared);
 467    SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_TOTAL), &Sizes.rLabelTotal);
 468    SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_COUNT), &Sizes.rLabelCount);
 469    SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_SIZE), &Sizes.rLabelSize);
 470    SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL_AVERAGE), &Sizes.rLabelAverage);
 471    SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_CPP_COUNT), &Sizes.rValueCppCount);
 472    SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_OTHER_COUNT), &Sizes.rValueOtherCount);
 473    SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_TARED_COUNT), &Sizes.rValueTaredCount);
 474    SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_TOTAL_COUNT), &Sizes.rValueTotalCount);
 475    SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_CPP_SIZE), &Sizes.rValueCppSize);
 476    SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_OTHER_SIZE), &Sizes.rValueOtherSize);
 477    SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_TARED_SIZE), &Sizes.rValueTaredSize);
 478    SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_TOTAL_SIZE), &Sizes.rValueTotalSize);
 479    SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_CPP_AVERAGE), &Sizes.rValueCppAverage);
 480    SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_OTHER_AVERAGE), &Sizes.rValueOtherAverage);
 481    SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_TARED_AVERAGE), &Sizes.rValueTaredAverage);
 482    SetWindowRect (GetDlgItem (l.hManager, IDC_VALUE_TOTAL_AVERAGE), &Sizes.rValueTotalAverage);
 483    SetWindowRect (GetDlgItem (l.hManager, IDC_BOX_DETAILS), &Sizes.rBoxDetails);
 484    SetWindowRect (GetDlgItem (l.hManager, IDC_LIST), &Sizes.rList);
 485    SetWindowRect (GetDlgItem (l.hManager, IDC_LABEL), &Sizes.rLabel);
 486    SetWindowRect (GetDlgItem (l.hManager, IDC_HIDE), &Sizes.rHide);
 487    SetWindowRect (GetDlgItem (l.hManager, IDC_TARE), &Sizes.rTare);
 488    SetWindowRect (GetDlgItem (l.hManager, IDC_RESET), &Sizes.rReset);
 489    SetWindowRect (GetDlgItem (l.hManager, IDCANCEL), &Sizes.rClose);
 490 }
 491
 492
 493 void MemMgr_OnListRemove (PVOID pData)
 494 {
 495    HWND hList = GetDlgItem (l.hManager, IDC_LIST);
 496
 497    LV_FINDINFO Find;
 498    Find.flags = LVFI_PARAM;
 499    Find.lParam = (LPARAM)pData;
 500
 501    int iItem;
 502    if ((iItem = ListView_FindItem (hList, 0, &Find)) == -1)
 503       {
 504       // The listview's find feature sucks; I've seen with my own little
 505       // eyes that it may miss an item if it's the only one in a list.
 506       // Look for ourselves.
 507       //
 508       int cItems = ListView_GetItemCount(hList);
 509       for (iItem = 0; iItem < cItems; ++iItem)
 510          {
 511          LV_ITEM Item;
 512          Item.iItem = iItem;
 513          Item.mask = LVIF_PARAM;
 514          ListView_GetItem (hList, &Item);
 515          if (Item.lParam == (LPARAM)pData)
 516             break;
 517          }
 518       }
 519
 520    if (iItem != -1)
 521       {
 522       ListView_DeleteItem (hList, iItem);
 523       }
 524 }
 525
 526
 527 void MemMgr_RemoveFromList (PMEMCHUNK pChunk)
 528 {
 529    PostMessage (l.hManager, WM_COMMAND, IDC_LIST_REMOVE, (LPARAM)(pChunk->pData));
 530    pChunk->fInList = FALSE;
 531 }
 532
 533
 534 LPTSTR MemMgr_GetItemKey (HWND hList, int iItem)
 535 {
 536    static TCHAR szText[ 256 ];
 537    LPTSTR pszReturn = NULL;
 538
 539    switch (lr.iColSort)
 540       {
 541       case 0:
 542       case 4:
 543       case 5:
 544          LV_ITEM Item;
 545          Item.iItem = iItem;
 546          Item.mask = LVIF_PARAM;
 547          ListView_GetItem (hList, &Item);
 548
 549          EnterCriticalSection (l.pcs);
 550
 551          size_t iBucket;
 552          iBucket = HASH(Item.lParam,l.cBuckets);
 553
 554          PMEMCHUNK pChunk;
 555          pChunk = NULL;
 556
 557          size_t iChunk;
 558          for (iChunk = l.aBuckets[iBucket].iFirst; iChunk != iINVALID; )
 559             {
 560             if ((pChunk = (PMEMCHUNK)l.pHeap->GetAt(iChunk)) == NULL)
 561                break;
 562             if (pChunk->pData == (PVOID)Item.lParam)
 563                break;
 564             if ((iChunk = pChunk->iNext) == iINVALID)
 565                {
 566                pChunk = NULL;
 567                break;
 568                }
 569             }
 570
 571          if (pChunk)
 572             {
 573             if (lr.iColSort == 0)
 574                pszReturn = (LPTSTR)UlongToPtr(pChunk->dwTick);
 575             else if (lr.iColSort == 4)
 576                pszReturn = (LPTSTR)pChunk->cbData;
 577             else // (lr.iColSort == 5)
 578                pszReturn = (LPTSTR)pChunk->pData;
 579             }
 580
 581          LeaveCriticalSection (l.pcs);
 582          break;
 583
 584       default:
 585          ListView_GetItemText (hList, iItem, lr.iColSort, szText, 256);
 586          pszReturn = szText;
 587          break;
 588       }
 589
 590    return pszReturn;
 591 }
 592
 593
 594 int MemMgr_CompareItems (LPTSTR pszKey1, LPTSTR pszKey2)
 595 {
 596    int dw;
 597
 598    switch (lr.iColSort)
 599       {
 600       case 0:
 601       case 4:
 602       case 5:
 603          dw = (int)( pszKey1 - pszKey2 );
 604          break;
 605
 606       default:
 607          dw = lstrcmpi (pszKey1, pszKey2);
 608          break;
 609       }
 610
 611    return (lr.fSortRev) ? (0-dw) : dw;
 612 }
 613
 614
 615 int MemMgr_PickListInsertionPoint (HWND hList, LPTSTR pszKey)
 616 {
 617    int iItemLow  = 0;
 618    int iItemHigh = ListView_GetItemCount (hList) -1;
 619
 620    while (iItemLow <= iItemHigh)
 621       {
 622       int iItemTest = iItemLow + (iItemHigh - iItemLow) / 2;
 623
 624       LPTSTR pszAlternate = MemMgr_GetItemKey (hList, iItemTest);
 625
 626       int iCompare = MemMgr_CompareItems (pszKey, pszAlternate);
 627       if (iCompare <= 0)
 628          {
 629          if ((iItemHigh = iItemTest-1) < iItemLow)
 630             return iItemHigh +1;
 631          }
 632       if (iCompare >= 0)
 633          {
 634          if ((iItemLow = iItemTest+1) > iItemHigh)
 635             return iItemLow;
 636          }
 637       }
 638
 639    return 0;
 640 }
 641
 642
 643 void MemMgr_OnListAdd (PMEMCHUNK pCopy)
 644 {
 645    HWND hList = GetDlgItem (l.hManager, IDC_LIST);
 646
 647    TCHAR szTime[256];
 648    FormatTime (szTime, pCopy->dwTick);
 649
 650    TCHAR szFlags[256];
 651    LPTSTR pszFlags = szFlags;
 652    *pszFlags++ = (pCopy->fCPP) ? TEXT('C') : TEXT(' ');
 653    *pszFlags++ = TEXT(' ');
 654    *pszFlags++ = (pCopy->fFreed) ? TEXT('F') : TEXT(' ');
 655    *pszFlags++ = 0;
 656
 657    TCHAR szExpr[256];
 658    lstrcpy (szExpr, (pCopy->pszExpr) ? pCopy->pszExpr : TEXT("unknown"));
 659
 660    LPTSTR pszFile = pCopy->pszFile;
 661    for (LPTSTR psz = pCopy->pszFile; *psz; ++psz)
 662       {
 663       if ((*psz == TEXT(':')) || (*psz == TEXT('\\')))
 664          pszFile = &psz[1];
 665       }
 666    TCHAR szLocation[256];
 667    if (!pszFile || !pCopy->dwLine)
 668       lstrcpy (szLocation, TEXT("unknown"));
 669    else
 670       wsprintf (szLocation, TEXT("%s, %ld"), pszFile, pCopy->dwLine);
 671
 672    TCHAR szBytes[256];
 673    FormatBytes (szBytes, (double)pCopy->cbData);
 674
 675    TCHAR szAddress[256];
 676    wsprintf (szAddress, TEXT("0x%08p"), pCopy->pData);
 677
 678    LPTSTR pszKey = NULL;
 679    switch (lr.iColSort)
 680       {
 681       case 0:  pszKey = (LPTSTR)UlongToPtr(pCopy->dwTick);  break;
 682       case 1:  pszKey = (LPTSTR)szFlags;        break;
 683       case 2:  pszKey = (LPTSTR)szExpr;         break;
 684       case 3:  pszKey = (LPTSTR)szLocation;     break;
 685       case 4:  pszKey = (LPTSTR)pCopy->cbData;  break;
 686       case 5:  pszKey = (LPTSTR)pCopy->pData;   break;
 687       }
 688
 689    LV_ITEM Item;
 690    memset (&Item, 0x00, sizeof(Item));
 691    Item.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE | LVIF_IMAGE;
 692    Item.iItem = MemMgr_PickListInsertionPoint (hList, pszKey);
 693    Item.iSubItem = 0;
 694    Item.cchTextMax = 256;
 695    Item.lParam = (LPARAM)pCopy->pData;
 696
 697    Item.pszText = szTime;
 698    DWORD iItem = ListView_InsertItem (hList, &Item);
 699    ListView_SetItemText (hList, iItem, 1, szFlags);
 700    ListView_SetItemText (hList, iItem, 2, szExpr);
 701    ListView_SetItemText (hList, iItem, 3, szLocation);
 702    ListView_SetItemText (hList, iItem, 4, szBytes);
 703    ListView_SetItemText (hList, iItem, 5, szAddress);
 704
 705    delete pCopy;
 706 }
 707
 708
 709 void MemMgr_AddToList (PMEMCHUNK pChunk)
 710 {
 711    PMEMCHUNK pCopy = new MEMCHUNK;
 712    memcpy (pCopy, pChunk, sizeof(MEMCHUNK));
 713
 714    if (pChunk->fInList)
 715       PostMessage (l.hManager, WM_COMMAND, IDC_LIST_REMOVEADD, (LPARAM)pCopy);
 716    else
 717       PostMessage (l.hManager, WM_COMMAND, IDC_LIST_ADD, (LPARAM)pCopy);
 718    pChunk->fInList = TRUE;
 719 }
 720
 721
 722 void MemMgr_RestoreSettings (void)
 723 {
 724    lr.rManager.left = 0;
 725    lr.rManager.top = 0;
 726    lr.rManager.right = 510;
 727    lr.rManager.bottom = 440;
 728    lr.acxColumns[0] = 70;
 729    lr.acxColumns[1] = 40;
 730    lr.acxColumns[2] = 100;
 731    lr.acxColumns[3] = 110;
 732    lr.acxColumns[4] = 50;
 733    lr.acxColumns[5] = 80;
 734    lr.iColSort = 4;
 735    lr.fSortRev = TRUE;
 736
 737    HKEY hk;
 738    if (RegOpenKey (HKEY_LOCAL_MACHINE, TEXT("Software\\Random\\MemMgr"), &hk) == 0)
 739       {
 740       DWORD dwType = REG_BINARY;
 741       DWORD dwSize = sizeof(lr);
 742       RegQueryValueEx (hk, TEXT("Settings"), 0, &dwType, (PBYTE)&lr, &dwSize);
 743       RegCloseKey (hk);
 744       }
 745 }
 746
 747 void MemMgr_StoreSettings (void)
 748 {
 749    if (IsWindow (l.hManager))
 750       {
 751       GetWindowRect (l.hManager, &lr.rManager);
 752
 753       HWND hList = GetDlgItem (l.hManager, IDC_LIST);
 754       if (IsWindow (hList))
 755          {
 756          for (size_t ii = 0; ii < 6; ++ii)
 757             lr.acxColumns[ ii ] = ListView_GetColumnWidth (hList, ii);
 758          }
 759       }
 760
 761    HKEY hk;
 762    if (RegCreateKey (HKEY_LOCAL_MACHINE, TEXT("Software\\Random\\MemMgr"), &hk) == 0)
 763       {
 764       RegSetValueEx (hk, TEXT("Settings"), 0, REG_BINARY, (PBYTE)&lr, sizeof(lr));
 765       RegCloseKey (hk);
 766       }
 767 }
 768
 769 void MemMgr_OnInit (void)
 770 {
 771    DWORD dwFlags = WS_CHILD | WS_TABSTOP | WS_VISIBLE;
 772    MakeWindow (TEXT("Button"), TEXT("Allocation Statistics"), dwFlags | BS_GROUPBOX, NULL, l.hManager, IDC_BOX_ALLOC);
 773    MakeWindow (TEXT("Static"), TEXT("C++ Objects:"), dwFlags, NULL, l.hManager, IDC_LABEL_CPP);
 774    MakeWindow (TEXT("Static"), TEXT("Dynamic:"), dwFlags, NULL, l.hManager, IDC_LABEL_OTHER);
 775    MakeWindow (TEXT("Static"), TEXT("Combined:"), dwFlags, NULL, l.hManager, IDC_LABEL_TOTAL);
 776    MakeWindow (TEXT("Static"), TEXT("Tared:"), dwFlags, NULL, l.hManager, IDC_LABEL_TARED);
 777    MakeWindow (TEXT("Static"), TEXT("Count"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_LABEL_COUNT);
 778    MakeWindow (TEXT("Static"), TEXT("Size"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_LABEL_SIZE);
 779    MakeWindow (TEXT("Static"), TEXT("Average"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_LABEL_AVERAGE);
 780    MakeWindow (TEXT("Static"), TEXT("0"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_CPP_COUNT);
 781    MakeWindow (TEXT("Static"), TEXT("1"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_OTHER_COUNT);
 782    MakeWindow (TEXT("Static"), TEXT("2"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_TARED_COUNT);
 783    MakeWindow (TEXT("Static"), TEXT("3"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_TOTAL_COUNT);
 784    MakeWindow (TEXT("Static"), TEXT("4"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_CPP_SIZE);
 785    MakeWindow (TEXT("Static"), TEXT("5"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_OTHER_SIZE);
 786    MakeWindow (TEXT("Static"), TEXT("6"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_TARED_SIZE);
 787    MakeWindow (TEXT("Static"), TEXT("7"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_TOTAL_SIZE);
 788    MakeWindow (TEXT("Static"), TEXT("8"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_CPP_AVERAGE);
 789    MakeWindow (TEXT("Static"), TEXT("9"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_OTHER_AVERAGE);
 790    MakeWindow (TEXT("Static"), TEXT("10"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_TARED_AVERAGE);
 791    MakeWindow (TEXT("Static"), TEXT("11"), dwFlags | SS_CENTER, NULL, l.hManager, IDC_VALUE_TOTAL_AVERAGE);
 792    MakeWindow (TEXT("Button"), TEXT("Details"), dwFlags | BS_GROUPBOX, NULL, l.hManager, IDC_BOX_DETAILS);
 793    MakeWindow (WC_LISTVIEW, TEXT(""), dwFlags | LVS_REPORT | LVS_SINGLESEL, NULL, l.hManager, IDC_LIST, WS_EX_CLIENTEDGE);
 794 // MakeWindow (TEXT("Button"), TEXT("Label"), dwFlags, NULL, l.hManager, IDC_LABEL);
 795 // MakeWindow (TEXT("Button"), TEXT("Hidden"), dwFlags, NULL, l.hManager, IDC_HIDE);
 796    MakeWindow (TEXT("Button"), TEXT("Tare"), dwFlags, NULL, l.hManager, IDC_TARE);
 797    MakeWindow (TEXT("Button"), TEXT("Restore"), dwFlags, NULL, l.hManager, IDC_RESET);
 798    MakeWindow (TEXT("Button"), TEXT("Close"), dwFlags, NULL, l.hManager, IDCANCEL);
 799    MemMgr_OnSize();
 800
 801    HWND hList = GetDlgItem (l.hManager, IDC_LIST);
 802
 803    LV_COLUMN Col;
 804    Col.mask = LVCF_WIDTH | LVCF_TEXT | LVCF_FMT | LVCF_SUBITEM;
 805    Col.fmt = LVCFMT_LEFT;
 806    Col.iSubItem = 0;
 807    Col.cx = lr.acxColumns[0];
 808    Col.pszText = TEXT("Time");
 809    ListView_InsertColumn (hList, Col.iSubItem, &Col);
 810
 811    Col.cx = lr.acxColumns[1];
 812    Col.pszText = TEXT("Flags");
 813    Col.iSubItem++;
 814    ListView_InsertColumn (hList, Col.iSubItem, &Col);
 815
 816    Col.cx = lr.acxColumns[2];
 817    Col.pszText = TEXT("Expression");
 818    Col.iSubItem++;
 819    ListView_InsertColumn (hList, Col.iSubItem, &Col);
 820
 821    Col.cx = lr.acxColumns[3];
 822    Col.pszText = TEXT("Location");
 823    Col.iSubItem++;
 824    ListView_InsertColumn (hList, Col.iSubItem, &Col);
 825
 826    Col.fmt = LVCFMT_RIGHT;
 827    Col.cx = lr.acxColumns[4];
 828    Col.pszText = TEXT("Size");
 829    Col.iSubItem++;
 830    ListView_InsertColumn (hList, Col.iSubItem, &Col);
 831
 832    Col.cx = lr.acxColumns[5];
 833    Col.pszText = TEXT("Address");
 834    Col.iSubItem++;
 835    ListView_InsertColumn (hList, Col.iSubItem, &Col);
 836
 837    EnterCriticalSection (l.pcs);
 838    SendMessage (GetDlgItem (l.hManager, IDC_LIST), WM_SETREDRAW, FALSE, 0);
 839
 840    for (size_t iChunk = 0; iChunk < l.cChunks; ++iChunk)
 841       {
 842       PMEMCHUNK pChunk;
 843       if ((pChunk = (PMEMCHUNK)l.pHeap->GetAt(iChunk)) == NULL)
 844          continue;
 845
 846       pChunk->fInList = FALSE;
 847       if (!pChunk->fTared && !pChunk->fFreed)
 848          MemMgr_AddToList (pChunk);
 849       }
 850
 851    SendMessage (GetDlgItem (l.hManager, IDC_LIST), WM_SETREDRAW, TRUE, 0);
 852    LeaveCriticalSection (l.pcs);
 853
 854    l.idTimer = SetTimer (l.hManager, 0, cmsecREFRESH, NULL);
 855 }
 856
 857 void MemMgr_OnRefresh (void)
 858 {
 859    // Fill in the statistics at the top of the manager dialog
 860    //
 861    SetDlgItemInt (l.hManager, IDC_VALUE_CPP_COUNT, (INT)l.Stats.cAllocCpp, TRUE);
 862    SetDlgItemInt (l.hManager, IDC_VALUE_OTHER_COUNT, (INT)l.Stats.cAllocDyna, TRUE);
 863    SetDlgItemInt (l.hManager, IDC_VALUE_TARED_COUNT, (INT)l.Stats.cAllocTotalTared, TRUE);
 864    SetDlgItemInt (l.hManager, IDC_VALUE_TOTAL_COUNT, (INT)l.Stats.cAllocTotal, TRUE);
 865
 866    SetDlgItemBytes (l.hManager, IDC_VALUE_CPP_SIZE, (double)l.Stats.cbAllocCpp);
 867    SetDlgItemBytes (l.hManager, IDC_VALUE_OTHER_SIZE, (double)l.Stats.cbAllocDyna);
 868    SetDlgItemBytes (l.hManager, IDC_VALUE_TARED_SIZE, (double)l.Stats.cbAllocTotalTared);
 869    SetDlgItemBytes (l.hManager, IDC_VALUE_TOTAL_SIZE, (double)l.Stats.cbAllocTotal);
 870
 871    SetDlgItemBytes (l.hManager, IDC_VALUE_CPP_AVERAGE, (l.Stats.cAllocCpp) ? ((double)l.Stats.cbAllocCpp / l.Stats.cAllocCpp) : 0);
 872    SetDlgItemBytes (l.hManager, IDC_VALUE_OTHER_AVERAGE, (l.Stats.cAllocDyna) ? ((double)l.Stats.cbAllocDyna / l.Stats.cAllocDyna) : 0);
 873    SetDlgItemBytes (l.hManager, IDC_VALUE_TARED_AVERAGE, (l.Stats.cAllocTotalTared) ? ((double)l.Stats.cbAllocTotalTared / l.Stats.cAllocTotalTared) : 0);
 874    SetDlgItemBytes (l.hManager, IDC_VALUE_TOTAL_AVERAGE, (l.Stats.cAllocTotal) ? ((double)l.Stats.cbAllocTotal / l.Stats.cAllocTotal) : 0);
 875 }
 876
 877 void MemMgr_OnLabel (void)
 878 {
 879    // TODO
 880 }
 881
 882 void MemMgr_OnHide (void)
 883 {
 884    // TODO
 885 }
 886
 887 void MemMgr_OnReset (void)
 888 {
 889    l.Stats.cAllocCpp += l.Stats.cAllocCppTared;
 890    l.Stats.cAllocDyna += l.Stats.cAllocDynaTared;
 891    l.Stats.cAllocTotal += l.Stats.cAllocTotalTared;
 892    l.Stats.cbAllocCpp += l.Stats.cbAllocCppTared;
 893    l.Stats.cbAllocDyna += l.Stats.cbAllocDynaTared;
 894    l.Stats.cbAllocTotal += l.Stats.cbAllocTotalTared;
 895
 896    l.Stats.cAllocCppTared = 0;
 897    l.Stats.cAllocDynaTared = 0;
 898    l.Stats.cAllocTotalTared = 0;
 899    l.Stats.cbAllocCppTared = 0;
 900    l.Stats.cbAllocDynaTared = 0;
 901    l.Stats.cbAllocTotalTared = 0;
 902
 903    EnterCriticalSection (l.pcs);
 904    SendMessage (GetDlgItem (l.hManager, IDC_LIST), WM_SETREDRAW, FALSE, 0);
 905
 906    ListView_DeleteAllItems (GetDlgItem (l.hManager, IDC_LIST));
 907
 908    for (size_t iChunk = 0; iChunk < l.cChunks; ++iChunk)
 909       {
 910       PMEMCHUNK pChunk;
 911       if ((pChunk = (PMEMCHUNK)l.pHeap->GetAt(iChunk)) == NULL)
 912          continue;
 913
 914       pChunk->fInList = FALSE;
 915       pChunk->fTared = FALSE;
 916       if (!pChunk->fFreed)
 917          MemMgr_AddToList (pChunk);
 918       }
 919
 920    SendMessage (GetDlgItem (l.hManager, IDC_LIST), WM_SETREDRAW, TRUE, 0);
 921    LeaveCriticalSection (l.pcs);
 922
 923    MemMgr_OnRefresh();
 924 }
 925
 926 void MemMgr_OnTare (void)
 927 {
 928    l.Stats.cAllocCppTared += l.Stats.cAllocCpp;
 929    l.Stats.cAllocDynaTared += l.Stats.cAllocDyna;
 930    l.Stats.cAllocTotalTared += l.Stats.cAllocTotal;
 931    l.Stats.cbAllocCppTared += l.Stats.cbAllocCpp;
 932    l.Stats.cbAllocDynaTared += l.Stats.cbAllocDyna;
 933    l.Stats.cbAllocTotalTared += l.Stats.cbAllocTotal;
 934
 935    l.Stats.cAllocCpp = 0;
 936    l.Stats.cAllocDyna = 0;
 937    l.Stats.cAllocTotal = 0;
 938    l.Stats.cbAllocCpp = 0;
 939    l.Stats.cbAllocDyna = 0;
 940    l.Stats.cbAllocTotal = 0;
 941
 942    EnterCriticalSection (l.pcs);
 943    SendMessage (GetDlgItem (l.hManager, IDC_LIST), WM_SETREDRAW, FALSE, 0);
 944
 945    ListView_DeleteAllItems (GetDlgItem (l.hManager, IDC_LIST));
 946
 947    for (size_t iChunk = 0; iChunk < l.cChunks; ++iChunk)
 948       {
 949       PMEMCHUNK pChunk;
 950       if ((pChunk = (PMEMCHUNK)l.pHeap->GetAt(iChunk)) == NULL)
 951          continue;
 952
 953       pChunk->fInList = FALSE;
 954       pChunk->fTared = TRUE;
 955       }
 956
 957    SendMessage (GetDlgItem (l.hManager, IDC_LIST), WM_SETREDRAW, TRUE, 0);
 958    LeaveCriticalSection (l.pcs);
 959
 960    MemMgr_OnRefresh();
 961 }
 962
 963
 964 void MemMgr_OnSort (void)
 965 {
 966    EnterCriticalSection (l.pcs);
 967    SendMessage (GetDlgItem (l.hManager, IDC_LIST), WM_SETREDRAW, FALSE, 0);
 968
 969    ListView_DeleteAllItems (GetDlgItem (l.hManager, IDC_LIST));
 970
 971    for (size_t iChunk = 0; iChunk < l.cChunks; ++iChunk)
 972       {
 973       PMEMCHUNK pChunk;
 974       if ((pChunk = (PMEMCHUNK)l.pHeap->GetAt(iChunk)) == NULL)
 975          continue;
 976
 977       pChunk->fInList = FALSE;
 978       if (!pChunk->fTared && !pChunk->fFreed)
 979          MemMgr_AddToList (pChunk);
 980       }
 981
 982    SendMessage (GetDlgItem (l.hManager, IDC_LIST), WM_SETREDRAW, TRUE, 0);
 983    LeaveCriticalSection (l.pcs);
 984 }
 985
 986
 987 void MemMgr_OnPaint (void)
 988 {
 989    PAINTSTRUCT ps;
 990    HDC hdc = BeginPaint (l.hManager, &ps);
 991
 992    static HBRUSH hbr = (HBRUSH)CreateSolidBrush (GetSysColor (COLOR_BTNFACE));
 993    FillRect (hdc, &ps.rcPaint, hbr);
 994
 995    EndPaint (l.hManager, &ps);
 996 }
 997
 998
 999 void MemMgr_OnTimer (void)
1000 {
1001    if (GetWindowLongPtr (l.hManager, GWLP_USERDATA))
1002       {
1003       SetWindowLongPtr (l.hManager, GWLP_USERDATA, 0);
1004       MemMgr_OnRefresh();
1005       }
1006 }
1007
1008
1009 void MemMgr_OnDelayedRefresh (void)
1010 {
1011    SetWindowLongPtr (l.hManager, GWLP_USERDATA, 1);
1012 }
1013
1014
1015 BOOL CALLBACK MemMgr_DlgProc (HWND hDlg, UINT msg, WPARAM wp, LPARAM lp)
1016 {
1017    switch (msg)
1018       {
1019       case WM_DESTROY:
1020          MemMgr_StoreSettings();
1021          l.hManager = NULL;
1022          KillTimer (hDlg, l.idTimer);
1023          l.idTimer = (UINT_PTR)-1;
1024          break;
1025
1026       case WM_SIZE:
1027          MemMgr_OnSize();
1028          MemMgr_StoreSettings();
1029          break;
1030
1031       case WM_MOVE:
1032          MemMgr_StoreSettings();
1033          break;
1034
1035       case WM_GETMINMAXINFO:
1036          LPMINMAXINFO lpmmi;
1037          lpmmi = (LPMINMAXINFO)lp;
1038          lpmmi->ptMinTrackSize.x = cxBUTTONS*5 + cxBETWEEN*4 + cBORDER*2 + 8;
1039          lpmmi->ptMinTrackSize.y = 270;
1040          return FALSE;
1041
1042       case WM_PAINT:
1043          MemMgr_OnPaint();
1044          break;
1045
1046       case WM_NOTIFY:
1047          switch (((NMHDR *)lp)->code)
1048             {
1049             case LVN_COLUMNCLICK:
1050                if (((NM_LISTVIEW*)lp)->iSubItem == lr.iColSort)
1051                   lr.fSortRev = !lr.fSortRev;
1052                else
1053                   {
1054                   lr.iColSort = ((NM_LISTVIEW*)lp)->iSubItem;
1055                   lr.fSortRev = FALSE;
1056                   }
1057                MemMgr_OnSort();
1058                MemMgr_StoreSettings();
1059                break;
1060             }
1061          break;
1062
1063       case WM_TIMER:
1064          MemMgr_OnTimer();
1065          break;
1066
1067       case WM_COMMAND:
1068          switch (LOWORD(wp))
1069             {
1070             case IDCANCEL:
1071                DestroyWindow (hDlg);
1072                break;
1073
1074             case IDC_INITIALIZE:
1075                MemMgr_OnInit();
1076                MemMgr_OnRefresh();
1077                break;
1078
1079             case IDC_REFRESH:
1080                MemMgr_OnDelayedRefresh();
1081                break;
1082
1083             case IDC_LABEL:
1084                MemMgr_OnLabel();
1085                break;
1086
1087             case IDC_HIDE:
1088                MemMgr_OnHide();
1089                break;
1090
1091             case IDC_RESET:
1092                MemMgr_OnReset();
1093                break;
1094
1095             case IDC_TARE:
1096                MemMgr_OnTare();
1097                break;
1098
1099             case IDC_LIST_REMOVEADD:
1100                MemMgr_OnListRemove (((PMEMCHUNK)lp)->pData);
1101                MemMgr_OnListAdd ((PMEMCHUNK)lp);
1102                break;
1103
1104             case IDC_LIST_ADD:
1105                MemMgr_OnListAdd ((PMEMCHUNK)lp);
1106                break;
1107
1108             case IDC_LIST_REMOVE:
1109                MemMgr_OnListRemove ((PVOID)lp);
1110                break;
1111             }
1112          break;
1113       }
1114
1115    return (BOOL) DefWindowProc (hDlg, msg, wp, lp);
1116 }
1117
1118
1119 /*
1120  * MANAGEMENT ROUTINES ________________________________________________________
1121  *
1122  */
1123
1124 BOOL MemMgr_Initialize (void)
1125 {
1126    if (!l.pHeap)
1127       {
1128       l.pcs = new CRITICAL_SECTION;
1129       InitializeCriticalSection (l.pcs);
1130
1131       l.pHeap = new ALLOCEXPANDARRAY (sizeof(MEMCHUNK));
1132
1133       REALLOC (l.aBuckets, l.cBuckets, cDEFAULT_BUCKETS, 1);
1134       if (l.aBuckets)
1135          {
1136          for (size_t ii = 0; ii < l.cBuckets; ++ii)
1137             l.aBuckets[ii].iFirst = iINVALID;
1138          }
1139       }
1140
1141    return (l.pHeap) && (l.aBuckets);
1142 }
1143
1144
1145 void MemMgr_TrackAllocation (PVOID pData, size_t cb, LPTSTR pszExpr, LPTSTR pszFile, DWORD dwLine, BOOL fSig)
1146 {
1147    if (!pData)
1148       return;
1149    if (!MemMgr_Initialize())
1150       return;
1151
1152    EnterCriticalSection (l.pcs);
1153
1154    // Ensure our hash table will be large enough to handle the new
1155    // MEMCHUNK we're about to assign.
1156    //
1157    if (l.cBuckets < MIN_BUCKETS(l.cChunks+1))
1158       {
1159       // Too small! Rebuild the hash table.
1160       //
1161       REALLOC (l.aBuckets, l.cBuckets, TARGET_BUCKETS(l.cChunks+1), 1);
1162       if (l.aBuckets)
1163          {
1164          for (size_t ii = 0; ii < l.cBuckets; ++ii)
1165             l.aBuckets[ii].iFirst = iINVALID;
1166
1167          for (size_t iChunk = 0; iChunk < l.cChunks; ++iChunk)
1168             {
1169             PMEMCHUNK pChunk;
1170             if ((pChunk = (PMEMCHUNK)l.pHeap->GetAt(iChunk)) == NULL)
1171                continue;
1172
1173             size_t iBucket = HASH(PtrToUlong(pChunk->pData),l.cBuckets);
1174             if ((pChunk->iNext = l.aBuckets[iBucket].iFirst) != iINVALID)
1175                {
1176                PMEMCHUNK pNext;
1177                if ((pNext = (PMEMCHUNK)l.pHeap->GetAt(pChunk->iNext)) != NULL)
1178                   pNext->iPrev = iChunk;
1179                }
1180             l.aBuckets[iBucket].iFirst = iChunk;
1181             pChunk->iPrev = iINVALID;
1182             }
1183          }
1184       }
1185
1186    // If space was allocated for a trailing signature, write one
1187    //
1188    if (fSig)
1189       *(DWORD *)( (PBYTE)pData + cb ) = dwSIG_AT_END;
1190
1191    // Prepare a MEMCHUNK entry and shove it in our array
1192    //
1193    size_t iChunk = l.cChunks;
1194    size_t iBucket = HASH(PtrToUlong(pData),l.cBuckets);
1195    BOOL fLinkIn = TRUE;
1196
1197    MEMCHUNK Chunk;
1198    Chunk.pData = pData;
1199    Chunk.fFreed = FALSE;
1200    Chunk.cbData = cb;
1201    Chunk.pszExpr = pszExpr;
1202    Chunk.pszFile = pszFile;
1203    Chunk.fCPP = !fSig;
1204    Chunk.dwLine = dwLine;
1205    Chunk.dwTick = GetTickCount();
1206    Chunk.dwEndSig = (fSig) ? dwSIG_AT_END : 0;
1207    Chunk.fInList = FALSE;
1208    Chunk.fTared = FALSE;
1209
1210 #ifdef TRACK_FREED
1211    // Find the memchunk associated with this pData. That's what our
1212    // hash table is for.
1213    //
1214    for (iChunk = l.aBuckets[iBucket].iFirst; iChunk != iINVALID; )
1215       {
1216       PMEMCHUNK pChunk;
1217       if ((pChunk = (PMEMCHUNK)l.pHeap->GetAt(iChunk)) != NULL)
1218          {
1219          if (pChunk->pData == pData)
1220             {
1221             Chunk.iNext = pChunk->iNext;
1222             Chunk.iPrev = pChunk->iPrev;
1223             fLinkIn = FALSE;
1224             break;
1225             }
1226          }
1227       iChunk = (pChunk) ? pChunk->iNext : iINVALID;
1228       }
1229    if (iChunk == iINVALID)
1230       iChunk = l.cChunks;
1231 #endif
1232
1233    l.cChunks = max (l.cChunks, 1+iChunk);
1234
1235    if (fLinkIn)
1236       {
1237       if ((Chunk.iNext = l.aBuckets[iBucket].iFirst) != iINVALID)
1238          {
1239          PMEMCHUNK pNext;
1240          if ((pNext = (PMEMCHUNK)l.pHeap->GetAt(Chunk.iNext)) != NULL)
1241             pNext->iPrev = iChunk;
1242          }
1243       l.aBuckets[iBucket].iFirst = iChunk;
1244       Chunk.iPrev = iINVALID;
1245       }
1246
1247    if (IsWindow (l.hManager))
1248       MemMgr_AddToList (&Chunk);
1249
1250    l.pHeap->SetAt (iChunk, &Chunk);
1251
1252    if (Chunk.fCPP)
1253       l.Stats.cAllocCpp ++;
1254    else // (!Chunk.fCPP)
1255       l.Stats.cAllocDyna ++;
1256
1257    if (Chunk.fCPP)
1258       l.Stats.cbAllocCpp += Chunk.cbData;
1259    else // (!Chunk.fCPP)
1260       l.Stats.cbAllocDyna += Chunk.cbData;
1261
1262    l.Stats.cAllocTotal ++;
1263    l.Stats.cbAllocTotal += Chunk.cbData;
1264
1265    LeaveCriticalSection (l.pcs);
1266
1267    if (IsWindow (l.hManager))
1268       PostMessage (l.hManager, WM_COMMAND, IDC_REFRESH, 0);
1269 }
1270
1271
1272 BOOL MemMgr_TrackDestruction (PVOID pData, LPTSTR pszFile, DWORD dwLine)
1273 {
1274    if (MemMgr_Initialize())
1275       {
1276       EnterCriticalSection (l.pcs);
1277
1278       // Find the memchunk associated with this pData. That's what our
1279       // hash table is for.
1280       //
1281       size_t iBucket = HASH(PtrToUlong(pData),l.cBuckets);
1282
1283       PMEMCHUNK pChunk = NULL;
1284       for (size_t iChunk = l.aBuckets[iBucket].iFirst; iChunk != iINVALID; )
1285          {
1286          if ((pChunk = (PMEMCHUNK)l.pHeap->GetAt(iChunk)) == NULL)
1287             break;
1288          if (pChunk->pData == pData)
1289             break;
1290          if ((iChunk = pChunk->iNext) == iINVALID)
1291             {
1292             pChunk = NULL;
1293             break;
1294             }
1295          }
1296
1297       if (!pChunk)
1298          {
1299          MEMCHUNK Sim;
1300          memset (&Sim, 0x00, sizeof(MEMCHUNK));
1301          Sim.pData = pData;
1302          Sim.pszExpr = TEXT("(unknown)");
1303          Sim.pszFile = TEXT("(unknown)");
1304          MemMgr_ShowWarning (&Sim, pszFile, dwLine, TEXT("An invalid memory address was freed."));
1305          }
1306       else if (pChunk->dwEndSig && (*(DWORD*)((PBYTE)pData + pChunk->cbData) != pChunk->dwEndSig))
1307          {
1308          MemMgr_ShowWarning (pChunk, pszFile, dwLine, TEXT("The trailing signature on a block of memory was overwritten."));
1309          }
1310       else if (pChunk->fFreed)
1311          {
1312          MemMgr_ShowWarning (pChunk, pszFile, dwLine, TEXT("A block of memory was freed more than once."));
1313          }
1314
1315       if (pChunk)
1316          {
1317          pChunk->fFreed = TRUE;
1318
1319          if (IsWindow (l.hManager))
1320             {
1321             if (pChunk->fInList)
1322                MemMgr_RemoveFromList (pChunk);
1323             }
1324
1325          if (pChunk->fCPP)
1326             l.Stats.cAllocCpp --;
1327          else // (!pChunk->fCPP)
1328             l.Stats.cAllocDyna --;
1329
1330          if (pChunk->fCPP)
1331             l.Stats.cbAllocCpp -= pChunk->cbData;
1332          else // (!pChunk->fCPP)
1333             l.Stats.cbAllocDyna -= pChunk->cbData;
1334
1335          l.Stats.cAllocTotal --;
1336          l.Stats.cbAllocTotal -= pChunk->cbData;
1337
1338 #ifndef TRACK_FREED
1339
1340          // Unlink this chunk from the hash table
1341          //
1342          if (pChunk->iNext != iINVALID)
1343             {
1344             PMEMCHUNK pNext;
1345             if ((pNext = (PMEMCHUNK)l.pHeap->GetAt(pChunk->iNext)) != NULL)
1346                pNext->iPrev = pChunk->iPrev;
1347             }
1348          if (pChunk->iPrev != iINVALID)
1349             {
1350             PMEMCHUNK pPrev;
1351             if ((pPrev = (PMEMCHUNK)l.pHeap->GetAt(pChunk->iPrev)) != NULL)
1352                pPrev->iNext = pChunk->iNext;
1353             }
1354          if (l.aBuckets[iBucket].iFirst == iChunk)
1355             l.aBuckets[iBucket].iFirst = pChunk->iNext;
1356
1357          // Empty this element in the expandarray. That means we need to
1358          // take the last element and shove it in here--so we'll have do
1359          // rework the hash table a little bit more.
1360          //
1361          if (iChunk != l.cChunks-1)
1362             {
1363             PMEMCHUNK pMove;
1364             if ((pMove = (PMEMCHUNK)l.pHeap->GetAt(l.cChunks-1)) != NULL)
1365                {
1366                size_t iBucket = HASH(pMove->pData,l.cBuckets);
1367
1368                if (pMove->iNext != iINVALID)
1369                   {
1370                   PMEMCHUNK pNext;
1371                   if ((pNext = (PMEMCHUNK)l.pHeap->GetAt(pMove->iNext)) != NULL)
1372                      pNext->iPrev = iChunk;
1373                   }
1374                if (pMove->iPrev != iINVALID)
1375                   {
1376                   PMEMCHUNK pPrev;
1377                   if ((pPrev = (PMEMCHUNK)l.pHeap->GetAt(pMove->iPrev)) != NULL)
1378                      pPrev->iNext = iChunk;
1379                   }
1380                if (l.aBuckets[iBucket].iFirst == (l.cChunks-1))
1381                   l.aBuckets[iBucket].iFirst = iChunk;
1382
1383                l.pHeap->SetAt (iChunk, pMove);
1384                memset (pMove, 0x00, sizeof(MEMCHUNK));
1385                }
1386             }
1387
1388          l.cChunks --;
1389
1390 #endif // TRACK_FREED
1391          }
1392
1393       LeaveCriticalSection (l.pcs);
1394       }
1395
1396    if (IsWindow (l.hManager))
1397       PostMessage (l.hManager, WM_COMMAND, IDC_REFRESH, 0);
1398    return TRUE;
1399 }
1400
1401
1402 /*
1403  * PUBLIC ROUTINES ____________________________________________________________
1404  *
1405  */
1406
1407 void MEMMGR_CALLCONV ShowMemoryManager (void)
1408 {
1409    if (MemMgr_Initialize())
1410       {
1411       if (!IsWindow (l.hManager))
1412          {
1413          MemMgr_RestoreSettings();
1414          l.hManager = MakeWindow (TEXT("Static"), cszTITLE, WS_OVERLAPPED | WS_THICKFRAME | WS_SYSMENU, &lr.rManager, 0, 0);
1415          SetWindowLongPtr (l.hManager, GWLP_WNDPROC, (LONG)PtrToUlong(MemMgr_DlgProc));
1416          PostMessage (l.hManager, WM_COMMAND, IDC_INITIALIZE, 0);
1417          ShowWindow (l.hManager, SW_SHOW);
1418          }
1419       }
1420 }
1421
1422
1423 void MEMMGR_CALLCONV WhileMemoryManagerShowing (void)
1424 {
1425    if (MemMgr_Initialize())
1426       {
1427       while (IsWindow (l.hManager))
1428          {
1429          MSG msg;
1430          if (!GetMessage (&msg, NULL, 0, 0))
1431             break;
1432
1433          if (!IsDialogMessage (l.hManager, &msg))
1434             {
1435             TranslateMessage (&msg);
1436             DispatchMessage (&msg);
1437             }
1438          }
1439       }
1440 }
1441
1442
1443 BOOL MEMMGR_CALLCONV IsMemoryManagerMessage (MSG *pMsg)
1444 {
1445    if (IsWindow (l.hManager))
1446       {
1447       if (pMsg->hwnd == l.hManager)
1448          {
1449 //       if (IsDialogMessage (l.hManager, pMsg))
1450 //          return TRUE;
1451          }
1452       }
1453    else if ((pMsg->message == WM_KEYDOWN) && (pMsg->wParam == VK_F8))
1454       {
1455       ShowMemoryManager();
1456       return TRUE;
1457       }
1458    return FALSE;
1459 }
1460
1461
1462 PVOID MEMMGR_CALLCONV MemMgr_AllocateMemory (size_t cb, LPTSTR pszExpr, LPTSTR pszFile, DWORD dwLine)
1463 {
1464    PVOID pData = GlobalAlloc (GMEM_FIXED, cb + sizeof(DWORD));
1465    MemMgr_TrackAllocation (pData, cb, pszExpr, pszFile, dwLine, TRUE);
1466    return pData;
1467 }
1468
1469
1470 void MEMMGR_CALLCONV MemMgr_FreeMemory (PVOID pData, LPTSTR pszFile, DWORD dwLine)
1471 {
1472    if (MemMgr_TrackDestruction (pData, pszFile, dwLine))
1473       {
1474       GlobalFree ((HGLOBAL)pData);
1475       }
1476 }
1477
1478
1479 PVOID MEMMGR_CALLCONV MemMgr_TrackNew (PVOID pData, size_t cb, LPTSTR pszExpr, LPTSTR pszFile, DWORD dwLine)
1480 {
1481    MemMgr_TrackAllocation (pData, cb, pszExpr, pszFile, dwLine, FALSE);
1482    return pData;
1483 }
1484
1485
1486 void MEMMGR_CALLCONV MemMgr_TrackDelete (PVOID pData, LPTSTR pszFile, DWORD dwLine)
1487 {
1488    MemMgr_TrackDestruction (pData, pszFile, dwLine);
1489 }
1490
1491
1492 /*
1493  * EXPANDARRAY ________________________________________________________________
1494  *
1495  * We'll use an EXPANDARRAY to manage our heap of allocation information.
1496  * Technically I would prefer to use a full HASHLIST here, but I don't want
1497  * this source file to be dependent upon yet another file. So we'll kinda
1498  * write a special-purpose hash system.
1499  *
1500  */
1501
1502 #define cEXPANDARRAYHEAPELEMENTS  1024
1503 #define cREALLOC_EXPANDARRAYHEAPS   16
1504
1505 ALLOCEXPANDARRAY::ALLOCEXPANDARRAY (size_t cbElement, size_t cElementsPerHeap)
1506 {
1507    if ((m_cbElement = cbElement) == 0)
1508       m_cbElement = sizeof(DWORD);
1509    if ((m_cElementsPerHeap = cElementsPerHeap) == 0)
1510       m_cElementsPerHeap = cEXPANDARRAYHEAPELEMENTS;
1511
1512    m_cHeaps = 0;
1513    m_aHeaps = 0;
1514 }
1515
1516 ALLOCEXPANDARRAY::~ALLOCEXPANDARRAY (void)
1517 {
1518    if (m_aHeaps)
1519       {
1520       for (size_t ii = 0; ii < m_cHeaps; ++ii)
1521          GlobalFree ((HGLOBAL)(m_aHeaps[ ii ]));
1522       GlobalFree ((HGLOBAL)m_aHeaps);
1523       }
1524 }
1525
1526 PVOID ALLOCEXPANDARRAY::GetAt (size_t iElement)
1527 {
1528    size_t iHeap = iElement / m_cElementsPerHeap;
1529    size_t iIndex = iElement % m_cElementsPerHeap;
1530    if ((iHeap >= m_cHeaps) || (!m_aHeaps[iHeap]))
1531       return NULL;
1532    return (PVOID)&((PBYTE)m_aHeaps[ iHeap ]->aElements)[ iIndex * m_cbElement ];
1533 }
1534
1535 void ALLOCEXPANDARRAY::SetAt (size_t iElement, PVOID pData)
1536 {
1537    size_t iHeap = iElement / m_cElementsPerHeap;
1538    size_t iIndex = iElement % m_cElementsPerHeap;
1539
1540    if (!REALLOC (m_aHeaps, m_cHeaps, 1+iHeap, cREALLOC_EXPANDARRAYHEAPS))
1541       return;
1542
1543    if (!m_aHeaps[ iHeap ])
1544       {
1545       size_t cbHeap = sizeof(EXPANDARRAYHEAP) + (m_cElementsPerHeap * m_cbElement);
1546       if ((m_aHeaps[ iHeap ] = (LPEXPANDARRAYHEAP)GlobalAlloc (GMEM_FIXED, cbHeap)) == NULL)
1547          return;
1548       memset (m_aHeaps[ iHeap ], 0x00, cbHeap);
1549       m_aHeaps[ iHeap ]->aElements = ((PBYTE)m_aHeaps[ iHeap ]) + sizeof(EXPANDARRAYHEAP);
1550       }
1551
1552    if (!pData)
1553       memset (&((PBYTE)m_aHeaps[ iHeap ]->aElements)[ iIndex * m_cbElement ], 0x00, m_cbElement);
1554    else
1555       memcpy (&((PBYTE)m_aHeaps[ iHeap ]->aElements)[ iIndex * m_cbElement ], pData, m_cbElement);
1556 }
1557