|
|
/**********************************************************************//** Microsoft Windows/NT **//** Copyright(c) Microsoft Corp., 1991 **//**********************************************************************/
/*
heap.hxx Expandable protected-mode heap classes: definition.
These classes provide global "new" and "delete" operators which use the Windows LocalInit, et al., routines to manage as large a heap as is allocatable from GlobalAlloc.
The class objects themselves are allocated from the local heap through LocalAlloc and LocalFree.
FILE HISTORY: DavidHov 2-25-91 Created from CDD. Johnl 5-02-91 Added overloaded new prototype KeithMo 23-Oct-1991 Added forward references. beng 24-Dec-1991 Removed one-shot heaps to heapones.hxx
*/
#if !defined(_HEAP_HXX_)
// In-line "operator new" that takes a pointer (placement syntax).
inline void * CDECL operator new ( size_t cb, void * p ){ (void) cb; return p;}
#define _HEAP_HXX_
// Only really expand this file if !Win32
#if !defined(WIN32)
#include "base.hxx"
#include "uiassert.hxx"
#include "uibuffer.hxx"
#ifndef _SIZE_T_DEFINED
#include <stddef.h>
#endif
//
// Forward references.
//
DLL_CLASS LOCAL_HEAP_OBJ;DLL_CLASS BASE_HEAP;DLL_CLASS SUB_HEAP;DLL_CLASS GIANT_HEAP;DLL_CLASS MEM_MASTER;
/*************************************************************************
NAME: LOCL_HEAP_OBJ
SYNOPSIS: An abstract class used to derive objects which will be allocated on the local (DS-based) heap.
INTERFACE: operator new() - new operator operator delete() - dleete operator QueryBlockSize() - return heap size
PARENT: BASE
NOTE: This class won't presently work from a DLL.
HISTORY: DavidHov 2-25-91 Created
**************************************************************************/
DLL_CLASS LOCAL_HEAP_OBJ : public BASE{public: VOID * operator new ( size_t cb ); VOID operator delete ( VOID * pbBlock ); USHORT QueryBlockSize ( VOID * pbBlock );
private: static long _cLocalFreeErrors;};
/*************************************************************************
NAME: BASE_HEAP
SYNOPSIS: An abstract class used to derive heap objects.
INTERFACE: BASE_HEAP() - constructor ~BASE_HEAP - destructor Alloc() - allocation Free() - Free.
PARENT: LOCAL_HEAP_OBJ, BUFFER
NOTE: This class won't presently work from a DLL.
HISTORY: DavidHov 2-25-91 Created
**************************************************************************/
DLL_CLASS BASE_HEAP : public LOCAL_HEAP_OBJ, public BUFFER{public: USHORT QuerySel() { return HIWORD( QueryPtr() ); } BASE_HEAP(); // Allocates the smallest possible buffer
BASE_HEAP( USHORT cbInitialAllocSize );
~BASE_HEAP();
virtual BYTE * Alloc ( USHORT cbBytes, USHORT fsFlags = 0 ) = 0; virtual BOOL Free ( BYTE * pbBlock ) = 0;};
/*************************************************************************
NAME: SUB_HEAP
SYNOPSIS: A single extension of a GIANT_HEAP, capable of allocating at most 64K of smaller items.
INTERFACE: Indirect. Correct usage is only through MEM_MASTER and GIANT_HEAP.
QueryOwner() - return the owner heap pointer. Alloc() - allocation Free() - free the memory CalcDeallocErrors() - return the count of deallocation errors
PARENT: BASE_HEAP
CAVEATS: This class and its subclasses, GIANT_HEAP and MEM_MASTER, use the SUB_HEAP operators "new" and "delete" to allocate their instances in the local heap through LocalAlloc and Local Free.
NOTES: Again, usage is indirect. Intended use is only through the global replacement "new" and "delete" operators. In other words, if you link HEAPBIG.CXX into your program, you only have to call MEM_MASTER::Init or InitForDll.
All SUB_HEAPs instances and the instances of its subclasses are linked onto a single circularly linked list maintained automatically by SUB_HEAP's constructors and destructors.
This class won't presently work from a DLL.
HISTORY: DavidHov 2-25-91 Created
**************************************************************************/
DLL_CLASS SUB_HEAP: public BASE_HEAP{friend class GIANT_HEAP;friend class MEM_MASTER;
protected: SUB_HEAP * _pFwd, * _pBack; enum SHtype { SHt_Invalid, SHt_DS, SHt_Normal } _type;
USHORT _cbLargestFailed; // Size of largest failed allocation
USHORT _cBlksOut; // Count of blocks outstanding
ULONG _lcDeallocErrors; // Deallocation errors
inline USHORT QuerySel () // Return selector of buffer
{ return HIWORD( QueryPtr() ); }
GIANT_HEAP * _pOwner; // Pointer to owning GIANT_HEAP
// Can only be constructed by MEM_MASTER,
// or as part of a GIANT_HEAP
//
SUB_HEAP(); // used by MEM_MASTER; SHt_DS
SUB_HEAP( USHORT cbInitialAllocSize ); // Normal constructor: SHt_Normal
~SUB_HEAP();
VOID Init(); // Initialze private data
VOID Link(); // Link onto circular list
VOID Unlink(); // Remove from circular list
USHORT QueryBlockSize( BYTE * pbBlock ); // Return size of allocated block
BOOL Walk () ; // Walk the heap-- Debugging.
public:
static MEM_MASTER * _pmmInstance; // Pointer to single instance
// of MEM_MASTER
// Returns pointer to owning GIANT_HEAP (which may be itself)
// or NULL, implying that it's the DS heap (default GIANT_HEAP)
virtual GIANT_HEAP * QueryOwner( );
virtual BYTE * Alloc( USHORT cbBytes, USHORT fsFlags = 0 ); virtual BOOL Free( BYTE * pbBlock );
virtual ULONG CalcDeallocErrors();};
/*************************************************************************
NAME: GIANT_HEAP
SYNOPSIS: Logically, a GIANT_HEAP is one or more SUB_HEAPs. Since there must be at least one SUB_HEAP, GIANT_HEAP inherits from SUB_HEAP. The distinction lies in the "_pOwner" variable, which points to itself for GIANT_HEAPs.
INTERFACE: Normally indirect. Typical usage is only through MEM_MASTER, since most programs will only ever have one GIANT_HEAP. Additional GIANT_HEAPs can be allocated to create "boundaries" to distinguish large-scale areas of memory allocation. Reference MEM_MASTER's "focus" routines for more information. GIANT_HEAP() - constructor ~GIANT_HEAP() - destructor SetBehavior() - set allocation behavior SetDeleteOnEmpty() - set delete on empty SetExtendOnFull() - set extend on full SetResizeOnEmpty() - set resize on empty QueryExpandErrors() - number of failed expansion attempts Alloc() - allocation Free() - free CalcDeallocErrors() - number of deallocation errors QueryTotalBlocks() - total blocks
PARENT: SUB_HEAP
NOTES: Normal usage is indirect. Intended use is through the global replacement "new" and "delete" operators. In other words, if you link HEAPBIG.CXX into your program, you only have to call MEM_MASTER Init. See SUB_HEAP, NOTES.
This class won't presently work from a DLL.
CAVEATS: See SUB_HEAP, CAVEATS.
HISTORY: DavidHov 2-25-91 Created
**************************************************************************/
#define GHbExtend (1<<0)
#define GHbDelete (1<<1)
#define GHbResize (1<<2)
DLL_CLASS GIANT_HEAP : public SUB_HEAP{friend class MEM_MASTER;protected: // Default initial allocation for all subsequent SUB_HEAPs
USHORT _cbInitAlloc;
// Count number of times a new SUB_HEAP could not be created
ULONG _cExpandErrors;
// Allocation behavior control word
USHORT _fsBehave;
// Add a new SUB_HEAP and allocate from it.
virtual BYTE * GrowAndAlloc( USHORT cbBytes, USHORT fsFlags = 0 );
// parameterless initialization used by MEM_MASTER
GIANT_HEAP();
public: // Public constructor for additional GIANT_HEAPs
GIANT_HEAP( USHORT cbInitialAllocation ); ~GIANT_HEAP();
BOOL SetBehavior( USHORT fFlag, BOOL fOnOff );
BOOL SetDeleteOnEmpty ( BOOL fDelete ) { return SetBehavior( GHbDelete, fDelete ); } BOOL SetExtendOnFull ( BOOL fExtend ) { return SetBehavior( GHbExtend, fExtend ); } BOOL SetResizeOnEmpty ( BOOL fResize ) { return SetBehavior( GHbResize, fResize ); }
ULONG QueryExpandErrors() { return _cExpandErrors ; }
// Return a pointer to the newest SUB_HEAP in the ensemble.
SUB_HEAP * QueryLatest();
virtual BYTE * Alloc( USHORT cbBytes, USHORT fsFlags = 0 ); virtual BOOL Free( BYTE * pbBlock ); virtual ULONG CalcDeallocErrors(); virtual ULONG QueryTotalBlocks();};
/*************************************************************************
NAME: MEM_MASTER
SYNOPSIS: MEM_MASTER serves primarily as the anchor for the linked list of SUB_HEAPS and the locus of the global "new" and "delete" operators. It also maintains a pointer to the current "focussed" GIANT_HEAP.
As explained in HEAPBIG.CXX, before instantiation, the global "new" and "delete" operators simply use LocalAlloc and LocalFree. After instantiation of MEM_MASTER (via "Init"), MEM_MASTER is created as a GIANT_HEAP which covers the local, DS-relative heap. Instantiation also creates the first instance of a GIANT_HEAP, which implies that the first SUB_HEAP is also created.
The effect is two-fold. First, a GIANT_HEAP is ready for use, and allocates memory obtained through GlobalAlloc. Second, the MEM_MASTER is still available as a GIANT_HEAP in case the uses wishes to temporarily allocate from the local heap.
MEM_MASTER is the first instance both of a SUB_HEAP and a GIANT_HEAP. It can be distinguished from other HEAPs because:
1) it's a GIANT_HEAP, since _pOwner == this (self), and 2) this (self) == _pmmInstance, it's the one and only MEM_MASTER.
INTERFACE: Call MEM_MASTER::Init(). This creates the sole, global instance of a MEM_MASTER, _pmmInstance. After Init(), all "new" and "delete" operations will automatically flow through _pmmInstance.
Init() - initialize InitForDll() - initialize for DLL Term() - terminate Alloc() - allocate Free() - free QueryBlockSize() - size of the block SetFocus() - refocus on the subheap GetGiantFocus() - get giant focus QueryTotalHeaps() - Total heaps QueryTotalBlocks() - total blocks
PARENT: GIANT_HEAP
USES: SUB_HEAP
CAVEATS: See SUB_HEAP, CAVEATS.
Warning about InitForDll: Under Windows, memory allocated by a DLL is always "owned" by the active task which invoked the DLL. The InitForDll method is primarily intended for LANMAN.DRV, which is loaded by the Window's shell and not unloaded until Windows is terminated. Calling InitForDll preallocates several heaps and prevents further expansion. Thus, all the memory used will belong to the shell, which first loaded LANMAN.DRV. This technique WILL NOT WORK for normal DLL usage.
NOTES: Normally, usage is indirect. Intended use is through the global replacement "new" and "delete" operators. In other words, if you link HEAPBIG.CXX into your program, you only have to call MEM_MASTER::Init.
HISTORY: DavidHov 2-25-91 Created
**************************************************************************/
DLL_CLASS MEM_MASTER : public GIANT_HEAP{private:
// This may point to a SUB_HEAP or a GIANT_HEAP
SUB_HEAP * _pFocus;
virtual BYTE * GrowAndAlloc( USHORT cbBytes, USHORT fsFlags = 0 );
// De/constructor
MEM_MASTER( USHORT cbInitAlloc ); ~MEM_MASTER();
public:
static BOOL Init(); static BOOL InitForDll ( INT cPreallocHeaps ); static BOOL Term();
// Primary methods used by global "new" and "delete".
virtual BYTE * Alloc ( USHORT cbBytes, USHORT fsFlags = 0 ); virtual BOOL Free ( BYTE * pbBlock );
// Return the size of any previously allocated block.
USHORT QueryBlockSize( BYTE * pbBlock );
// Change the GIANT_HEAP in use.
BOOL SetFocus( SUB_HEAP * pSubHeap );
// Returns the focussed GIANT_HEAP or NULL
GIANT_HEAP * GetGiantFocus();
// Returns the focussed SUB_HEAP or NULL
SUB_HEAP * GetSubFocus();
USHORT QueryTotalHeaps(); ULONG QueryTotalBlocks();
// Check the health of the heap
BOOL Walk () ;};
#endif // !Win32
#endif // _HEAP_HXX_
|
