prj/tech/libsrc/lgalloc/primallc.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // $Source: x:/prj/tech/libsrc/lgalloc/RCS/primallc.cpp $
   3 // $Author: TOML $
   4 // $Date: 1998/06/10 13:58:15 $
   5 // $Revision: 1.7 $
   6 //
   7
   8 #ifdef _WIN32
   9
  10 #include <lg.h>
  11 #undef Free
  12 #undef Malloc
  13 #undef Realloc
  14
  15 #include <memcore.h>
  16 #include <primallc.h>
  17
  18 #pragma code_seg("lgalloc")
  19
  20 ///////////////////////////////////////////////////////////////////////////////
  21
  22 volatile cFastMutex g_AllocMutex;
  23
  24 ///////////////////////////////////////////////////////////////////////////////
  25 //
  26 // CLASS: cPrimaryMalloc, members
  27 //
  28
  29 cPrimaryMalloc::cPrimaryMalloc()
  30 {
  31     initAllocCap = 0x2000000;
  32     allocCap     = 0x2000000;
  33     totalAlloc   = 0;
  34     #ifndef SHIP
  35     peakAlloc    = 0;
  36     #endif
  37 }
  38
  39 ///////////////////////////////////////
  40
  41 cPrimaryMalloc::~cPrimaryMalloc()
  42 {
  43
  44 }
  45
  46 ///////////////////////////////////////
  47
  48 ulong LGAPI cPrimaryMalloc::DefPageFunc(ulong needed, sAllocLimits * pLimits)
  49 {
  50     return 0;
  51 }
  52
  53 ///////////////////////////////////////
  54
  55 STDMETHODIMP_(void *) cPrimaryMalloc::Alloc(ULONG size)
  56 {
  57     // @Note (toml 07-14-97): This code is block copied in AllocEx and should be kept in sync
  58     if (!size)
  59         size = 1;  // For VC compatibility, allow 0 sized allocations.
  60
  61     IAllocator * const pNext = m_pNext;
  62     void * p;
  63     BOOL   fMoreToPage = FALSE;
  64
  65     // Until we actually allocate a block...
  66     do
  67     {
  68         // Page memory if over limit
  69         if (totalAlloc > allocCap)
  70             fMoreToPage = ((*m_pfnPage)(size, this) != 0);
  71
  72         // Allocate our block
  73         AllocThreadLock();
  74         p = pNext->Alloc(size);
  75         if (p)
  76         {
  77             totalAlloc += pNext->GetSize(p);
  78 #ifndef SHIP
  79             if (totalAlloc > peakAlloc)
  80                 peakAlloc = totalAlloc;
  81 #endif
  82             AllocThreadUnlock();
  83             return p;
  84         }
  85         AllocThreadUnlock();
  86
  87     } while (fMoreToPage);
  88
  89     g_fQuietAssert = FALSE;
  90     CriticalMsg("Out of memory");
  91
  92     return NULL;
  93 }
  94
  95 ///////////////////////////////////////
  96
  97 STDMETHODIMP_(void *) cPrimaryMalloc::Realloc(void * pOld, ULONG newClientSize)
  98 {
  99     // @Note (toml 07-14-97): This code is block copied in ReallocEx and should be kept in sync
 100
 101     // Let's handle ANSI behaviors here...
 102     if (!pOld)
 103         return cPrimaryMalloc::Alloc(newClientSize);
 104
 105     if (!newClientSize)
 106     {
 107         cPrimaryMalloc::Free(pOld);
 108         return 0;
 109     }
 110
 111     AllocThreadLock();
 112
 113     void *    pNew;
 114     const int oldClientSize = m_pNext->GetSize(pOld);
 115     BOOL      fMoreToPage = FALSE;
 116     const int difference = newClientSize - oldClientSize;
 117
 118     do
 119     {
 120         if (difference > 0 && m_pfnPage && totalAlloc > allocCap)
 121         {
 122             AllocThreadUnlock();
 123             fMoreToPage = ((*m_pfnPage)(difference, this) != 0);
 124             AllocThreadLock();
 125         }
 126
 127         pNew = m_pNext->Realloc(pOld, newClientSize);
 128
 129     } while (!pNew && fMoreToPage);
 130
 131     if (pNew)
 132     {
 133         totalAlloc += m_pNext->GetSize(pNew) - oldClientSize;
 134         #ifndef SHIP
 135         if (totalAlloc > peakAlloc)
 136             peakAlloc = totalAlloc;
 137         #endif
 138     }
 139     else
 140     {
 141         g_fQuietAssert = FALSE;
 142         CriticalMsg("Out of memory");
 143     }
 144
 145     AllocThreadUnlock();
 146
 147     return pNew;
 148 }
 149
 150 ///////////////////////////////////////
 151
 152 STDMETHODIMP_(void) cPrimaryMalloc::Free(void * p)
 153 {
 154     // @Note (toml 07-14-97): This code is block copied in FreeEx and should be kept in sync
 155     if (!p)
 156         return;
 157
 158     AllocThreadLock();
 159     IAllocator * const pNext = m_pNext;
 160     totalAlloc -= pNext->GetSize(p);
 161     pNext->Free(p);
 162     AllocThreadUnlock();
 163 }
 164
 165 ///////////////////////////////////////
 166
 167 STDMETHODIMP_(ULONG) cPrimaryMalloc::GetSize(void * p)
 168 {
 169     ulong result;
 170
 171     if (!p)
 172         return 0;
 173
 174     AllocThreadLock();
 175     result = m_pNext->GetSize(p);
 176     AllocThreadUnlock();
 177
 178     return result;
 179 }
 180
 181 ///////////////////////////////////////
 182
 183 STDMETHODIMP_(int) cPrimaryMalloc::DidAlloc(void * pv)
 184 {
 185     int result;
 186
 187     AllocThreadLock();
 188     result = m_pNext->DidAlloc(pv);
 189     AllocThreadUnlock();
 190
 191     return result;
 192 }
 193
 194 ///////////////////////////////////////
 195
 196 STDMETHODIMP_(void) cPrimaryMalloc::HeapMinimize()
 197 {
 198     AllocThreadLock();
 199     m_pNext->HeapMinimize();
 200     AllocThreadUnlock();
 201 }
 202
 203 ///////////////////////////////////////
 204 #ifndef SHIP
 205
 206 STDMETHODIMP_(void *) cPrimaryMalloc::AllocEx(ULONG size, const char * pszFile, int line)
 207 {
 208     // @Note (toml 07-14-97): This code is block copied FROM Alloc and should be kept in sync
 209     if (!size)
 210         size = 1;  // For VC compatibility, allow 0 sized allocations.
 211
 212     IAllocator * const pNext = m_pNext;
 213     void * p;
 214     BOOL   fMoreToPage = FALSE;
 215
 216     // Until we actually allocate a block...
 217     do
 218     {
 219         // Page memory if over limit
 220         if (totalAlloc > allocCap)
 221             fMoreToPage = ((*m_pfnPage)(size, this) != 0);
 222
 223         // Allocate our block
 224         AllocThreadLock();
 225         p = pNext->AllocEx(size, pszFile, line);
 226         if (p)
 227         {
 228             totalAlloc += pNext->GetSize(p);
 229 #ifndef SHIP
 230             if (totalAlloc > peakAlloc)
 231                 peakAlloc = totalAlloc;
 232 #endif
 233             AllocThreadUnlock();
 234             return p;
 235         }
 236         AllocThreadUnlock();
 237
 238     } while (fMoreToPage);
 239
 240     g_fQuietAssert = FALSE;
 241     CriticalMsg("Out of memory");
 242
 243     return NULL;
 244 }
 245
 246 ///////////////////////////////////////
 247
 248 STDMETHODIMP_(void *) cPrimaryMalloc::ReallocEx(void * pOld, ULONG newClientSize, const char * pszFile, int line)
 249 {
 250     // @Note (toml 07-14-97): This code is block copied FROM Realloc and should be kept in sync
 251
 252     // Let's handle ANSI behaviors here...
 253     if (!pOld)
 254         return cPrimaryMalloc::Alloc(newClientSize);
 255
 256     if (!newClientSize)
 257     {
 258         cPrimaryMalloc::Free(pOld);
 259         return 0;
 260     }
 261
 262     AllocThreadLock();
 263
 264     void *    pNew;
 265     const int oldClientSize = m_pNext->GetSize(pOld);
 266     BOOL      fMoreToPage = FALSE;
 267     const int difference = newClientSize - oldClientSize;
 268
 269     do
 270     {
 271         if (difference > 0 && m_pfnPage && totalAlloc > allocCap)
 272         {
 273             AllocThreadUnlock();
 274             fMoreToPage = ((*m_pfnPage)(difference, this) != 0);
 275             AllocThreadLock();
 276         }
 277
 278         pNew = m_pNext->ReallocEx(pOld, newClientSize, pszFile, line);
 279
 280     } while (!pNew && fMoreToPage);
 281
 282     if (pNew)
 283     {
 284         totalAlloc += m_pNext->GetSize(pNew) - oldClientSize;
 285         #ifndef SHIP
 286         if (totalAlloc > peakAlloc)
 287             peakAlloc = totalAlloc;
 288         #endif
 289     }
 290     else
 291     {
 292         g_fQuietAssert = FALSE;
 293         CriticalMsg("Out of memory");
 294     }
 295
 296     AllocThreadUnlock();
 297
 298     return pNew;
 299 }
 300
 301 ///////////////////////////////////////
 302
 303 STDMETHODIMP_(void) cPrimaryMalloc::FreeEx(void * p, const char * pszFile, int line)
 304 {
 305     // @Note (toml 07-14-97): This code is block copied FROM Free and should be kept in sync
 306     if (!p)
 307         return;
 308
 309     AllocThreadLock();
 310     IAllocator * const pNext = m_pNext;
 311     totalAlloc -= pNext->GetSize(p);
 312     pNext->FreeEx(p, pszFile, line);
 313     AllocThreadUnlock();
 314 }
 315
 316 ///////////////////////////////////////
 317
 318 STDMETHODIMP cPrimaryMalloc::VerifyAlloc(void * p)
 319 {
 320     if (!p)
 321         return S_OK;
 322
 323     HRESULT result;
 324
 325     AllocThreadLock();
 326     result = m_pNext->VerifyAlloc(p);
 327     AllocThreadUnlock();
 328
 329     return result;
 330 }
 331
 332 ///////////////////////////////////////
 333
 334 STDMETHODIMP cPrimaryMalloc::VerifyHeap()
 335 {
 336     HRESULT result;
 337
 338     AllocThreadLock();
 339     result = m_pNext->VerifyHeap();
 340     AllocThreadUnlock();
 341
 342     return result;
 343 }
 344
 345 #endif
 346 ///////////////////////////////////////////////////////////////////////////////
 347 #endif