This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
support using the CRT's malloc() family of functions instead of
authorGurusamy Sarathy <gsar@cpan.org>
Fri, 11 Jan 2002 01:05:15 +0000 (01:05 +0000)
committerGurusamy Sarathy <gsar@cpan.org>
Fri, 11 Jan 2002 01:05:15 +0000 (01:05 +0000)
the internal one when ithreads is enabled; allocate large blocks
using VirtualAlloc() since the Heap*() functions may only be tuned
for small allocations (from Doug Lankshear <dougl@ActiveState.com>)

pass -D_USE_MSVCRT_MEM_ALLOC via cflags to enable the CRT's malloc();
also see comments at the top of win32/vmem.h for other options that
can be set

p4raw-id: //depot/perl@14175

win32/vmem.h

index a0e5eba..cda6f81 100644 (file)
@@ -6,7 +6,242 @@
  *    You may distribute under the terms of either the GNU General Public
  *    License or the Artistic License, as specified in the README file.
  *
+ * Options:
  *
+ * Defining _USE_MSVCRT_MEM_ALLOC will cause all memory allocations
+ * to be forwarded to MSVCRT.DLL. Defining _USE_LINKED_LIST as well will
+ * track all allocations in a doubly linked list, so that the host can
+ * free all memory allocated when it goes away.
+ * If _USE_MSVCRT_MEM_ALLOC is not defined then Knuth's boundary tag algorithm
+ * is used; defining _USE_BUDDY_BLOCKS will use Knuth's algorithm R
+ * (Buddy system reservation)
+ *
+ */
+
+#ifndef ___VMEM_H_INC___
+#define ___VMEM_H_INC___
+
+// #define _USE_MSVCRT_MEM_ALLOC
+
+// #define _USE_BUDDY_BLOCKS
+
+// #define _DEBUG_MEM
+#ifdef _DEBUG_MEM
+#define ASSERT(f) if(!(f)) DebugBreak();
+
+inline void MEMODS(char *str)
+{
+    OutputDebugString(str);
+    OutputDebugString("\n");
+}
+
+inline void MEMODSlx(char *str, long x)
+{
+    char szBuffer[512];        
+    sprintf(szBuffer, "%s %lx\n", str, x);
+    OutputDebugString(szBuffer);
+}
+
+#define WALKHEAP() WalkHeap(0)
+#define WALKHEAPTRACE() WalkHeap(1)
+
+#else
+
+#define ASSERT(f)
+#define MEMODS(x)
+#define MEMODSlx(x, y)
+#define WALKHEAP()
+#define WALKHEAPTRACE()
+
+#endif
+
+#ifdef _USE_MSVCRT_MEM_ALLOC
+
+#ifndef _USE_LINKED_LIST
+// #define _USE_LINKED_LIST
+#endif
+
+/* 
+ * Pass all memory requests throught to msvcrt.dll 
+ * optionaly track by using a doubly linked header
+ */
+
+typedef void (*LPFREE)(void *block);
+typedef void* (*LPMALLOC)(size_t size);
+typedef void* (*LPREALLOC)(void *block, size_t size);
+#ifdef _USE_LINKED_LIST
+typedef struct _MemoryBlockHeader* PMEMORY_BLOCK_HEADER;
+typedef struct _MemoryBlockHeader {
+    PMEMORY_BLOCK_HEADER    pNext;
+    PMEMORY_BLOCK_HEADER    pPrev;
+} MEMORY_BLOCK_HEADER, *PMEMORY_BLOCK_HEADER;
+#endif
+
+class VMem
+{
+public:
+    VMem();
+    ~VMem();
+    virtual void* Malloc(size_t size);
+    virtual void* Realloc(void* pMem, size_t size);
+    virtual void Free(void* pMem);
+    virtual void GetLock(void);
+    virtual void FreeLock(void);
+    virtual int IsLocked(void);
+    virtual long Release(void);
+    virtual long AddRef(void);
+
+    inline BOOL CreateOk(void)
+    {
+       return TRUE;
+    };
+
+protected:
+#ifdef _USE_LINKED_LIST
+    void LinkBlock(PMEMORY_BLOCK_HEADER ptr)
+    {
+       PMEMORY_BLOCK_HEADER next = m_Dummy.pNext;
+       m_Dummy.pNext = ptr;
+       ptr->pPrev = &m_Dummy;
+       ptr->pNext = next;
+       next->pPrev = ptr;
+    }
+    void UnlinkBlock(PMEMORY_BLOCK_HEADER ptr)
+    {
+       PMEMORY_BLOCK_HEADER next = ptr->pNext;
+       PMEMORY_BLOCK_HEADER prev = ptr->pPrev;
+       prev->pNext = next;
+       next->pPrev = prev;
+    }
+
+    MEMORY_BLOCK_HEADER        m_Dummy;
+#endif
+
+    long               m_lRefCount;    // number of current users
+    CRITICAL_SECTION   m_cs;           // access lock
+    HINSTANCE          m_hLib;
+    LPFREE             m_pfree;
+    LPMALLOC           m_pmalloc;
+    LPREALLOC          m_prealloc;
+};
+
+VMem::VMem()
+{
+    m_lRefCount = 1;
+    InitializeCriticalSection(&m_cs);
+#ifdef _USE_LINKED_LIST
+    m_Dummy.pNext = m_Dummy.pPrev =  &m_Dummy;
+#endif
+    m_hLib = LoadLibrary("msvcrt.dll");
+    if (m_hLib) {
+       m_pfree = (LPFREE)GetProcAddress(m_hLib, "free");
+       m_pmalloc = (LPMALLOC)GetProcAddress(m_hLib, "malloc");
+       m_prealloc = (LPREALLOC)GetProcAddress(m_hLib, "realloc");
+    }
+}
+
+VMem::~VMem(void)
+{
+#ifdef _USE_LINKED_LIST
+    while (m_Dummy.pNext != &m_Dummy) {
+       Free(m_Dummy.pNext+1);
+    }
+#endif
+    if (m_hLib)
+       FreeLibrary(m_hLib);
+    DeleteCriticalSection(&m_cs);
+}
+
+void* VMem::Malloc(size_t size)
+{
+#ifdef _USE_LINKED_LIST
+    PMEMORY_BLOCK_HEADER ptr = (PMEMORY_BLOCK_HEADER)m_pmalloc(size+sizeof(MEMORY_BLOCK_HEADER));
+    LinkBlock(ptr);
+    return (ptr+1);
+#else
+    return m_pmalloc(size);
+#endif
+}
+
+void* VMem::Realloc(void* pMem, size_t size)
+{
+#ifdef _USE_LINKED_LIST
+    if (!pMem)
+       return Malloc(size);
+
+    if (!size) {
+       Free(pMem);
+       return NULL;
+    }
+
+    PMEMORY_BLOCK_HEADER ptr = (PMEMORY_BLOCK_HEADER)(((char*)pMem)-sizeof(MEMORY_BLOCK_HEADER));
+    UnlinkBlock(ptr);
+    ptr = (PMEMORY_BLOCK_HEADER)m_prealloc(ptr, size+sizeof(MEMORY_BLOCK_HEADER));
+    LinkBlock(ptr);
+
+    return (ptr+1);
+#else
+    return m_prealloc(pMem, size);
+#endif
+}
+
+void VMem::Free(void* pMem)
+{
+#ifdef _USE_LINKED_LIST
+    if (pMem) {
+       PMEMORY_BLOCK_HEADER ptr = (PMEMORY_BLOCK_HEADER)(((char*)pMem)-sizeof(MEMORY_BLOCK_HEADER));
+       UnlinkBlock(ptr);
+       m_pfree(ptr);
+    }
+#else
+    m_pfree(pMem);
+#endif
+}
+
+void VMem::GetLock(void)
+{
+    EnterCriticalSection(&m_cs);
+}
+
+void VMem::FreeLock(void)
+{
+    LeaveCriticalSection(&m_cs);
+}
+
+int VMem::IsLocked(void)
+{
+#if 0
+    /* XXX TryEnterCriticalSection() is not available in some versions
+     * of Windows 95.  Since this code is not used anywhere yet, we 
+     * skirt the issue for now. */
+    BOOL bAccessed = TryEnterCriticalSection(&m_cs);
+    if(bAccessed) {
+       LeaveCriticalSection(&m_cs);
+    }
+    return !bAccessed;
+#else
+    ASSERT(0); /* alarm bells for when somebody calls this */
+    return 0;
+#endif
+}
+
+long VMem::Release(void)
+{
+    long lCount = InterlockedDecrement(&m_lRefCount);
+    if(!lCount)
+       delete this;
+    return lCount;
+}
+
+long VMem::AddRef(void)
+{
+    long lCount = InterlockedIncrement(&m_lRefCount);
+    return lCount;
+}
+
+#else  /* _USE_MSVCRT_MEM_ALLOC */
+
+/*
  * Knuth's boundary tag algorithm Vol #1, Page 440.
  *
  * Each block in the heap has tag words before and after it,
  * is freed, therefore space needs to be reserved for them.  Thus, the minimum
  * block size (not counting the tags) is 8 bytes.
  *
- * Since memory allocation may occur on a single threaded, explict locks are
+ * Since memory allocation may occur on a single threaded, explict locks are not
  * provided.
  * 
  */
 
-#ifndef ___VMEM_H_INC___
-#define ___VMEM_H_INC___
-
-const long lAllocStart = 0x00010000; /* start at 64K */
+const long lAllocStart = 0x00020000; /* start at 128K */
 const long minBlockSize = sizeof(void*)*2;
 const long sizeofTag = sizeof(long);
 const long blockOverhead = sizeofTag*2;
 const long minAllocSize = minBlockSize+blockOverhead;
+#ifdef _USE_BUDDY_BLOCKS
+const long lSmallBlockSize = 1024;
+const size_t nListEntries = ((lSmallBlockSize-minAllocSize)/sizeof(long));
+
+inline size_t CalcEntry(size_t size)
+{
+    ASSERT((size&(sizeof(long)-1)) == 0);
+    return ((size - minAllocSize) / sizeof(long));
+}
+#endif
 
 typedef BYTE* PBLOCK;  /* pointer to a memory block */
 
@@ -49,7 +291,7 @@ typedef BYTE* PBLOCK;        /* pointer to a memory block */
  */
 
 #define SIZE(block)    (*(ULONG*)(((PBLOCK)(block))-sizeofTag))
-#define PSIZE(block)   (*(ULONG*)(((PBLOCK)(block))-(sizeofTag*2)))
+#define PSIZE(block)   (*(ULONG*)(((PBLOCK)(block))-(blockOverhead)))
 inline void SetTags(PBLOCK block, long size)
 {
     SIZE(block) = size;
@@ -76,6 +318,7 @@ inline void Unlink(PBLOCK p)
     NEXT(prev) = next;
     PREV(next) = prev;
 }
+#ifndef _USE_BUDDY_BLOCKS
 inline void AddToFreeList(PBLOCK block, PBLOCK pInList)
 {
     PBLOCK next = NEXT(pInList);
@@ -83,7 +326,7 @@ inline void AddToFreeList(PBLOCK block, PBLOCK pInList)
     SetLink(block, pInList, next);
     PREV(next) = block;
 }
-
+#endif
 
 /* Macro for rounding up to the next sizeof(long) */
 #define ROUND_UP(n)    (((ULONG)(n)+sizeof(long)-1)&~(sizeof(long)-1))
@@ -96,16 +339,39 @@ inline void AddToFreeList(PBLOCK block, PBLOCK pInList)
  * Each record in this array contains information about a non-contiguous heap area.
  */
 
-const int maxHeaps = 64;
+const int maxHeaps = 32; /* 64 was overkill */
 const long lAllocMax   = 0x80000000; /* max size of allocation */
 
+#ifdef _USE_BUDDY_BLOCKS
+typedef struct _FreeListEntry
+{
+    BYTE    Dummy[minAllocSize];       // dummy free block
+} FREE_LIST_ENTRY, *PFREE_LIST_ENTRY;
+#endif
+
+#ifndef _USE_BUDDY_BLOCKS
+#define USE_BIGBLOCK_ALLOC
+#endif
+/*
+ * performance tuning
+ * Use VirtualAlloc() for blocks bigger than nMaxHeapAllocSize since
+ * Windows 95/98/Me have heap managers that are designed for memory 
+ * blocks smaller than four megabytes.
+ */
+
+#ifdef USE_BIGBLOCK_ALLOC
+const int nMaxHeapAllocSize = (1024*512);  /* don't allocate anything larger than this from the heap */
+#endif
+
 typedef struct _HeapRec
 {
     PBLOCK     base;   /* base of heap area */
     ULONG      len;    /* size of heap area */
+#ifdef USE_BIGBLOCK_ALLOC
+    BOOL       bBigBlock;  /* was allocate using VirtualAlloc */
+#endif
 } HeapRec;
 
-
 class VMem
 {
 public:
@@ -122,7 +388,11 @@ public:
 
     inline BOOL CreateOk(void)
     {
+#ifdef _USE_BUDDY_BLOCKS
+       return TRUE;
+#else
        return m_hHeap != NULL;
+#endif
     };
 
     void ReInit(void);
@@ -130,62 +400,79 @@ public:
 protected:
     void Init(void);
     int Getmem(size_t size);
-    int HeapAdd(void* ptr, size_t size);
+
+    int HeapAdd(void* ptr, size_t size
+#ifdef USE_BIGBLOCK_ALLOC
+       , BOOL bBigBlock
+#endif
+    );
+
     void* Expand(void* block, size_t size);
-    void WalkHeap(void);
 
+#ifdef _USE_BUDDY_BLOCKS
+    inline PBLOCK GetFreeListLink(int index)
+    {
+       if (index >= nListEntries)
+           index = nListEntries-1;
+       return &m_FreeList[index].Dummy[sizeofTag];
+    }
+    inline PBLOCK GetOverSizeFreeList(void)
+    {
+       return &m_FreeList[nListEntries-1].Dummy[sizeofTag];
+    }
+    inline PBLOCK GetEOLFreeList(void)
+    {
+       return &m_FreeList[nListEntries].Dummy[sizeofTag];
+    }
+
+    void AddToFreeList(PBLOCK block, size_t size)
+    {
+       PBLOCK pFreeList = GetFreeListLink(CalcEntry(size));
+       PBLOCK next = NEXT(pFreeList);
+       NEXT(pFreeList) = block;
+       SetLink(block, pFreeList, next);
+       PREV(next) = block;
+    }
+#endif
+    inline size_t CalcAllocSize(size_t size)
+    {
+       /*
+        * Adjust the real size of the block to be a multiple of sizeof(long), and add
+        * the overhead for the boundary tags.  Disallow negative or zero sizes.
+        */
+       return (size < minBlockSize) ? minAllocSize : (size_t)ROUND_UP(size) + blockOverhead;
+    }
+
+#ifdef _USE_BUDDY_BLOCKS
+    FREE_LIST_ENTRY    m_FreeList[nListEntries+1];     // free list with dummy end of list entry as well
+#else
     HANDLE             m_hHeap;                    // memory heap for this script
     char               m_FreeDummy[minAllocSize];  // dummy free block
     PBLOCK             m_pFreeList;                // pointer to first block on free list
+#endif
     PBLOCK             m_pRover;                   // roving pointer into the free list
     HeapRec            m_heaps[maxHeaps];          // list of all non-contiguous heap areas 
     int                        m_nHeaps;                   // no. of heaps in m_heaps 
     long               m_lAllocSize;               // current alloc size
     long               m_lRefCount;                // number of current users
     CRITICAL_SECTION   m_cs;                       // access lock
+
 #ifdef _DEBUG_MEM
+    void WalkHeap(int complete);
+    void MemoryUsageMessage(char *str, long x, long y, int c);
     FILE*              m_pLog;
 #endif
 };
 
-// #define _DEBUG_MEM
-#ifdef _DEBUG_MEM
-#define ASSERT(f) if(!(f)) DebugBreak();
-
-inline void MEMODS(char *str)
-{
-    OutputDebugString(str);
-    OutputDebugString("\n");
-}
-
-inline void MEMODSlx(char *str, long x)
-{
-    char szBuffer[512];        
-    sprintf(szBuffer, "%s %lx\n", str, x);
-    OutputDebugString(szBuffer);
-}
-
-#define WALKHEAP() WalkHeap()
-#define WALKHEAPTRACE() m_pRover = NULL; WalkHeap()
-
-#else
-
-#define ASSERT(f)
-#define MEMODS(x)
-#define MEMODSlx(x, y)
-#define WALKHEAP()
-#define WALKHEAPTRACE()
-
-#endif
-
-
 VMem::VMem()
 {
     m_lRefCount = 1;
+#ifndef _USE_BUDDY_BLOCKS
     BOOL bRet = (NULL != (m_hHeap = HeapCreate(HEAP_NO_SERIALIZE,
                                lAllocStart,    /* initial size of heap */
                                0)));           /* no upper limit on size of heap */
     ASSERT(bRet);
+#endif
 
     InitializeCriticalSection(&m_cs);
 #ifdef _DEBUG_MEM
@@ -197,32 +484,76 @@ VMem::VMem()
 
 VMem::~VMem(void)
 {
+#ifndef _USE_BUDDY_BLOCKS
     ASSERT(HeapValidate(m_hHeap, HEAP_NO_SERIALIZE, NULL));
-    WALKHEAPTRACE();
-#ifdef _DEBUG_MEM
-    MemoryUsageMessage(NULL, 0, 0, 0);
 #endif
+    WALKHEAPTRACE();
+
     DeleteCriticalSection(&m_cs);
+#ifdef _USE_BUDDY_BLOCKS
+    for(int index = 0; index < m_nHeaps; ++index) {
+       VirtualFree(m_heaps[index].base, 0, MEM_RELEASE);
+    }
+#else /* !_USE_BUDDY_BLOCKS */
+#ifdef USE_BIGBLOCK_ALLOC
+    for(int index = 0; index < m_nHeaps; ++index) {
+       if (m_heaps[index].bBigBlock) {
+           VirtualFree(m_heaps[index].base, 0, MEM_RELEASE);
+       }
+    }
+#endif
     BOOL bRet = HeapDestroy(m_hHeap);
     ASSERT(bRet);
+#endif /* _USE_BUDDY_BLOCKS */
 }
 
 void VMem::ReInit(void)
 {
-    for(int index = 0; index < m_nHeaps; ++index)
-       HeapFree(m_hHeap, HEAP_NO_SERIALIZE, m_heaps[index].base);
+    for(int index = 0; index < m_nHeaps; ++index) {
+#ifdef _USE_BUDDY_BLOCKS
+       VirtualFree(m_heaps[index].base, 0, MEM_RELEASE);
+#else
+#ifdef USE_BIGBLOCK_ALLOC
+       if (m_heaps[index].bBigBlock) {
+           VirtualFree(m_heaps[index].base, 0, MEM_RELEASE);
+       }
+       else
+#endif
+           HeapFree(m_hHeap, HEAP_NO_SERIALIZE, m_heaps[index].base);
+#endif /* _USE_BUDDY_BLOCKS */
+    }
 
     Init();
 }
 
 void VMem::Init(void)
-{   /*
+{
+#ifdef _USE_BUDDY_BLOCKS
+    PBLOCK pFreeList;
+    /*
+     * Initialize the free list by placing a dummy zero-length block on it.
+     * Set the end of list marker.
+     * Set the number of non-contiguous heaps to zero.
+     * Set the next allocation size.
+     */
+    for (int index = 0; index < nListEntries; ++index) {
+       pFreeList = GetFreeListLink(index);
+       SIZE(pFreeList) = PSIZE(pFreeList+minAllocSize) = 0;
+       PREV(pFreeList) = NEXT(pFreeList) = pFreeList;
+    }
+    pFreeList = GetEOLFreeList();
+    SIZE(pFreeList) = PSIZE(pFreeList+minAllocSize) = 0;
+    PREV(pFreeList) = NEXT(pFreeList) = NULL;
+    m_pRover = GetOverSizeFreeList();
+#else
+    /*
      * Initialize the free list by placing a dummy zero-length block on it.
      * Set the number of non-contiguous heaps to zero.
      */
-    m_pFreeList = m_pRover = (PBLOCK)(&m_FreeDummy[minBlockSize]);
-    PSIZE(m_pFreeList) = SIZE(m_pFreeList) = 0;
+    m_pFreeList = m_pRover = (PBLOCK)(&m_FreeDummy[sizeofTag]);
+    PSIZE(m_pFreeList+minAllocSize) = SIZE(m_pFreeList) = 0;
     PREV(m_pFreeList) = NEXT(m_pFreeList) = m_pFreeList;
+#endif
 
     m_nHeaps = 0;
     m_lAllocSize = lAllocStart;
@@ -232,27 +563,111 @@ void* VMem::Malloc(size_t size)
 {
     WALKHEAP();
 
+    PBLOCK ptr;
+    size_t lsize, rem;
     /*
-     * Adjust the real size of the block to be a multiple of sizeof(long), and add
-     * the overhead for the boundary tags.  Disallow negative or zero sizes.
+     * Disallow negative or zero sizes.
      */
-    size_t realsize = (size < blockOverhead) ? minAllocSize : (size_t)ROUND_UP(size) + minBlockSize;
+    size_t realsize = CalcAllocSize(size);
     if((int)realsize < minAllocSize || size == 0)
        return NULL;
 
+#ifdef _USE_BUDDY_BLOCKS
+    /*
+     * Check the free list of small blocks if this is free use it
+     * Otherwise check the rover if it has no blocks then
+     * Scan the free list entries use the first free block
+     * split the block if needed, stop at end of list marker
+     */
+    {
+       int index = CalcEntry(realsize);
+       if (index < nListEntries-1) {
+           ptr = GetFreeListLink(index);
+           lsize = SIZE(ptr);
+           if (lsize >= realsize) {
+               rem = lsize - realsize;
+               if(rem < minAllocSize) {
+                   /* Unlink the block from the free list. */
+                   Unlink(ptr);
+               }
+               else {
+                   /*
+                    * split the block
+                    * The remainder is big enough to split off into a new block.
+                    * Use the end of the block, resize the beginning of the block
+                    * no need to change the free list.
+                    */
+                   SetTags(ptr, rem);
+                   ptr += SIZE(ptr);
+                   lsize = realsize;
+               }
+               SetTags(ptr, lsize | 1);
+               return ptr;
+           }
+           ptr = m_pRover;
+           lsize = SIZE(ptr);
+           if (lsize >= realsize) {
+               rem = lsize - realsize;
+               if(rem < minAllocSize) {
+                   /* Unlink the block from the free list. */
+                   Unlink(ptr);
+               }
+               else {
+                   /*
+                    * split the block
+                    * The remainder is big enough to split off into a new block.
+                    * Use the end of the block, resize the beginning of the block
+                    * no need to change the free list.
+                    */
+                   SetTags(ptr, rem);
+                   ptr += SIZE(ptr);
+                   lsize = realsize;
+               }
+               SetTags(ptr, lsize | 1);
+               return ptr;
+           }
+           ptr = GetFreeListLink(index+1);
+           while (NEXT(ptr)) {
+               lsize = SIZE(ptr);
+               if (lsize >= realsize) {
+                   size_t rem = lsize - realsize;
+                   if(rem < minAllocSize) {
+                       /* Unlink the block from the free list. */
+                       Unlink(ptr);
+                   }
+                   else {
+                       /*
+                        * split the block
+                        * The remainder is big enough to split off into a new block.
+                        * Use the end of the block, resize the beginning of the block
+                        * no need to change the free list.
+                        */
+                       SetTags(ptr, rem);
+                       ptr += SIZE(ptr);
+                       lsize = realsize;
+                   }
+                   SetTags(ptr, lsize | 1);
+                   return ptr;
+               }
+               ptr += sizeof(FREE_LIST_ENTRY);
+           }
+       }
+    }
+#endif
+
     /*
      * Start searching the free list at the rover.  If we arrive back at rover without
      * finding anything, allocate some memory from the heap and try again.
      */
-    PBLOCK ptr = m_pRover;     /* start searching at rover */
-    int loops = 2;             /* allow two times through the loop  */
+    ptr = m_pRover;    /* start searching at rover */
+    int loops = 2;     /* allow two times through the loop  */
     for(;;) {
-       size_t lsize = SIZE(ptr);
+       lsize = SIZE(ptr);
        ASSERT((lsize&1)==0);
        /* is block big enough? */
        if(lsize >= realsize) { 
            /* if the remainder is too small, don't bother splitting the block. */
-           size_t rem = lsize - realsize;
+           rem = lsize - realsize;
            if(rem < minAllocSize) {
                if(m_pRover == ptr)
                    m_pRover = NEXT(ptr);
@@ -311,11 +726,7 @@ void* VMem::Realloc(void* block, size_t size)
     if(Expand(block, size) != NULL)
        return block;
 
-    /*
-     * adjust the real size of the block to be a multiple of sizeof(long), and add the
-     * overhead for the boundary tags.  Disallow negative or zero sizes.
-     */
-    size_t realsize = (size < blockOverhead) ? minAllocSize : (size_t)ROUND_UP(size) + minBlockSize;
+    size_t realsize = CalcAllocSize(size);
     if((int)realsize < minAllocSize)
        return NULL;
 
@@ -351,7 +762,11 @@ void* VMem::Realloc(void* block, size_t size)
             * next block cannot be free
             */
            SetTags(prev, rem);
+#ifdef _USE_BUDDY_BLOCKS
+           AddToFreeList(prev, rem);
+#else
            AddToFreeList(prev, m_pFreeList);
+#endif
            cursize = realsize;
         }
        /* Set the boundary tags to mark it as allocated. */
@@ -361,7 +776,7 @@ void* VMem::Realloc(void* block, size_t size)
 
     /* Allocate a new block, copy the old to the new, and free the old. */
     if((ptr = (PBLOCK)Malloc(size)) != NULL) {
-       memmove(ptr, block, cursize-minBlockSize);
+       memmove(ptr, block, cursize-blockOverhead);
        Free(block);
     }
     return ((void *)ptr);
@@ -386,12 +801,18 @@ void VMem::Free(void* p)
     size &= ~1;        /* remove allocated tag */
 
     /* if previous block is free, add this block to it. */
+#ifndef _USE_BUDDY_BLOCKS
     int linked = FALSE;
+#endif
     size_t psize = PSIZE(ptr);
     if((psize&1) == 0) {
        ptr -= psize;   /* point to previous block */
        size += psize;  /* merge the sizes of the two blocks */
+#ifdef _USE_BUDDY_BLOCKS
+       Unlink(ptr);
+#else
        linked = TRUE;  /* it's already on the free list */
+#endif
     }
 
     /* if the next physical block is free, merge it with this block. */
@@ -413,9 +834,13 @@ void VMem::Free(void* p)
     SetTags(ptr, size);
 
     /* Link the block to the head of the free list. */
+#ifdef _USE_BUDDY_BLOCKS
+       AddToFreeList(ptr, size);
+#else
     if(!linked) {
        AddToFreeList(ptr, m_pFreeList);
     }
+#endif
 }
 
 void VMem::GetLock(void)
@@ -463,11 +888,14 @@ long VMem::AddRef(void)
 
 int VMem::Getmem(size_t requestSize)
 {   /* returns -1 is successful 0 if not */
+#ifdef USE_BIGBLOCK_ALLOC
+    BOOL bBigBlock;
+#endif
     void *ptr;
 
     /* Round up size to next multiple of 64K. */
     size_t size = (size_t)ROUND_UP64K(requestSize);
-    
+
     /*
      * if the size requested is smaller than our current allocation size
      * adjust up
@@ -477,18 +905,28 @@ int VMem::Getmem(size_t requestSize)
 
     /* Update the size to allocate on the next request */
     if(m_lAllocSize != lAllocMax)
-       m_lAllocSize <<= 1;
+       m_lAllocSize <<= 2;
 
-    if(m_nHeaps != 0) {
+#ifndef _USE_BUDDY_BLOCKS
+    if(m_nHeaps != 0
+#ifdef USE_BIGBLOCK_ALLOC
+       && !m_heaps[m_nHeaps-1].bBigBlock
+#endif
+                   ) {
        /* Expand the last allocated heap */
-       ptr = HeapReAlloc(m_hHeap, HEAP_REALLOC_IN_PLACE_ONLY|HEAP_ZERO_MEMORY|HEAP_NO_SERIALIZE,
+       ptr = HeapReAlloc(m_hHeap, HEAP_REALLOC_IN_PLACE_ONLY|HEAP_NO_SERIALIZE,
                m_heaps[m_nHeaps-1].base,
                m_heaps[m_nHeaps-1].len + size);
        if(ptr != 0) {
-           HeapAdd(((char*)ptr) + m_heaps[m_nHeaps-1].len, size);
+           HeapAdd(((char*)ptr) + m_heaps[m_nHeaps-1].len, size
+#ifdef USE_BIGBLOCK_ALLOC
+               , FALSE
+#endif
+               );
            return -1;
        }
     }
+#endif /* _USE_BUDDY_BLOCKS */
 
     /*
      * if we didn't expand a block to cover the requested size
@@ -497,19 +935,59 @@ int VMem::Getmem(size_t requestSize)
      * the above ROUND_UP64K may not have added any memory to include this.
      */
     if(size == requestSize)
-       size = (size_t)ROUND_UP64K(requestSize+(sizeofTag*2));
+       size = (size_t)ROUND_UP64K(requestSize+(blockOverhead));
+
+Restart:
+#ifdef _USE_BUDDY_BLOCKS
+    ptr = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
+#else
+#ifdef USE_BIGBLOCK_ALLOC
+    bBigBlock = FALSE;
+    if (size >= nMaxHeapAllocSize) {
+       bBigBlock = TRUE;
+       ptr = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
+    }
+    else
+#endif
+    ptr = HeapAlloc(m_hHeap, HEAP_NO_SERIALIZE, size);
+#endif /* _USE_BUDDY_BLOCKS */
+
+    if (!ptr) {
+       /* try to allocate a smaller chunk */
+       size >>= 1;
+       if(size > requestSize)
+           goto Restart;
+    }
 
-    ptr = HeapAlloc(m_hHeap, HEAP_ZERO_MEMORY|HEAP_NO_SERIALIZE, size);
     if(ptr == 0) {
        MEMODSlx("HeapAlloc failed on size!!!", size);
        return 0;
     }
 
+#ifdef _USE_BUDDY_BLOCKS
+    if (HeapAdd(ptr, size)) {
+       VirtualFree(ptr, 0, MEM_RELEASE);
+       return 0;
+    }
+#else
+#ifdef USE_BIGBLOCK_ALLOC
+    if (HeapAdd(ptr, size, bBigBlock)) {
+       if (bBigBlock) {
+           VirtualFree(ptr, 0, MEM_RELEASE);
+       }
+    }
+#else
     HeapAdd(ptr, size);
+#endif
+#endif /* _USE_BUDDY_BLOCKS */
     return -1;
 }
 
-int VMem::HeapAdd(void *p, size_t size)
+int VMem::HeapAdd(void* p, size_t size
+#ifdef USE_BIGBLOCK_ALLOC
+    , BOOL bBigBlock
+#endif
+    )
 {   /* if the block can be succesfully added to the heap, returns 0; otherwise -1. */
     int index;
 
@@ -520,37 +998,49 @@ int VMem::HeapAdd(void *p, size_t size)
     size = (size_t)ROUND_DOWN(size);
     PBLOCK ptr = (PBLOCK)p;
 
-    /*
-     * Search for another heap area that's contiguous with the bottom of this new area.
-     * (It should be extremely unusual to find one that's contiguous with the top).
-     */
-    for(index = 0; index < m_nHeaps; ++index) {
-       if(ptr == m_heaps[index].base + (int)m_heaps[index].len) {
-           /*
-            * The new block is contiguous with a previously allocated heap area.  Add its
-            * length to that of the previous heap.  Merge it with the the dummy end-of-heap
-            * area marker of the previous heap.
-            */
-           m_heaps[index].len += size;
-           break;
+#ifdef USE_BIGBLOCK_ALLOC
+    if (!bBigBlock) {
+#endif
+       /*
+        * Search for another heap area that's contiguous with the bottom of this new area.
+        * (It should be extremely unusual to find one that's contiguous with the top).
+        */
+       for(index = 0; index < m_nHeaps; ++index) {
+           if(ptr == m_heaps[index].base + (int)m_heaps[index].len) {
+               /*
+                * The new block is contiguous with a previously allocated heap area.  Add its
+                * length to that of the previous heap.  Merge it with the the dummy end-of-heap
+                * area marker of the previous heap.
+                */
+               m_heaps[index].len += size;
+               break;
+           }
        }
+#ifdef USE_BIGBLOCK_ALLOC
+    }
+    else {
+       index = m_nHeaps;
     }
+#endif
 
     if(index == m_nHeaps) {
-       /* The new block is not contiguous.  Add it to the heap list. */
+       /* The new block is not contiguous, or is BigBlock.  Add it to the heap list. */
        if(m_nHeaps == maxHeaps) {
            return -1;  /* too many non-contiguous heaps */
        }
        m_heaps[m_nHeaps].base = ptr;
        m_heaps[m_nHeaps].len = size;
+#ifdef USE_BIGBLOCK_ALLOC
+       m_heaps[m_nHeaps].bBigBlock = bBigBlock;
+#endif
        m_nHeaps++;
 
        /*
         * Reserve the first LONG in the block for the ending boundary tag of a dummy
         * block at the start of the heap area.
         */
-       size -= minBlockSize;
-       ptr += minBlockSize;
+       size -= blockOverhead;
+       ptr += blockOverhead;
        PSIZE(ptr) = 1; /* mark the dummy previous block as allocated */
     }
 
@@ -575,10 +1065,9 @@ int VMem::HeapAdd(void *p, size_t size)
 void* VMem::Expand(void* block, size_t size)
 {
     /*
-     * Adjust the size of the block to be a multiple of sizeof(long), and add the
-     * overhead for the boundary tags.  Disallow negative or zero sizes.
+     * Disallow negative or zero sizes.
      */
-    size_t realsize = (size < blockOverhead) ? minAllocSize : (size_t)ROUND_UP(size) + minBlockSize;
+    size_t realsize = CalcAllocSize(size);
     if((int)realsize < minAllocSize || size == 0)
        return NULL;
 
@@ -640,7 +1129,11 @@ void* VMem::Expand(void* block, size_t size)
             * next block cannot be free
             */
            SetTags(next, rem);
+#ifdef _USE_BUDDY_BLOCKS
+           AddToFreeList(next, rem);
+#else
            AddToFreeList(next, m_pFreeList);
+#endif
            cursize = realsize;
         }
        /* Set the boundary tags to mark it as allocated. */
@@ -653,7 +1146,7 @@ void* VMem::Expand(void* block, size_t size)
 #ifdef _DEBUG_MEM
 #define LOG_FILENAME ".\\MemLog.txt"
 
-void MemoryUsageMessage(char *str, long x, long y, int c)
+void VMem::MemoryUsageMessage(char *str, long x, long y, int c)
 {
     char szBuffer[512];
     if(str) {
@@ -663,58 +1156,68 @@ void MemoryUsageMessage(char *str, long x, long y, int c)
        fputs(szBuffer, m_pLog);
     }
     else {
-       fflush(m_pLog);
-       fclose(m_pLog);
-       m_pLog = 0;
+       if(m_pLog) {
+           fflush(m_pLog);
+           fclose(m_pLog);
+           m_pLog = 0;
+       }
     }
 }
 
-void VMem::WalkHeap(void)
+void VMem::WalkHeap(int complete)
 {
-    if(!m_pRover) {
-       MemoryUsageMessage("VMem heaps used %d\n", m_nHeaps, 0, 0);
-    }
+    if(complete) {
+       MemoryUsageMessage(NULL, 0, 0, 0);
+       size_t total = 0;
+       for(int i = 0; i < m_nHeaps; ++i) {
+           total += m_heaps[i].len;
+       }
+       MemoryUsageMessage("VMem heaps used %d. Total memory %08x\n", m_nHeaps, total, 0);
+
+       /* Walk all the heaps - verify structures */
+       for(int index = 0; index < m_nHeaps; ++index) {
+           PBLOCK ptr = m_heaps[index].base;
+           size_t size = m_heaps[index].len;
+#ifndef _USE_BUDDY_BLOCKS
+#ifdef USE_BIGBLOCK_ALLOC
+           if (!m_heaps[m_nHeaps].bBigBlock)
+#endif
+               ASSERT(HeapValidate(m_hHeap, HEAP_NO_SERIALIZE, ptr));
+#endif
 
-    /* Walk all the heaps - verify structures */
-    for(int index = 0; index < m_nHeaps; ++index) {
-       PBLOCK ptr = m_heaps[index].base;
-       size_t size = m_heaps[index].len;
-       ASSERT(HeapValidate(m_hHeap, HEAP_NO_SERIALIZE, p));
-
-       /* set over reserved header block */
-       size -= minBlockSize;
-       ptr += minBlockSize;
-       PBLOCK pLast = ptr + size;
-       ASSERT(PSIZE(ptr) == 1); /* dummy previous block is allocated */
-       ASSERT(SIZE(pLast) == 1); /* dummy next block is allocated */
-       while(ptr < pLast) {
-           ASSERT(ptr > m_heaps[index].base);
-           size_t cursize = SIZE(ptr) & ~1;
-           ASSERT((PSIZE(ptr+cursize) & ~1) == cursize);
-           if(!m_pRover) {
-               MemoryUsageMessage("Memory Block %08x: Size %08x %c\n", (long)ptr, cursize, (SIZE(p)&1) ? 'x' : ' ');
-           }
-           if(!(SIZE(ptr)&1)) {
-               /* this block is on the free list */
-               PBLOCK tmp = NEXT(ptr);
-               while(tmp != ptr) {
-                   ASSERT((SIZE(tmp)&1)==0);
-                   if(tmp == m_pFreeList)
-                       break;
-                   ASSERT(NEXT(tmp));
-                   tmp = NEXT(tmp);
-               }
-               if(tmp == ptr) {
-                   MemoryUsageMessage("Memory Block %08x: Size %08x free but not in free list\n", (long)ptr, cursize, 0);
+           /* set over reserved header block */
+           size -= blockOverhead;
+           ptr += blockOverhead;
+           PBLOCK pLast = ptr + size;
+           ASSERT(PSIZE(ptr) == 1); /* dummy previous block is allocated */
+           ASSERT(SIZE(pLast) == 1); /* dummy next block is allocated */
+           while(ptr < pLast) {
+               ASSERT(ptr > m_heaps[index].base);
+               size_t cursize = SIZE(ptr) & ~1;
+               ASSERT((PSIZE(ptr+cursize) & ~1) == cursize);
+               MemoryUsageMessage("Memory Block %08x: Size %08x %c\n", (long)ptr, cursize, (SIZE(ptr)&1) ? 'x' : ' ');
+               if(!(SIZE(ptr)&1)) {
+                   /* this block is on the free list */
+                   PBLOCK tmp = NEXT(ptr);
+                   while(tmp != ptr) {
+                       ASSERT((SIZE(tmp)&1)==0);
+                       if(tmp == m_pFreeList)
+                           break;
+                       ASSERT(NEXT(tmp));
+                       tmp = NEXT(tmp);
+                   }
+                   if(tmp == ptr) {
+                       MemoryUsageMessage("Memory Block %08x: Size %08x free but not in free list\n", (long)ptr, cursize, 0);
+                   }
                }
+               ptr += cursize;
            }
-           ptr += cursize;
        }
-    }
-    if(!m_pRover) {
        MemoryUsageMessage(NULL, 0, 0, 0);
     }
 }
-#endif
+#endif /* _DEBUG_MEM */
+
+#endif /* _USE_MSVCRT_MEM_ALLOC */
 
 #endif /* ___VMEM_H_INC___ */