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

               

---

dKingyoAnalogGC.h

解説を見る。

#include "AllLoad.h"

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

//**********************************************************
//d金魚流？？ガベコレもどき
//**********************************************************


#   ifdef USE_DKINGYO_DEBUG_VIEW

class INL_dKingyoAllocatorGC{
    
    //typedef std::deque<DKINGYOALLOCATOR_GC_DEBUG>  GC_QUEUE;
    typedef std::deque<void *>  GC_QUEUE;
    //typedef DKUTIL_HASHSET<DKINGYOALLOCATOR_GC_DEBUG> GC_SET;
    typedef std::set<DKINGYOALLOCATOR_GC_DEBUG> GC_SET;
    typedef std::pair<GC_SET::iterator,bool> GC_SET_RESULT;
    GC_QUEUE sm_fq;//Freeに使うキュー
    GC_SET sm_taset;//使い捨てメモリ用セット
    GC_SET sm_set;//セット
    enum{
        enuSTLsetNotFound = 1,//set内で見つからない。
        enuSTLdequeNotFound,//deque内で見つからない。
        enuSTLempty,//STLコンテナ内に何も格納されてない。
    };
    inline int SetQueue(void *getpower,size_t size,bool ThrowingAwayFlag,char *str){
        if(ThrowingAwayFlag){
            sm_taset.insert(DKINGYOALLOCATOR_GC_DEBUG(size,getpower,str));
        }else{
            sm_set.insert(DKINGYOALLOCATOR_GC_DEBUG(size,getpower,str));
        }
        return 0;
    }
    inline int PopFreeQueue(void *get){
        GC_SET::iterator it = sm_taset.begin();
        bool findflag=false;
        while( it != sm_taset.end() ){
            if( (*it).address == get ){//見つかった
                findflag=true;
                break;
            }
            it++;
        }
        if(findflag){
            sm_taset.erase(it);//見つかった
        }else{
            //見つからなかったらエラー値を返す
            return enuSTLsetNotFound;
        }
        return 0;
    }
    int PopQueue(void *get){
        if(!sm_set.empty())
        {
            GC_SET::iterator it = sm_set.begin();
            bool findflag=false;
            while( it != sm_set.end() ){
                if( (*it).address == get ){//見つかった
                    findflag=true;
                    break;
                }
                it++;
            }
            if(findflag){//見つかった！
                sm_set.erase(it);
            }else{//見つからない！！
                return enuSTLsetNotFound;
            }
        }else{
            return enuSTLempty;
        }
        return 0;
    }
public:
    INL_dKingyoAllocatorGC(){}
    ~INL_dKingyoAllocatorGC(){
        AllClear();
    }
    
    inline void *Malloc(size_t size,bool ThrowingAwayFlag,char *str){
        void *getpower = ::malloc(size);
        if(!getpower) return NULL;
        SetQueue(getpower,size,ThrowingAwayFlag,str);
        return getpower;
    }
    inline void *Realloc(void *get,size_t size,bool ThrowingAwayFlag,char *str){
        void *getpower = ::realloc(get,size);
        if(!getpower) return NULL;
        SetQueue(getpower,size,ThrowingAwayFlag,str);
        return getpower;
    }
    inline int Free(void *get,bool ImmediatelyFreeFlag=false){
        if(ImmediatelyFreeFlag){//すぐに開放するならば
            if(0 != PopQueue(get)){
                return -1;//不正なアドレスを代入したらしい
            }
            ::free(get);
            return 0;
        }else{//キューに入れる。

            sm_fq.push_back(get);
        }
        return -1;
    }

    inline int FreeQueueClear(){
        GC_QUEUE::iterator it = sm_fq.begin();
        int invalidNum=0;//無効だった数
        if(!sm_fq.empty()){//空じゃない場合
            while( it != sm_fq.end() ){
                if( 0 != PopFreeQueue((*it))){
                    invalidNum++;
                }else{//不正なアドレスではなかったら
                    ::free((*it));
                }
                it++;
            }
        }else{
            return enuSTLempty;
        }
        sm_fq.clear();//キュー内をクリアする。
#       ifdef _DEBUG
        if(invalidNum){
            dOutputDebugString(" FreeQueueClear() 不正開放数 = %d\n",invalidNum);
        }
#       endif
        return 0;
    
    }
    inline int AllClear(){
        int invalid=0;

        FreeQueueClear();
        
        if(!sm_set.empty())
        {
            GC_SET::iterator it = sm_set.begin();
            while( it != sm_set.end() ){
                ::free((*it).address);
                it++;
            }
            sm_set.clear();
        }
        if(!sm_taset.empty())
        {
            GC_SET::iterator it = sm_taset.begin();
            while( it != sm_taset.end() ){
                ::free((*it).address);
                it++;
            }
            sm_taset.clear();
        }
        return 0;
    }
};

#else 

class INL_dKingyoAllocatorGC{
protected:

    typedef std::deque<void * > GC_QUEUE;
    //typedef DKUTIL_HASHSET<void * > GC_SET;
    typedef std::set<void * > GC_SET;
    typedef std::pair<GC_SET::iterator,bool> GC_SET_RESULT;

    GC_QUEUE sm_fq;//Freeに使うキュー
    GC_SET sm_taset;//使い捨てメモリ用セット
    GC_SET sm_set;//セット
    enum{
        enuSTLsetNotFound = 1,//set内で見つからない。
        enuSTLdequeNotFound,//deque内で見つからない。
        enuSTLempty,//STLコンテナ内に何も格納されてない。
    };
    inline int SetQueue(void *getpower,size_t //size
                                                                        ,bool ThrowingAwayFlag
                                                                        ,char * //str
                                                                        ){
        if(ThrowingAwayFlag){//使い捨て指定だったら使い捨て用キューに入れる。
            sm_taset.insert(getpower);
        }else{
            sm_set.insert(getpower);
        }
        return 0;
    }
    inline int PopFreeQueue(void *get){
        //フリー用キュー内を検索して見つかったら削除する
        GC_SET::iterator it=sm_taset.begin();
        it = sm_taset.find(get);
        if(it != sm_taset.begin() ){
            sm_taset.erase(it);
        }else{
            return enuSTLsetNotFound;
        }
        return 0;
    }
    int PopQueue(void *get){
        //すべてのメモリアドレスを管理しているsetを検索して見つかったら削除
        //見つからなかったらエラー値を返す。
        if(!sm_set.empty())
        {
            GC_SET::iterator it=sm_set.begin();
            it = sm_set.find(get);
            if(it != sm_set.begin() ){
                sm_set.erase(it);
            }else{
                //見つからなかったら使い捨て専用領域から探す。
                //PopFreeQueue(get);
                //いや、見つからない。
                return enuSTLsetNotFound;
            }
        }else{
            return enuSTLempty;
        }

        return 0;
    }
public:
    INL_dKingyoAllocatorGC(){}
    ~INL_dKingyoAllocatorGC(){
        AllClear();
    }
    
    inline void *Malloc(size_t size,bool ThrowingAwayFlag,char *str){
        void *getpower = ::malloc(size);
        if(!getpower) return NULL;
        SetQueue(getpower,size,ThrowingAwayFlag,str);
        return getpower;
    }
    inline void *Realloc(void *get,size_t size,bool ThrowingAwayFlag,char *str){
        void *getpower = ::realloc(get,size);
        if(!getpower) return NULL;
        SetQueue(getpower,size,ThrowingAwayFlag,str);
        return getpower;
    }

    inline int Free(void *get,bool ImmediatelyFreeFlag=false){
        if(ImmediatelyFreeFlag){//すぐに開放するならば
            if(0 != PopQueue(get)){
                return -1;//不正なアドレスを代入したらしい
            }
            ::free(get);
            return 0;
        }else{//キューに入れる。
            sm_fq.push_back(get);
        }
        return -1;
    }
    inline int FreeQueueClear(){
        GC_QUEUE::iterator it = sm_fq.begin();
        int invalidNum=0;//無効だった数
        if(!sm_fq.empty()){//空じゃない場合
            while( it != sm_fq.end() ){
                if( 0 != PopFreeQueue((*it))){
                    invalidNum++;
                }else{//不正なアドレスではなかったら
                    ::free((*it));
                }
                it++;
            }
        }else{
            return enuSTLempty;
        }
        sm_fq.clear();//キュー内をクリアする。
#       ifdef _DEBUG
        if(invalidNum){
            dOutputDebugString(" FreeQueueClear() 不正開放数 = %d\n",invalidNum);
        }
#       endif
        return 0;
    
    }
    inline int AllClear(){
        int invalid=0;

        FreeQueueClear();
        
        if(!sm_set.empty())
        {
            GC_SET::iterator it = sm_set.begin();
            while( it != sm_set.end() ){
                ::free((*it));
                it++;
            }
            sm_set.clear();
        }
        if(!sm_taset.empty())
        {
            GC_SET::iterator it = sm_taset.begin();
            while( it != sm_taset.end() ){
                void *itit = (*it);
                ::free((*it));
                it++;
            }
            sm_taset.clear();
        }
        return 0;
    }
};
#endif // end of USE_DKINGYO_DEBUG_VIEW

inline INL_dKingyoAllocatorGC &GetdKingyoGCOriginalRefelence(){
    static INL_dKingyoAllocatorGC dgc;
    return dgc;
}

#ifdef _DEBUG
inline void CheckNullAddress(void *p){
    if(p==NULL) MB("NULL Plase break;");
}
#else
inline void CheckNullAddress(void *p){}
#endif


// /*
template<class T>
class dKingyoAllocatorGC : public IdKingyoAllocatorGC<T>
{
  typedef size_t    size_type;
  typedef ptrdiff_t difference_type;
  typedef T*        pointer;
  typedef const T*  const_pointer;
  typedef T&        reference;
  typedef const T&  const_reference;
  typedef T         value_type;
protected:
    bool m_CollectFlag;
    bool m_ImmediatelyFreeFlag;

#   ifdef _DEBUG
    DWORD m_alloc_count;
    char m_tempstr[256];
    enum{
        enuTempStrNum=256,
    };
    inline pointer alllocate_proto(size_type n){
        _snprintf(m_tempstr,enuTempStrNum," dKingyoAllocatorGC::allocate No=%d,size=%d",
            m_alloc_count++,n);// ++してます
        return DKINGYO_GC_NEW_A(m_CollectFlag,m_tempstr) value_type[n];
    }
    inline void deallocate_proto(pointer p){
        CheckNullAddress(p);
    DKINGYO_GC_DELETE_A(p,m_ImmediatelyFreeFlag);
    }
#   else
    inline pointer alllocate_proto(size_type n){
        return DKINGYO_GC_NEW_A(m_CollectFlag,"release") value_type[n];
    }
    inline void deallocate_proto(pointer p){
    DKINGYO_GC_DELETE_A(p,m_ImmediatelyFreeFlag);
    }
# endif

public:
    inline void SetCollectFlag(bool f){ m_CollectFlag=f;}
    inline void SetImmediatelyFreeFlag(bool f){ m_ImmediatelyFreeFlag = f;}
    dKingyoAllocatorGC(){
        SetCollectFlag(false);
        SetImmediatelyFreeFlag(false);
    }
    virtual ~dKingyoAllocatorGC(){}

    virtual void *MallocGC(size_t,bool,char *) const;
    virtual int FreeGC(void *,bool) const;
    virtual void *ReallocGC(void *,size_t,bool,char *) const;
    virtual int Collection() const;//ガベコレもどきをする。
  
    pointer       address(reference x) const
    { return &x; }
  const_pointer address(const_reference x) const
    { return &x; }
  pointer       allocate(size_type n, const void* hint = 0) {
    return alllocate_proto(n);
    }
  void      deallocate(pointer p, size_type n = 0) {
        deallocate_proto(p);
  }
  size_type max_size() const{
        return (size_t)-1 / sizeof(T);
    }
  void construct(pointer p, const T& val) {
    new ((void*)p) T(val);
  }
  void destroy(pointer p) {
        ((T*)p)->~T();
  }
  char* _Charalloc(size_type n) {
    return allocate(n);
  }
};

// */


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


//**********************************************************
//偽装ガーベジコレクタ(ガベコレもどき)をnew演算子に対応させる
//**********************************************************
struct tugOnlyfordKingyoGCNew{
};
//マクロを用意しているのでこれは見なかったことにしてください。
extern tugOnlyfordKingyoGCNew dKingyoGCNewArg;

inline void *operator new(size_t size,bool CollectionFlag,
                                                    char *String,char *File,int line,tugOnlyfordKingyoGCNew //get
                                                    ){
    //d金魚用ガベコレもどき＾＾；
    return dkutil::memory::GetdKingyoGCOriginalRefelence().Malloc(size,CollectionFlag,String);
}
inline void *operator new[](size_t size,bool CollectionFlag,
                                                        char *String,char *File,int line,tugOnlyfordKingyoGCNew //get
                                                        ){
    return dkutil::memory::GetdKingyoGCOriginalRefelence().Malloc(size,CollectionFlag,String);
}

inline void operator delete[](void* obj,bool ImmediatelyFreeFlag,
                                                            char *File,int line,tugOnlyfordKingyoGCNew //get
                                                            )
{
    dkutil::memory::GetdKingyoGCOriginalRefelence().Free(obj,ImmediatelyFreeFlag);

}
inline void operator delete(void* obj,bool ImmediatelyFreeFlag,
                                                        char *File,int line,tugOnlyfordKingyoGCNew //get
                                                        )
{
    dkutil::memory::GetdKingyoGCOriginalRefelence().Free(obj,ImmediatelyFreeFlag);
}

#define DKINGYO_GC_NEW(flag,str) new(flag,str,__FILE__,__LINE__,dKingyoGCNewArg)

#define DKINGYO_GC_DELETE(p,flag) ::operator delete(p,flag,__FILE__,__LINE__,dKingyoGCNewArg) 

#define DKINGYO_GC_NEW_A(flag,str) new(flag,str,__FILE__,__LINE__,dKingyoGCNewArg)

#define DKINGYO_GC_DELETE_A(p,flag) ::operator delete[](p,flag,__FILE__,__LINE__,dKingyoGCNewArg) 

---