F:/My Projects/LSEngine/Modules/LSMemLib/Src/Allocators/LSASmallAllocator.h

#ifndef __LSA_SMALLALLOCATOR_H__
#define __LSA_SMALLALLOCATOR_H__

#include "../OSHeap/LSAOsHeap.h"


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
// MACROS
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
// The number of 256-byte blocks to use as a guideline for the sizes of the small allocators.
#define LSA_SMALL_ALLOCATOR_BLOCKS                              64

// The smallest allocation size.
#define LSA_SMALLEST_ALLOCATION_BITS                    LSA_MIN_ALIGN_BITS
#define LSA_SMALLEST_ALLOCATION_SIZE                    (1 << LSA_SMALLEST_ALLOCATION_BITS)

// The largest allocation size.
#define LSA_LARGEST_ALLOCATION_SIZE                             256

// Number of blocks in a full working set.
#define LSA_WS                                                                  (LSA_LARGEST_ALLOCATION_SIZE / LSA_SMALLEST_ALLOCATION_SIZE)

namespace lsa {

        class CSmallAllocator {
                // Only the CStdAllocator class can create this object.
                friend class CStdAllocator;

        protected :
                // == Various constructors.
                LSE_CALL                                                                CSmallAllocator( LSVOID * _pvAddress, LSUINT32 _ui32Total256Blocks );


                // == Types.
                typedef struct LSA_SMALL_ALLOC_BLOCKSET {
                        LSA_SIZE *                                                      psBits;

                        LSUINT8 *                                                       pui8Blocks;

                        LSUINT32                                                        ui32Blocks;
                } * LPLSA_SMALL_ALLOC_BLOCKSET, * const LPCLSA_SMALL_ALLOC_BLOCKSET;


                // == Members.
                // The pointer to the next CSmallAllocator object in the linked list managed by our
                //      superiors.
                CSmallAllocator *                                               m_psaNext;

                // The arrays of pointers to the starts of each row of blocks for each given size.
                // We handle 16 sizes (from 16 bytes to 256 bytes).  These point to the first blocks
                //      in each size class.
                LSA_SMALL_ALLOC_BLOCKSET                                m_pui8BlockStarts[LSA_WS];

                // The beginning address of our heap.
                LSA_SIZE                                                                m_sLow;

                // The ending address of our heap.
                LSA_SIZE                                                                m_sHi;


                // == Functions.
                LSVOID LSE_CALL                                                 Init( LSVOID * _pvAddress, LSUINT32 _ui32Total256Blocks );

                LSVOID * LSE_CALL                                               Alloc( LSA_SIZE _sSize, LSUINT32 _ui32Align = LSA_MIN_ALIGN );

                LSBOOL LSE_CALL                                                 Free( LSVOID * _pvAddr );

                LSVOID * LSE_CALL                                               ReAlloc( LSVOID * _pvAddr, LSA_SIZE _sSize,
                        LSA_SIZE &_sOldSize );

                LSBOOL LSE_CALL                                                 IsEmpty() const;

                LSVOID LSE_CALL                                                 Trash();

                LSBOOL LSE_CALL                                                 HaveAddress( const LSVOID * _pvAddr ) const;

                static LSA_SIZE LSE_CALL                                GetWorkingSetSizeByNumberOf256Blocks( LSUINT32 _ui32Total256Blocks,
                        const LSVOID * _pvAddress = NULL,
                        LSA_SMALL_ALLOC_BLOCKSET * _psabBlocks = NULL );

                static LSA_SIZE LSE_CALL                                GetFullAllocatorSizeWithNumberOf256Blocks( LSVOID * _pvAddress,
                        LSUINT32 _ui32Total256Blocks );

                static LSUINT32 LSE_CALL                                GetElementsFromBits( LSUINT32 _ui32Bits );

                static LSUINT32 LSE_CALL                                GetByteAndBitFromBit( const LSUINT32 &_ui32Bit,
                        LSUINT32 &_ui32ReturnBit );

                static LSUINT32 LSE_CALL                                Find0Bit( LSA_SIZE _sValue );

                LSE_INLINE static LSUINTPTR LSE_CALL    GetBlockOffset( LSUINT32 _ui32SetIndex, LSUINT32 _ui32BlockIndex );
        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        LSE_INLINE LSBOOL LSE_CALL CSmallAllocator::HaveAddress( const LSVOID * _pvAddr ) const {
                LSUINTPTR uiptrThis = reinterpret_cast<LSUINTPTR>(_pvAddr);
                return uiptrThis >= m_sLow && uiptrThis < m_sHi;
        }

        LSE_INLINE LSUINTPTR LSE_CALL CSmallAllocator::GetBlockOffset( LSUINT32 _ui32SetIndex, LSUINT32 _ui32BlockIndex ) {
                LSUINTPTR uiptrSize = (_ui32SetIndex + 1) * LSA_SMALLEST_ALLOCATION_SIZE;
                return uiptrSize * _ui32BlockIndex;
        }
        
        
}       // namespace lsa

#endif  // __LSA_SMALLALLOCATOR_H__