cdeclog

/**
 * MemPool.h
 *
 * Memory Pooling Class
 *
 * Copyright (c) 2004 by cdecl (byung-kyu kim)
 *
 */

#ifndef __MEM_POOL_H__BY__CDECL
#define __MEM_POOL_H__BY__CDECL


namespace GLASS {

// MemPool Class 
class MemPool
{
public:
    typedef unsigned int size_type;
    enum { DEFAULT_CHUNK_SIZE = 32 };

    struct MemNode { MemNode *next_; };

public:
    MemPool(size_type type_size, size_type chunk_size = DEFAULT_CHUNK_SIZE) :
        pHead_(0), pFree_(0), nUsed_(0),
        TYPESIZE(type_size > sizeof(MemNode*) ? type_size : sizeof(MemNode*)),
        CHUNK_SIZE(chunk_size)
    {
        ExpanseChunk();
    };
    ~MemPool() { Release(); }

public:
    void* malloc()
    {
        if (IsFull()) {
            if (pFree_) return (NodeNext(pFree_));

            ExpanseChunk();
        }

        int nOffSet = sizeof(MemNode*) + (TYPESIZE * nUsed_++);
        return (reinterpret_cast<char*>(pHead_) + nOffSet);
    }

    void free(void *p)
    {
        MemNode *pmn = reinterpret_cast<MemNode*>(p);
        pmn->next_ = pFree_;
        pFree_ = pmn;
    }

    void ExpanseChunk()
    {
        size_type nAllocSize = TYPESIZE * CHUNK_SIZE + sizeof(MemNode*);

        MemNode *pmn =
            reinterpret_cast<MemNode *>(::operator new(nAllocSize));

        nUsed_ = 0;;

        pmn->next_ = pHead_;
        pHead_ = pmn;
    }

    bool IsFull() const
    {
        return nUsed_ >= CHUNK_SIZE;
    }

    void Release()
    {
        while (pHead_ != 0) {
            ::operator delete(NodeNext(pHead_));
        }
    }

private:
    inline MemNode* NodeNext(MemNode *&pmn)
    {
        MemNode *p = pmn;
        pmn = pmn->next_;
        return p;
    }

private:
    // No Copy
    MemPool(const MemPool&);
    MemPool& operator=(const MemPool&);

private:
    MemNode *pHead_;
    MemNode *pFree_;

    size_type nUsed_;

private:
    const size_type TYPESIZE;
    const size_type CHUNK_SIZE;

};


} // namespace GLASS

#endif

//////////////////////////////////////////////////////// 
#include <iostream>
using namespace std;


template <class Derived, class Base>
class IsDerived
{
private:
    class YES { char c[2]; };
    class NO {};

    static YES Test(Base *p);
    static NO Test(...);

public:
    // VC++, g++ 문제 없음 
    static bool Is()
    {
        return (sizeof(Test(static_cast<Derived *>(0))) == sizeof(YES));
    }

    // VC++ 문제없음 
    // g++ 3.2 컴파일 안됨 
    // g++ 3.4.1 에서는 문제 없음
    // enum { Is = (sizeof(Test(static_cast<Derived *>(0))) == sizeof(YES)) }; 

};


class B {};

class C : public B
{};


int main()
{
    cout << IsDerived<C, B>::Is() << endl;
}

#ifndef __PROP_H__BY_CDECL__ 
#define __PROP_H__BY_CDECL__ 

namespace Glass {

class IYES {};
class YES : public IYES {};
class NO {};

template <class T, class Parent, class ReadWrite = YES>
    class Prop
{
public:
    typedef Prop<T, Parent> this_type;
    typedef T (Parent::*get_fun)();
    typedef void (Parent::*set_fun)(const T&);

    Prop() : getf_(NULL), setf_(NULL), parent_(NULL) {}

    void SetParent(Parent *p) {
        parent_ = p;
    }

    void Set(set_fun f) {
        ReadWrite yn;
        IYES *p = &yn; // 읽기전용일때 이함수를 사용하면 컴파일 에러 !! 

        setf_ = f;
    }

    void Get(get_fun f) {
        getf_ = f;
    }

    T operator=(const T &value) {
        ReadWrite yn;
        IYES *p = &yn; // 읽기전용일때 이함수를 사용하면 컴파일 에러 !! 

        if (!setf_) {
            throw exception();
        }

        (parent_->*setf_)(value);
        return value;
    }

    T operator=(this_type &type) {
        return operator=(static_cast<T>(type));
    }

    operator T() {
        if (!getf_) {
            throw exception();
        }

        return (parent_->*getf_)();
    }

private:
    Parent *parent_;
    get_fun getf_;
    set_fun setf_;

};


} // namespace Glass 

#endif // __PROP_H__BY_CDECL__ 



#include <iostream>
#include <string>
using namespace std;


class AA
{
public:
    AA() {
        Str.SetParent(this);
        Str.Set(&AA::setStr);
        Str.Get(&AA::getStr);
    }

    void setStr(const string &str)
    {
        cout << "setStr" << endl;
        str_ = str;
    }

    string getStr()
    {
        cout << "getStr" << endl;
        return str_;
    }

    Glass::Prop<string, AA> Str;
    string str_;
};


int main()
{
    AA a;
    a.Str = "cdecl ";

}

#include <iostream>
#include <string>
using namespace std;

#include <windows.h>
#include <boost/pool/pool.hpp>

class VM
{
public:
    void* operator new(size_t s)
    {
        return bpool.malloc();
    }

    void operator delete(void *p)
    {
        bpool.free(p);
    }

private:
    char sz[100];

private:
    static boost::pool<> bpool;
};

boost::pool<> VM::bpool(sizeof(VM));


class NVM
{
private:
    char sz[100];
};


template <class Ty>
DWORD PoolingTest()
{
    enum { COUNT = 1000, LOOP = 500 };

    DWORD dw = GetTickCount();
    Ty *pArr[LOOP];

    int i, j;
    for (i = 0; i < COUNT; ++i) {
        for (j = 0; j < LOOP; ++j) {
            pArr[j] = new Ty();
        }
        for (j = 0; j < LOOP; ++j) {
            delete pArr[j];
        }
    }

    return GetTickCount() - dw;
}


int main()
{
    cout << "pooling: " << PoolingTest<VM>() << endl;
    cout << "normal: " << PoolingTest<NVM>() << endl;

    cout << "END" << endl;
    cin.get();
    return 0;
}