TnbStaticMemory.h

[詳解]

#pragma once
#include "TnbSingleton.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CStaticMemory
{
public:
 
    enum EResult
    {
        ER_Success,         
        ER_ExistBank,       
        ER_NotFoundBank,    
        ER_OutOfMemory,     
        ER_InvalidTell,     
        ER_InvalidParam,    
        ER_Locked,          
    };
 
private:
 
    typedef DWORD TELL;
 
    #define INVALID_TELL (ULONG_MAX)
 
    class CManage
    {
        CSyncSection m_syncFunc;    
        class CInfo
        {
            DWORD   m_dwLockCount;          
            DWORD   m_dwSectorSize;         
            WORD    m_wSectorCount;         
            WORD    m_wCacheIndex;          
            WORD    m_wCacheSecNo;          
            WORD    m_wUsedSectors;         
            BYTE*   m_pContent;             
            WORD *index(void) { return reinterpret_cast<WORD*>(m_pContent); }
            WORD *flag(void)
            {
                return (m_pContent == NULL)
                        ? NULL
                        : reinterpret_cast<WORD*>(&m_pContent[sizeof(WORD) * m_wSectorCount]); 
            }
            BYTE* data(WORD wSecNo)
            {
                return (m_pContent == NULL)
                        ? NULL
                        : &m_pContent[  sizeof(WORD) * m_wSectorCount + 
                                        sizeof(WORD) * m_wSectorCount + 
                                        m_dwSectorSize * wSecNo]; 
            }
            WORD m_IndexToSecNo(WORD i)
            {
                WORD* W = index();
                ASSERTLIB(W[i] != 0);
                return ToWord(W[i] & 0x7FFF);
            }
            DWORD m_AllocSub(WORD wStart, WORD wEnd, WORD wLen)
            {
                WORD wNext;
                WORD* F = flag();
                while ( wStart < wEnd )
                {
                    wNext = static_cast<WORD>(F[wStart] & 0x7FFF);
                    if ( wNext == 0 )
                    {
                        wNext = m_wSectorCount;
                    }
                    if ( (F[wStart] & 0x8000) == 0 && (wNext - wStart) >= wLen )
                    {
                        //期待セクタ数の空きがあった
                        WORD w = static_cast<WORD>(wStart + wLen);
                        if ( w >= m_wSectorCount )
                        { 
                            w = 0;
                        }
                        for ( WORD i = 0; i < wLen; i++ )
                        {
                            F[wStart + i] = static_cast<WORD>(0x8000 | w);
                        }
                        m_wCacheSecNo = w;
                        return wStart;
                    }
                    wStart = wNext;
                }
                return INVALID_TELL;
            }
        public:
            CSyncSection syncBank;      
            CInfo(void)
            {
                m_wCacheIndex   = 0;
                m_wCacheSecNo   = 0;
                m_wUsedSectors  = 0;
                m_dwLockCount   = 0;
                m_dwSectorSize  = 0;
                m_wSectorCount  = 0;
                m_pContent      = NULL;     
            }
            ~CInfo(void)
            {
                if ( m_pContent != NULL )
                {
                    delete[] m_pContent;
                    m_pContent = NULL;
                }
            }
            WORD GetSectorCount(void) { return m_wSectorCount; }
            bool IsValid(void) { return m_pContent != NULL; }
            EResult Create(DWORD dwSectorSize, WORD wSectorCount)
            {
                EXCLUSIVE(&syncBank);
                if ( m_pContent != NULL ) { return ER_ExistBank; }
                if ( dwSectorSize < 16 ) { return ER_InvalidParam; }
                if ( wSectorCount < 10 || wSectorCount >= 32768) { return ER_InvalidParam; }
                m_pContent = new BYTE[sizeof(WORD) * wSectorCount + (sizeof(WORD) + dwSectorSize) * wSectorCount];
                if ( m_pContent == NULL ){ return ER_OutOfMemory; }
                memset(m_pContent, 0, sizeof(WORD) * wSectorCount + sizeof(WORD) * wSectorCount);
                m_dwSectorSize = dwSectorSize;
                m_wSectorCount= wSectorCount;
                return ER_Success;
            }
            void Delete(void)   
            {
                EXCLUSIVE(&syncBank);
                #ifdef _DEBUG
                    if ( m_dwLockCount != 0 )
                    {
                        TRACE0("CStaticMemory::CManage::Delete() ; Lock/Unlockの回数が合っていません。\n");
                    }
                #endif
                if ( m_pContent != NULL )
                {
                    delete[] m_pContent;
                    m_pContent = NULL;
                }
                m_wCacheSecNo = 0;
                m_wCacheIndex = 0;
                m_wUsedSectors = 0;
                m_dwLockCount = 0;
            }
            EResult Resize(WORD wSectorCount)
            {
                EXCLUSIVE(&syncBank);
                if ( wSectorCount == 0 )
                {
                    wSectorCount = m_wSectorCount;
                }
                else if ( m_wUsedSectors > wSectorCount )
                {
                    return ER_OutOfMemory;  //足りなくなる
                }
                else if ( m_wSectorCount > wSectorCount )
                {
                    return ER_InvalidParam; //小さくなる
                }
                if ( m_pContent == NULL ){ return ER_NotFoundBank; }
                CInfo infoNew;
                EResult rc = infoNew.Create(m_dwSectorSize, wSectorCount);
                if ( rc != ER_Success ){ return rc; }
                //
                WORD* W = index();
                WORD* newW = infoNew.index();
                WORD* F = flag();
                WORD wPos;
                for ( WORD i = 0; i < m_wSectorCount; i++ )
                {
                    wPos = W[i];
                    if ( wPos != 0 )
                    {
                        wPos &= 0x7FFF;
                        WORD wLen = static_cast<WORD>((F[wPos] & 0x7FFF) - wPos);
                        DWORD r = infoNew.m_AllocSub(infoNew.m_wCacheSecNo, wSectorCount, wLen);
                        if ( r == INVALID_TELL && infoNew.m_wCacheSecNo != 0 )
                        {
                            r = infoNew.m_AllocSub(0, infoNew.m_wCacheSecNo, wLen);
                        }
                        ASSERTLIB(r != INVALID_TELL);
                        BYTE* P = infoNew.data(ToWord(r));
                        ASSERTLIB(P != NULL);
                        MemCopy(P, data(wPos), wLen * m_dwSectorSize);
                        newW[i] = ToWord(0x8000 | r);
                    }
                }
                m_wSectorCount= wSectorCount;
                m_wCacheSecNo = 0;
                m_wCacheIndex = 0;
                delete[] m_pContent;
                m_pContent = infoNew.m_pContent;
                infoNew.m_pContent = NULL;
                return ER_Success;
            }
            WORD GetUsedSectors(void)
            {
                return m_wUsedSectors;
            }
            DWORD Allocate(size_t size)
            {
                EXCLUSIVE(&syncBank);
                if ( m_pContent == NULL ){ return INVALID_TELL; }
                WORD wLen = ToWord((ToDword(size) + m_dwSectorSize - 1) / m_dwSectorSize);
                if ( wLen + m_wUsedSectors > m_wSectorCount ){ return INVALID_TELL; }
                DWORD r = m_AllocSub(m_wCacheSecNo, m_wSectorCount, wLen);
                if ( r == INVALID_TELL && m_wCacheSecNo != 0 )
                {
                    r = m_AllocSub(0, m_wCacheSecNo, wLen);
                }
                if ( r == INVALID_TELL )
                {
                    return r;
                }
                //
                m_wUsedSectors = static_cast<WORD>(m_wUsedSectors + wLen);
                WORD* W = index();
                for ( WORD i = m_wCacheIndex; i < m_wSectorCount; i++ )
                {
                    if ( W[i] == 0 )
                    {
                        W[i] = ToWord(0x8000 | r);
                        m_wCacheIndex = i;
                        return i;
                    }
                }
                for ( WORD i = 0; i < m_wCacheIndex; i++ )
                {
                    if ( W[i] == 0 )
                    {
                        W[i] = ToWord(0x8000 | r);
                        m_wCacheIndex = i;
                        return i;
                    }
                }
                ASSERTLIB(false);
                return INVALID_TELL;
            }
            bool Free(WORD wIndex)
            {
                EXCLUSIVE(&syncBank);
                if ( m_pContent == NULL ){ return false; } // プールなし
                if ( wIndex >= m_wSectorCount ){ return false; } // 番号異常
                WORD wSecNo = m_IndexToSecNo(wIndex);
                ASSERTLIB(wSecNo < m_wSectorCount);
                WORD* F = flag();
                if ( (F[wSecNo] & 0x8000) == 0 ){ return false; } // 確保していない
                m_wCacheSecNo = wSecNo;
                WORD w;
                WORD wNext = static_cast<WORD>(F[wSecNo] & 0x7FFF);
                if ( wNext == 0 )
                {
                    //= 最後。全部０にしちゃう
                    wNext = m_wSectorCount;
                    w = 0;
                }
                else
                {
                    //= 次のブロック確認
                    if ( (F[wNext] & 0x8000) != 0 )
                    {
                        //確保している.次のブロックはNext
                        w = wNext;
                    }
                    else
                    {
                        //確保していない。次のブロックの次にする。
                        w = F[wNext];
                    }
                }
                for ( WORD i = wSecNo; i < wNext; i++ )
                {
                    F[i] = w;
                }
                index()[wIndex] = 0;
                m_wCacheIndex = wIndex;
                m_wUsedSectors = static_cast<WORD>(m_wUsedSectors - (wNext - wSecNo));
                return true;
            }
            size_t GetSize(WORD wIndex)
            {
                EXCLUSIVE(&syncBank);
                if ( wIndex >= m_wSectorCount ){ return INVALID_TELL; } // 番号異常
                WORD wSecNo = m_IndexToSecNo(wIndex);
                ASSERTLIB(wSecNo < m_wSectorCount);
                WORD* F = flag();
                if ( (F[wSecNo] & 0x8000) == 0 ){ return INVALID_TELL; } //確保してない
                if ( wSecNo != 0 )
                {
                    if ( F[wSecNo - 1] == F[wSecNo] ){ return INVALID_TELL; }//一つ前と同じのはずがない
                }
                return ((F[wSecNo] & 0x7FFF) - wSecNo) * m_dwSectorSize;
            }
            DWORD GetLockCount(void) { return m_dwLockCount; }
            LPVOID Lock(WORD wIndex)
            {
                EXCLUSIVE(&syncBank);
                if ( GetSize(wIndex) == INVALID_TELL ){ return NULL; }
                WORD wSecNo = m_IndexToSecNo(wIndex);
                ASSERTLIB(wSecNo < m_wSectorCount);
                ASSERT0(data(wSecNo) != NULL, "CStaticMemory::CManage::CInfo::Lock()", "確保していません");
                m_dwLockCount++;
                return data(wSecNo);
            }
 
            void Unlock(void) 
            {
                m_dwLockCount--;
            }
        private:
            friend class CStaticMemoryTest;
        }; // CINfo
 
        //--------------------
 
        CInfo*  m_pInfo;            
        SINGLETON_CONSTRUCTOR(CManage)
        {
            m_pInfo = new CInfo[256];
            ASSERT( m_pInfo != NULL );
        }
        bool m_CheckTell(TELL& tell, BYTE& bank)
        {
            bank = static_cast<BYTE>(tell >> 24);
            tell &= 0x0000FFFF;
            if ( ! m_pInfo[bank].IsValid() ){ return false; }
            return m_pInfo[bank].GetSectorCount() > tell;
        }
    public:
        ~CManage(void)
        {
            if ( m_pInfo != NULL )
            {
                delete[] m_pInfo;
                m_pInfo = NULL;
            }
        }
        EResult CreateBank(BYTE bank, DWORD dwSectorSize, WORD wSectorCount)
        {
            EXCLUSIVE(&m_syncFunc);
            return m_pInfo[bank].Create(dwSectorSize, wSectorCount);
        }
        EResult DeleteBank(BYTE bank, bool boIsForce = false)
        {
            EXCLUSIVE2(&m_syncFunc,&m_pInfo[bank].syncBank);
            if ( ! m_pInfo[bank].IsValid() ){ return ER_NotFoundBank; }
            if ( ! boIsForce && m_pInfo[bank].GetLockCount() != 0 ){ return ER_Locked; }
            m_pInfo[bank].Delete();
            return ER_Success; 
        }
        EResult ResizeBank(BYTE bank, WORD wSectorCount = 0)
        {
            EXCLUSIVE2(&m_syncFunc,&m_pInfo[bank].syncBank);
            if ( ! m_pInfo[bank].IsValid() ){ return ER_NotFoundBank; }
            if ( m_pInfo[bank].GetLockCount() != 0 ){ return ER_Locked; }
            return m_pInfo[bank].Resize(wSectorCount);
        }
        WORD GetUsedSectors(BYTE bank)
        {
            return static_cast<WORD>(m_pInfo[bank].IsValid() ? m_pInfo[bank].GetUsedSectors() : 0);
        }
        TELL Allocate(BYTE bank, size_t size)
        {
            if ( size == 0 || ! m_pInfo[bank].IsValid() ){ return INVALID_TELL; }
            DWORD dw = m_pInfo[bank].Allocate(size);
            return (dw == INVALID_TELL) ? INVALID_TELL : ((bank << 24) | dw); 
        }
        bool Free(TELL tell)
        {
            BYTE bank;
            return m_CheckTell(tell, bank) ? m_pInfo[bank].Free(ToWord(tell)) : false;
        }
        size_t GetSize(TELL tell)
        {
            BYTE bank;
            return m_CheckTell(tell, bank) ? m_pInfo[bank].GetSize(ToWord(tell)) : 0;
        }
        LPVOID Lock(TELL tell)
        {
            BYTE bank;
            return m_CheckTell(tell, bank) ? m_pInfo[bank].Lock(ToWord(tell)) : NULL;
        }
 
        bool Unlock(TELL tell)
        {
            BYTE bank;
            if ( ! m_CheckTell(tell, bank) ){ return false; }
            m_pInfo[bank].Unlock();
            return true;
        }
 
    private:
        friend class CStaticMemoryTest;
    }; // CManage
 
    //--------------------
 
    CManage*    m_pMan;         
    TELL        m_tell;         
    DWORD       m_dwParam;      
    void m_Init(void)
    {
        m_dwParam = 0;
        m_pMan = CManage::GetInstance();
        m_tell = INVALID_TELL;
    }
 
public:
 
    static EResult CreateBank(BYTE bank, DWORD dwSectorSize, WORD wSectorCount)
    {
        return CManage::GetInstance()->CreateBank(bank, dwSectorSize, wSectorCount);
    }
 
    static EResult DeleteBank(BYTE bank, bool boIsForce = false)
    {
        return CManage::GetInstance()->DeleteBank(bank, boIsForce);
    }
 
    static EResult ResizeBank(BYTE bank, WORD wSectorCount = 0)
    {
        return CManage::GetInstance()->ResizeBank(bank, wSectorCount);
    }
 
    ~CStaticMemory(void)
    {
        Free();
    }
    
    CStaticMemory(void)
    {
        m_Init();
    }
 
    CStaticMemory(const CStaticMemory& h)
    {
        m_Init();
        operator=(h);
    }
 
    CStaticMemory& operator=(const CStaticMemory& other)
    {
        Free();
        if ( other.m_tell != INVALID_TELL )
        {
            LONG* B = static_cast<LONG*>(m_pMan->Lock(other.m_tell));
            ::InterlockedIncrement(B);
            m_pMan->Unlock(other.m_tell);
            m_tell = other.m_tell;
        }
        m_dwParam = other.m_dwParam;
        return *this;
    }
 
    DWORD GetParam(void)
    {
        return m_dwParam;
    }
 
    void SetParam(DWORD dwParam)
    {
        m_dwParam = dwParam;
    }
 
    LONG GetJointlyCount(void)
    {
        if ( m_tell == INVALID_TELL){ return 0; }
        LONG* B = static_cast<LONG*>(m_pMan->Lock(m_tell));
        LONG r = *B;
        m_pMan->Unlock(m_tell);
        return r;
    }
 
    bool HasMemory(void)
    {
        return m_tell!=INVALID_TELL;
    }
 
    bool Allocate(BYTE bank, size_t size)
    {
        Free();
        TELL t = m_pMan->Allocate(bank, size + sizeof(LONG));//カウンタ分多く
        if ( t == INVALID_TELL )
        {
            return false;
        }
        LONG* P = static_cast<LONG*>(m_pMan->Lock(t));
        if ( P == NULL )
        {
            m_pMan->Free(t);
            return false;
        }
        *P = 1; //カウンタ初期化
        m_pMan->Unlock(t);
        m_tell = t;
        return true;
    }
 
    void Free(void)
    {
        if ( m_tell == INVALID_TELL) { return; }
        LONG* B = static_cast<LONG*>(m_pMan->Lock(m_tell));
        if ( ::InterlockedDecrement(B) == 0 )
        {
            m_pMan->Unlock(m_tell);
            m_pMan->Free(m_tell);
        }
        else
        {
            m_pMan->Unlock(m_tell);
        }
        m_tell=INVALID_TELL;
    }
 
    size_t GetSize(void)
    {
        if ( m_tell == INVALID_TELL ){ return 0; }
        size_t l = m_pMan->GetSize(m_tell);
        if ( l != 0 )
        {
            l -= sizeof(LONG); 
        }
        return l;
    }
 
    LPVOID Lock(void)
    {
        if ( m_tell == INVALID_TELL ) { return NULL; }
        LONG* B = static_cast<LONG*>(m_pMan->Lock(m_tell));
        return &B[1];
    }
 
    void Unlock(void)
    {
        if ( m_tell != INVALID_TELL )
        {
            m_pMan->Unlock(m_tell);
        }
    }
 
private:
    friend class CStaticMemoryTest;
};
 
 
 
};//TNB
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
#if 0
    //m_pContent の確保内容
    [Indexテーブル][Flagテーブル][内容]という並び。
    //Indexテーブル
    並びはIndex順。
    TELLの下位WORD(Index)とセクタNoを関連付けるテーブル。最上位BIT
    が立っていたら使用（下位15BITがSecNo）
    Resize、デフラグしても並びは変換しない。
    // Flagテーブル＆内容
    いずれも並びはSecNo順。
    Flag用DWORDをセクタ数確保。
    セクタサイズのメモリをセクタ数確保。
    Flag用は、次の空きセクタ番号を保持。０なら最後を指す。
    つまり起動時はすべて０。
    確保すると、複数の確保したセクタすべて最上位ビットが立ち、
    次のブロックの先頭セクタ番号が入る。
    ex)
             <0>    <1>    <2>    <3>    <4>    <5>    <6>
        起動時
            0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
        2ブロック確保
            0x8002,0x8002,0x0000,0x0000,0x0000,0x0000,0x0000,
        さらに３ブロック確保
            0x8002,0x8002,0x8005,0x8005,0x8005,0x0000,0x0000,
        最初の2ブロック開放
            0x0002,0x0002,0x8005,0x8005,0x8005,0x0000,0x0000,
        1ブロック確保
            0x8001,0x0002,0x8005,0x8005,0x8005,0x0000,0x0000,
 
    つまりチェーンと使用フラグとブロック長がわかるようになる。
#endif
#endif