SEO		[PR] 爆速!無料ブログ 無料ホームページ開設 無料ライブ放送

               

---

dKingyoMemoryManager.h

解説を見る。

#ifndef DKINGYO_MEMORY_MANAGER__
#define DKINGYO_MEMORY_MANAGER__



#include "AllLoad.h"
//#include "dkutilTL.h"


//BoehmGC使います。
#   ifdef USE_DKINGYO_BOEHM_GC
#       include <BOEHMGC_INCLUDE_PATH>
#       pragma comment(lib,BOEHMGC_LIB_PATH)

#       ifdef USE_DKINGYO_BEOHM_GC_LEAVE_FREE //GC_freeを使わない(BoehmGCに任せる)場合。
#           define  DKINGYO_GC_FREE__(s)
#       else
#           define DKINGYO_GC_FREE__(s) GC_free(s)
#       endif


typedef struct tugOnlyforBoehmGCNew{
}ONLYFOR_BOEHMGC_NEW;
typedef struct tugOnlyforBoehmGCNewString{
}ONLYFOR_BOEHMGC_NEW_STRING;
typedef struct tugOnlyforBoehmGCNewUnCollect{
}ONLYFOR_BOEHMGC_NEW_UNCOLLECT;

inline void *operator new(size_t size,tugOnlyforBoehmGCNew //get
                                                    ){
    return GC_malloc(size);
}
inline void *operator new[](size_t size,tugOnlyforBoehmGCNew //get
                                                    ){
    return GC_malloc(size);
}
inline void *operator new(size_t size,tugOnlyforBoehmGCNewString //get
                                                    ){
    return GC_malloc_atomic(size);
}
inline void *operator new[](size_t size,tugOnlyforBoehmGCNewString //get
                                                    ){
    return GC_malloc_atomic(size);
}
inline void *operator new(size_t size,tugOnlyforBoehmGCNewUnCollect //get
                                                    ){
    return GC_malloc_uncollectable(size);
}
inline void *operator new[](size_t size,tugOnlyforBoehmGCNewUnCollect //get
                                                    ){
    return GC_malloc_uncollectable(size);
}
inline void operator delete[](void* obj,tugOnlyforBoehmGCNew //get
                                                            )
{
    DKINGYO_GC_FREE__(obj);
}
inline void operator delete(void* obj,tugOnlyforBoehmGCNew //get
                                                            )
{
    DKINGYO_GC_FREE__(obj);
}

namespace dkutil{//begin dkutil
namespace memory{//begin memory

class CBoehmGCWrapper{
public:
    CBoehmGCWrapper(){}
    ~CBoehmGCWrapper(){}
    static ONLYFOR_BOEHMGC_NEW m_new;
    static ONLYFOR_BOEHMGC_NEW_STRING m_new_string;
    static ONLYFOR_BOEHMGC_NEW_UNCOLLECT m_new_uncollect;
    static void *operator new(size_t size);
    static void *operator new[](size_t size);
    static void operator delete[](void* obj);
    static void operator delete(void* obj);
//かなりナンセンスゥな実装だなぁ＾＾；まぁ、プリプロセッサはぶりぶりプロセッサだから＾＾；
//グローばルなのさ〜〜
#   define DKINGYO_BOEHMGC_NEW new(CBoehmGCWrapper::m_new)
#   define DKINGYO_BOEHMGC_NEW_STRING new(CBoehmGCWrapper::m_new_string)
#   define DKINGYO_BOEHMGC_NEW_UNCOLLECT new(CBoehmGCWrapper::m_new_uncollect)
#   define DKINGYO_BOEHMGC_DELETE(mem) ::operator delete(mem,CBoehmGCWrapper::m_new)

#   define DKINGYO_BOEHMGC_NEW_A new(CBoehmGCWrapper::m_new)
#   define DKINGYO_BOEHMGC_NEW_STRING_A new(CBoehmGCWrapper::m_new_string)
#   define DKINGYO_BOEHMGC_NEW_UNCOLLECT_A new(CBoehmGCWrapper::m_new_uncollect)
#   define DKINGYO_BOEHMGC_DELETE_A(mem) ::operator delete[](mem,CBoehmGCWrapper::m_new)

};

}//end of memory
}//end of dkutil

#   endif


#define DKINGYO_NEW new

#define DKINGYO_DELETE delete


#   ifdef USE_DKINGYO_BOEHM_GC
#       define DKINGYO_MALLOC(s) GC_malloc(s)
#       define DKINGYO_FREE(s) GC_free(s)
#       ifdef USE_DKINGYO_BEOHM_GC_LEAVE_FREE
#           undef DKINGYO_FREE(s)
#           define DKINGYO_FREE(s)//BoehmGCに開放処理はすべて任せます。
#       endif
#   else 
#       ifdef USE_DKINGYO_MEMORYLEAK_CHECK
#           define DKINGYO_MALLOC(s) malloc(s)
#           define DKINGYO_FREE(s) free(s)
#           undef DKINGYO_NEW
#           define DKINGYO_NEW ::new(_NORMAL_BLOCK, __FILE__, __LINE__)
#       else
#           define DKINGYO_MALLOC(s) ::malloc(s)
#           define DKINGYO_FREE(s) ::free(s)
#       endif
#   endif

#ifdef USE_DKINGYO_NEW_OPERATOR

inline void *operator new(size_t size)
{
    return DKINGYO_MALLOC(size);
}
inline void *operator new[](size_t size)
{   
    return DKINGYO_MALLOC(size);
}
inline void operator delete[](void* obj)
{
    DKINGYO_FREE(obj);

}
inline void operator delete(void* obj)
{
    DKINGYO_FREE(obj);
}

#endif // end of USE_DKINGYO_NEW_OPERATOR


namespace dkutil{//begin dkutil
namespace memory{//begin memory



//**********************************************************
//メモリ確保だけのラッパークラス等
//**********************************************************
#ifdef USE_DKINGYO_BOEHM_GC

class dKingyoAllocateManagerBoehmGC :
    public IdKingyoAllocateManager ,//抽象クラス
    boost::noncopyable //コピー禁止クラス指定
{
public:
    void *Malloc(size_t s){
        return GC_malloc(s);
    }
    void Free(void *p){
        GC_free(p);
    }
    void *Realloc(void *p,size_t s){
        return GC_realloc(p,s);
    }
};

#endif 

class dKingyoAllocateManagerDefault :
    public IdKingyoAllocateManager ,
    boost::noncopyable 
{
public:
    void *Malloc(size_t s){
        return ::malloc(s);
    }
    void Free(void *p){
        ::free(p);
    }
    void *Realloc(void *p,size_t s){
        return ::realloc(p,s);
    }
};



}//end of memory
}//end of dkutil











/*

template<class T>
class dKingyoVectorMemory : IdKingyoArray< DKINGYO_VECTORMEMORY<T> >{
protected:
    T *m;//vector memory
    size_t allnum;//vecotr memory allnum;
    size_t now_num;//今の空いている配列ナンバー
    typedef std::list< tugdKingyoVectorMemory< T > > DKINGYO_VECTOR_LIST;
    std::list< tugdKingyoVectorMemory< T > > l;//list (use memory domain)
    std::list<tugdKingyoVectorMemory< T > >::iterator it;//list counter
    //int i;
    
public:
    dKingyoVectorMemory(){
        m=NULL;allnum=now_num=0;
    }
    virtual ~dKingyoVectorMemory(){}
    virtual int ReallocateMemory(){
//#error ここはエラー。newのやり方が間違っているぞ！！
        int old=allnum;
        T *get = new T[allnum=allnum*1.5f];
        if(get==NULL)
            return -1;//だめじゃん！！最悪〜〜
        //メモリコピー
        for(i=0;i<old;i++){
            get[i]=m[i];
        }
        delete[] m;//元のは開放
        return 0;
    }
    virtual int Init(size_t num){
        AllFree();
        allnum = num;
        m = new T[allnum];
        if(!m){
            return -1;//What are you DOING about!!!This PC is IDIOTICAL!!!
        }
        return 0;
    }
    
    virtual DKINGYO_VECTORMEMORY<T> *GetArray(size_t num=1){
        int i=0;
        if(num<=0)
            return NULL;//あほ〜〜0は駄目!!
        if(allnum <= now_num + num)//もし、配列が最後まで使っちまったら･･･
        {
            PRINT_DEBUG("dKingyoVectorMemory::GetArray(size_t num) :Compaction function begin\n");
            if(-1==Compaction())//コンパクション
            {
                PRINT_DEBUG("Compaction failed");
                //なんで駄目やねん！
                if(-1==ReallocateMemory())//仕方ないから確保する
                { 
                    PRINT_DEBUG("ReallocateVectorMemory failed.it's the worst!!");
                    return NULL; 
                }//だめだぁ
            }
        }
        //使ってしまった。メモリ領域を記録
        l.push_back(DKINGYO_VECTORMEMORY<T>(&m[now_num],now_num,num,true));
        now_num += num;//今の未使用領域配列の添え字を変更
        

        return &l.back();
    }
    virtual int ReleaseArray(DKINGYO_VECTORMEMORY<T> *pb){
        it = l.begin();
        while (it!=l.end()){
            if ((*it).start_==pb->start_){
                if (!(*it).bUsed_){
                    //英語分からないけど、使わないと覚えないから間違っていても使う･･･ごめんよぉ
                    PRINT_DEBUG("Don't call 'free' function ,at this time insert already free memory domain.\n");
                    return 1;//開放した奴は開放するな！！
                }
                (*it).bUsed_ = false;//削除フラグをつけてOK!?
                return 0;//終わりかよ！これで(まぁ、あとはCompaction関数に任せる^^;
            }
            it++;
        }
        return -1;//そんなポインタは無いよ!!
    }
    inline int Free(DKINGYO_VECTORMEMORY<T> *pb){return ReleaseArray(pb);}
    inline DKINGYO_VECTORMEMORY<T> *Malloc(size_t num){return GetArray(num);}
    virtual int Compaction(){//再起構造にしたかったけど^^;なんか速度的に遅そうだから^^;
        it = l.begin();
        int r=-1;
        //DWORD prev_num;//前のポインタの配列数
        DKINGYO_VECTORMEMORY <T> prev(0,0,0,false);//前の奴
        DKINGYO_VECTOR_LIST::iterator getit;
        DEBUGINT(co,0);//カウンタ
        
        while (it!=l.end())
        {
            
            if(!(*it).bUsed_)//ファルスだったらリストから削除。Vector領域を動かします。
            {
            #ifdef _DEBUG
                //配列の添え字の数が前のより多いはずが無い！
                
                DKINGYO_VECTORMEMORY<T> kore=(*it);
                if(prev.array_num_ >= (*it).array_num_)
                {
                
                    DEBUGMB("Debuging!!! dKingyoMemoryVector");
                }
            #endif
                //コンパクションの例外処理
                if((*it).start_ == m){
                    DEBUGMB("一番最初　だから特殊なコンパクションが必要");
                }
                if((*it).array_num_>=allnum){
                    DEBUGMB("コンパクションは必要ないかもね＾＾");
                }
                
                //次のリストも空き領域が無いか検索。
                {
                    DWORD check_count=1;
                    it++;//ひとつインクリメントしたからcheck_countも１と＾＾
                    //次のメモリもチェック
                    while(it!=l.end())
                    {
                        //ががーん！やっぱりFALSE!!めんどくせぇ！再起構造にしたい!
                        if(!(*it).bUsed_)
                        {
                            getit=it;//代入
                            getit--;//前の奴を指す
                            //前の方にあけわたします(無条件降伏じゃい!(謎))
                            (*(getit)).array_num_ += (*it).array_num_;
                            (*(getit)).num_ += (*it).num_;
                            l.erase(it);//さようなら〜
                        }
                        else//違うのだったらBreakBreak!!
                        {
                            break;
                        }

                        it++;
                        check_count++;
                    }
                    {for(int j=0;j<check_count;j++){
                        it --;//カウンタは戻します。
                    }}

                    
                }

                
                //DWORD offset_num;//配列数
                //DWORD offset;//コピーするサイズ数
                //offset_num = (*(it + 1)).array_num_ - (*it).array_num_;
                //offset = (*(it + 1)).num_;//確保している数はこれだけあるらしい。
                getit=it;//いてれータ代入
                getit++;
                //後ろと同じは駄目でしょ^^;
                if(getit!=l.end()){
                    #ifdef _DEBUG
                
                        DKINGYO_VECTORMEMORY<T> kore_it=(*it);
                        DKINGYO_VECTORMEMORY<T> kore_getit=(*getit);
                
                    #endif
                    
                    for(i=0;i<(*(getit)).num_;i++)//メモリコピー処理。
                    {
                        m[(*it).array_num_ + i] = m[(*(getit)).array_num_ + i];
                    }
                    
                    //保存データを更新。
                    //　次のデータ　前のデータ
                    (*getit).array_num_ =   (*it).array_num_;
                    (*getit).start_ = (*it).start_;

                    //用済みはいらないよん！！
                    l.erase(it);
                    it = getit;//itは無いのでこれを入れときます。
                    //while( これでOKなはず！？
                    r=0;//しっかり処理できてるよん！！
                }
            }
            else//TRUEだったら
            {
                
                
            }
            
            DEBUGINC(co);
            prev = (*it);//内容をコピーします＾＾
            it++;//何故ここでやるかというとeraseで削除されているからです。
        }
        
        //実際どのくらいの領域が空いたのよ！？
        DKINGYO_VECTORMEMORY<T> mem=l.back();
    
        DWORD temp;//使える配列数
        temp = mem.array_num_ + mem.num_;//実際このくらいらしい
        if(temp >= allnum)
        {
            //DEBUGMB("もちろんだめだめです。エラーです。ありえません");
            PRINT_DEBUG("dKingyoVectorMemory:ReallocateMemory function is required.\n");
            return -1;
        }
        now_num = temp;//今つかえる領域はこのくらいです＾＾；
        
        


        return r;
    }
    virtual void AllFree(){
        l.clear();
        if(m){
            delete[] m;
        }
        m=NULL;
        allnum = now_num = 0;
    }
    virtual void PRINT_DEBUG(char *str,...){
        #ifdef _DEBUG
            char s[1024];
            SET_VA_LIST(s,1024,str);
            OutputDebugString(s);
        #endif
    }
    virtual void DEBUG_PRINT(){
        PRINT_DEBUG("//___________________________________\n");
        PRINT_DEBUG("dKingyoVectorMemory class DEBUG_PRINT\n");
        if(allnum <= now_num)
            PRINT_DEBUG("DEBUGPRINT :Vector Memory is Full ,Doesn't go into VectorMemory any longer.\n");
        PRINT_DEBUG("DEBUGPRINT :allnum=%d now_num=%d .\n",allnum,now_num);
        int c=0;
        for(it = l.begin();it!=l.end();it++){
            if(!(*it).bUsed_){
                PRINT_DEBUG("NO Compaction Free domain = %d \n",(*it).array_num_);
            }
            c++;
        }
        PRINT_DEBUG("//____________END_____________________\n");
    }
        
};
*/



#endif

---