#pragma once

int mp_register_usage( size_t size, size_t count );
bool mp_create();
void mp_destory();
void* mp_alloc( int objtype );
void mp_free( int objtype, void* mem );


#include <windows.h>

////////////////////////////////////////////////////////////////////////////////

#define MP_MAX_OBJECT_TYPE        8

struct MP_OBJECT_ENTRY
{
    SLIST_HEADER lsthdr;
    size_t size;
    size_t count;
};

static MP_OBJECT_ENTRY s_entries[MP_MAX_OBJECT_TYPE] = { 0 };
static void* s_base = NULL;

////////////////////////////////////////////////////////////////////////////////

int mp_register_usage( size_t size, size_t count )
{
    if( size == 0 || count == 0 )
        return -1;

    size += MEMORY_ALLOCATION_ALIGNMENT - 1;
    size /= MEMORY_ALLOCATION_ALIGNMENT;
    size *= MEMORY_ALLOCATION_ALIGNMENT;

    for( int i = 0; i < MP_MAX_OBJECT_TYPE; ++i )
    {
        MP_OBJECT_ENTRY* entry = s_entries + i;
        if( entry->size == size || entry->size == 0 )
        {
            entry->size = size;
            entry->count += count;
            return i;
        }
    }

    return -1;
}

//------------------------------------------------------------------------------

bool mp_create()
{
    size_t total = 0;
    for( int i = 0; i < MP_MAX_OBJECT_TYPE; ++i )
        total += s_entries[i].count * s_entries[i].size;

    s_base = VirtualAlloc( NULL, total, MEM_COMMIT, PAGE_READWRITE );
    if( s_base == NULL )
        return false;

    char* base = reinterpret_cast<char*>( s_base );
    for( int i = 0; i < MP_MAX_OBJECT_TYPE; ++i )
    {
        MP_OBJECT_ENTRY* entry = s_entries + i;
        InitializeSListHead( &entry->lsthdr );

        char* addr = base + entry->size * entry->count;
        addr -= MEMORY_ALLOCATION_ALIGNMENT;

        for( size_t j = 0; j < entry->count; ++j )
        {
            SLIST_ENTRY* node = reinterpret_cast<SLIST_ENTRY*>( addr );
            InterlockedPushEntrySList( &entry->lsthdr, node );
            addr -= entry->size;
        }

        base += entry->count * entry->size;
    }

    return true;
}

//------------------------------------------------------------------------------

void mp_destory()
{
    if( s_base != NULL )
    {
        VirtualFree( s_base, 0, MEM_RELEASE );
        s_base = NULL;
    }
}

//------------------------------------------------------------------------------

void* mp_alloc( int objtype )
{
    MP_OBJECT_ENTRY* entry = s_entries + objtype;
    SLIST_ENTRY* node = InterlockedPopEntrySList( &entry->lsthdr );
    char* p = reinterpret_cast<char*>( node );
    if( p != NULL )
        p -= entry->size - MEMORY_ALLOCATION_ALIGNMENT;

    return p;
}

//------------------------------------------------------------------------------

void mp_free( int objtype, void* mem )
{
    if( mem == NULL )
        return;

    MP_OBJECT_ENTRY* entry = s_entries + objtype;
    char* p = reinterpret_cast<char*>( mem );
    p += entry->size - MEMORY_ALLOCATION_ALIGNMENT;

    SLIST_ENTRY* node = reinterpret_cast<SLIST_ENTRY*>( p );
    InterlockedPushEntrySList( &s_entries[objtype].lsthdr, node );
}

////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////

template<size_t size>
class CSomeObject
{
private:
    static int s_objtype;

private:
    char m_data[size];

public:
    CSomeObject() {}
    void DoSomeThing()
    {
        _tprintf( _T("Object Type = %d, Object Size = %d\n"), s_objtype, size );
    }
    ~CSomeObject() {}

public:
    static void RegisterMemoryUsage( size_t count )
    {
        s_objtype = mp_register_usage( sizeof(CSomeObject<size>), count );
    }
    static void* operator new( size_t size )
    {
        return mp_alloc( s_objtype );
    }
    static void operator delete( void* mem )
    {
        mp_free( s_objtype, mem );
    }
};

template<size_t size> int CSomeObject<size>::s_objtype = -1;

////////////////////////////////////////////////////////////////////////////////

HANDLE g_stopevent = NULL;

#define TEST_OBJECT( c, s ) \
    case c:\
    {\
        CSomeObject<s>* p = new CSomeObject<s>;\
        if( p != NULL )\
        {\
            p->DoSomeThing();\
            delete p;\
        }\
    }\
    break;

uintptr_t __stdcall worker_thread( void* )
{
    srand( GetTickCount() );

    while( WaitForSingleObject( g_stopevent, 0 ) == WAIT_TIMEOUT )
    {
        switch( rand() % 7 )
        {
            TEST_OBJECT( 0, 1 )
            TEST_OBJECT( 1, 9 )
            TEST_OBJECT( 2, 10 )
            TEST_OBJECT( 3, 20 )
            TEST_OBJECT( 4, 36 )
            TEST_OBJECT( 5, 100 )
            TEST_OBJECT( 6, 1000 )
        }
    }

    return 0;
}

////////////////////////////////////////////////////////////////////////////////

int _tmain( int argc, _TCHAR* argv[] )
{
    CSomeObject<1>::RegisterMemoryUsage( 100 );
    CSomeObject<9>::RegisterMemoryUsage( 2 );
    CSomeObject<10>::RegisterMemoryUsage( 100 );
    CSomeObject<20>::RegisterMemoryUsage( 200 );
    CSomeObject<36>::RegisterMemoryUsage( 300 );
    CSomeObject<100>::RegisterMemoryUsage( 205 );
    CSomeObject<1000>::RegisterMemoryUsage( 128 );

    mp_create();

    g_stopevent = CreateEvent( NULL, TRUE, FALSE, NULL );
    for( int i = 0; i < 10; ++i )
    {
        uintptr_t h = _beginthreadex( NULL, 0, worker_thread, NULL, 0, NULL );
        CloseHandle( reinterpret_cast<HANDLE>( h ) );
    }

    _getch();

    SetEvent( g_stopevent );
    Sleep( 500 );
    CloseHandle( g_stopevent );
    mp_destory();

    return 0;
}

////////////////////////////////////////////////////////////////////////////////



Lock(); // ①
n = 10; // ②
Unlock(); // ③
int x = n; // ④

struct bar
{
    volatile unsigned version;    // 一个额外的版本号字段
    int field1;
    char field2;
    char field3;
    ......
};
bar g_bar = { 0 };


// 写线程
++g_bar.version;    // 加1, version是奇数, 表示正在更新
g_bar.field1 = 10;
......
++g_bar.version;    // 再加1, version是偶数, 表示更新完毕

// 读线程
void ReadGlobalBar( bar* p )
{
    unsigned ver;
    do {
        ver = g_bar.version;
        if( ver % 2 != 0 )    // 正在更新
        {
            Sleep( 0 );    // 等待
            continue;
        }
        p->field1 = g_bar.field1;
        ......
    } while( ver != g_bar.version );

}

// 头文件

#ifndef SWMR_LOCK_H
#define SWMR_LOCK_H

#ifndef SWMR_LOCK_NUMBER_OF_WRITER
#define SWMR_LOCK_NUMBER_OF_WRITER        1
#endif // SWMR_LOCK_NUMBER_OF_WRITER

typedef volatile long SWMR_LOCK

void SwmrLockInitialize( SWMR_LOCK* pLock );
void SwmrLockWriteLock( SWMR_LOCK* pLock );
void SwmrLockWriteUnlock( SWMR_LOCK* pLock );
void SwmrLockReadLock( SWMR_LOCK* pLock );
void SwmrLockReadUnlock( SWMR_LOCK* pLock );
void SwmrLockUninitialize( SWMR_LOCK* pLock );

#endif

// 实现文件
#include "srmrl.h"

////////////////////////////////////////////////////////////////////////////////

#define WRITING_FLAG    0x40000000

////////////////////////////////////////////////////////////////////////////////

void SwmrLockInitialize( SWMR_LOCK* pLock )
{
    *pLock = 0;
}

////////////////////////////////////////////////////////////////////////////////

void SwmrLockWriteLock( SWMR_LOCK* pLock )
{
    long old, xchg;
    do {
        old = *pLock;
#if( SWMR_LOCK_NUMBER_OF_WRITER > 1 )
        if( old & WRITING_FLAG )
        {
            Sleep( 0 );
            continue;
        }
#endif // ( SWMR_LOCK_NUMBER_OF_WRITER > 1 )
        xchg = old | WRITING_FLAG;
    } while( _InterlockedCompareExchange( pLock, xchg, old ) != old );

    // wait until all readers quit reading
    while( old != WRITING_FLAG )
    {
        Sleep( 0 );
        old = *pLock;
    }
}

////////////////////////////////////////////////////////////////////////////////

void SwmrLockWriteUnlock( SWMR_LOCK* pLock )
{
    *pLock = 0;
}

////////////////////////////////////////////////////////////////////////////////

void SwmrLockReadLock( SWMR_LOCK* pLock )
{
    long old, xchg;
    do {
        old = *pLock;
        if( old & WRITING_FLAG )
        {
            Sleep( 0 );
            continue;
        }
        xchg = old + 1;
    } while( _InterlockedCompareExchange( pLock, xchg, old ) != old );
}

////////////////////////////////////////////////////////////////////////////////

void SwmrLockReadUnlock( SWMR_LOCK* pLock )
{
    _InterlockedDecrement( pLock );
}

////////////////////////////////////////////////////////////////////////////////

void SwmrLockUninitialize( SWMR_LOCK* pLock )
{
    pLock; // has nothing to do

}

template<class T>
class CRefCount
{
private:
    // 使用第30位作为生存标志位, 你可以改成其它位, 但千万不要用了符号位
    static const LONG s_lAliveFlag = 0x40000000;
    volatile LONG m_lRef;
    
public:
    CRefCount() : m_lRef( s_lAliveFlag )
    {
    }
    
    bool AddRef()
    {
        LONG lRef;
        do{
            lRef = m_lRef;
            // 已经死亡了, 增加引用失败
            if( (lRef & s_lAliveFlag) == 0 )
                return false;
        } while( InterlockedCompareExchange(&m_lRef, lRef+1, lRef) != lRef );
        return true;
    }
    
    void Release()
    {
        if( InterlockedDecrement( &m_lRef ) == 0 )
        {
            T* pT = static_cast<T*>( this );
            delete pT;
        }
    }
    
    void Suicide()
    {
        // 注意: 调用此函数前应AddRef, 这样调用之后的Release才能正确删除对象
        InterlockedAnd( &m_lRef, ~s_lActiveFlag );
    }
};