🚀 go-pugleaf

This is what we developed. It's crude and not designed to be fast but
it helps us avoid the scenario I described. BTW I'll reiterate that I
don't know if the HM is at fault or not - it's just my theory :)

// .h
/*
  Use this class when you are likely to be reallocating lots of memory
blocks.
  This class will reduce calls to the Heap Manager by recycling old
memory blocks.

  It is not a directly performance related class. The idea is to avoid
heap
    fragmentation and thus hopefully avoid runaway memory consumption.
*/

struct TCachedItem
{
  bool          InUseF;
  TCachedItem * Next;
  void *        Data;
  DWORD         Size;

  TCachedItem()
  {
    Next=NULL;
    Data=NULL;
    InUseF=false;
  }

  ~TCachedItem()
  {
    KillAry( Data );
    KillObj( Next );
  }
};

const int MAX_CACHED_ALLOC = 1024*1024;
const int MAX_CACHED_ITEMS = 128;

class TOCachedAllocator
{
    TCachedItem MyCachedItems;
    DWORD       MyTotalSize;
    WORD        MyTotalItems;

    template<typename ObjectType> ObjectType * fixupMemoryBlock(
ObjectType * Data,
                                                                 DWORD
Size,
                                                                 bool
InitF )
    {
      if( InitF )
        memset( Data, 0, Size );

      return Data;
    }
  public:
    TOCachedAllocator();

    // Allocate/recycle new memory block.
#pragma warn -inl
    template<typename ObjectType> ObjectType * Get( ObjectType *&
Pointer,
                                                    int           Count,
                                                    bool
InitF=true )
    {
      DWORD reqSize=Count;
      reqSize*=sizeof( *Pointer );

      // First look for a free block of that size
      TCachedItem * itemPtr=MyCachedItems.Next;

      while( itemPtr&&
             ( itemPtr->InUseF||
               itemPtr->Size!=reqSize ) )
        GoNext( itemPtr );

      if( itemPtr )
      {
        itemPtr->InUseF=true;
        return Pointer=fixupMemoryBlock( reinterpret_cast<ObjectType
*>( itemPtr->Data ),
                                 reqSize,
                                 InitF );
      }

      // Consider allocating a new block
      if( ( reqSize+MyTotalSize>MAX_CACHED_ALLOC )||
          ( MyTotalItems==MAX_CACHED_ITEMS ) )
        return Pointer=fixupMemoryBlock( new ObjectType[ Count ],
                                 reqSize,
                                 InitF );

      MyTotalSize+=reqSize;
      ++MyTotalItems;

      itemPtr=new TCachedItem();
      itemPtr->InUseF=true;
      itemPtr->Size=reqSize;
      itemPtr->Data=new ObjectType[ Count ];
      itemPtr->Next=MyCachedItems.Next;
      MyCachedItems.Next=itemPtr;

      return Pointer=fixupMemoryBlock( reinterpret_cast<ObjectType *>(
itemPtr->Data ),
                               itemPtr->Size,
                               InitF );
    }

    // Deallocate/return object
    template<typename ObjectType> void Release( ObjectType *& Pointer )
    {
      // Look for this block in our list
      TCachedItem * itemPtr=MyCachedItems.Next;

      while( itemPtr&&
             ( itemPtr->Data!=Pointer ) )
        GoNext( itemPtr );

      if( !itemPtr )
      { // Not ours
        delete[] Pointer;
      }
      else
      { // Ours - mark it as unused
        itemPtr->InUseF=false;
      }
    }
#pragma warn .inl
};

extern TOCachedAllocator CachedAllocator;

#endif

// .cpp
TOCachedAllocator
  ::TOCachedAllocator()
{
  MyTotalSize=MyTotalItems=0;
}

TOCachedAllocator CachedAllocator;

It's quite old and could probably benefit from the STL. std::set for
the list of blocks would probably be a good start :)
-- 
Andrue Cope [TeamB]
[Bicester, Uk]
http://info.borland.com/newsgroups/guide.html