root/lang/objective-cplusplus/i3/trunk/src/mil/include/mil/Pool.h @ 37815

#pragma once

#include "Mil.h"
#include "Thread.h"

#define MIL_DEBUG_PRODUCER   0
#define MIL_MY_PRODUCER      0
#define MIL_MALLOC_PRODUCER  1
#define MIL_TBB_PRODUCER     0

namespace mil {
namespace pool {

typedef class MemoryHandle_ {
    int unused;
} * MemoryHandle;

class MemoryHeader {
    boost::uint_fast32_t header;
public:
#if MIL_DEBUG_PRODUCER    
    thread::native_id_t os_thread_id;
    thread::id_t mil_thread_id;
    int blocks;
    void* instance;
    bool cleaned;
#endif
    bool isMalloced() const {
        return (getBlocks() == 0xFFFF);
    }
    void* getMemory() const {
        return (void*)((char*)this + sizeof(*this));
    }
    boost::uint16_t getBlocks() const {
#if MIL_MALLOC_PRODUCER
        return 1;
#else
        return static_cast<boost::uint16_t>(0xFFFF & (header >> 16));
#endif
    }
    thread::id_t getThreadId() const {
#if MIL_MY_PRODUCER
        return static_cast<thread::id_t>(0xFFFF & header);
#else
        return ~0;
#endif
    }
    static MemoryHeader& get(void* memory) {
        return *(static_cast<MemoryHeader*>(memory) - 1);
    }
    static MemoryHeader& create(
        void* memory, boost::uint16_t blocks, thread::id_t thread_id) {

        MemoryHeader* this_ = static_cast<MemoryHeader*>(memory);

        BOOST_STATIC_ASSERT(sizeof(this_->header) >=
                            (sizeof(blocks) + sizeof(thread_id)));

        this_->header = (blocks << 16) | thread_id;
        return *this_;
    }
};

namespace private_ {
class MemoryList {
public:
    MemoryList* next;
};

const unsigned int BLOCK_SIZE = sizeof(void*) * 4;

#if MIL_DEBUG_PRODUCER
const unsigned int MALLOC_BLOCKS_THESHOLD = 3;
#else
const unsigned int MALLOC_BLOCKS_THESHOLD = 10;
#endif

static inline boost::uint16_t bytes_to_blocks(size_t bytes) {
    if (bytes == 0) {
        return 1;
    }
    size_t blocks = ((bytes - 1) / BLOCK_SIZE) + 1;
    if (std::numeric_limits<boost::uint16_t>::max() < blocks) {
        return 0xFFFF;
    }
    return (boost::uint16_t)blocks;
}

}
}
}

namespace mil {
namespace pool {

class MallocProducer {
public:
    MallocProducer(thread::id_t thread_id) {
        (void)thread_id;
    }

    void* allocate(int bytes) {
        return ::malloc(bytes);
    }

    template <typename Type>
    Type* allocate() {
        return (Type*)allocate(sizeof(Type));
    }

    void free(void* memory) {
        ::free(memory);
    }

    void free(MemoryHandle m) {
        (void)m;
    }
};

class MallocConsumer {
public:
    MemoryHandle pop(thread::id_t owner_id) {
        (void)owner_id;
        return (MemoryHandle)NULL;
    }

    void store(void* memory) {
        free(memory);
    }
};
}
}

#if HAVE_TBB_TBB_ALLOCATOR_H
#include <tbb/tbb_allocator.h>
namespace mil {
namespace pool {

struct TBBMemoryUnit {
    char data[private_::BLOCK_SIZE];
};

extern tbb::tbb_allocator<TBBMemoryUnit> tbb_a;

class TBBProducer {
public:
    TBBProducer(thread::id_t thread_id) {
        (void)thread_id;
    }

    void* allocate(int bytes) {
        boost::uint_fast32_t blocks = private_::bytes_to_blocks(bytes);
        bytes += sizeof(blocks);
        void* memory = NULL;
        if (blocks <= private_::MALLOC_BLOCKS_THESHOLD) {
            memory = tbb_a.allocate(blocks);
        } else {
            memory = malloc(bytes);
        }
        if (!memory) {
            halt << "can't allocate memory";
        }
        *(boost::uint_fast32_t*)memory = blocks;
        memory = (void*)((char*)memory + sizeof(blocks));
        return memory;
    }

    template <typename Type>
    Type* allocate() {
        return (Type*)allocate(sizeof(Type));
    }

    void free(void* memory) {
        (void)memory;
    }

    void free(MemoryHandle m) {
        (void)m;
    }
};

class TBBConsumer {
public:
    MemoryHandle pop(thread::id_t owner_id) {
        (void)owner_id;
        return (MemoryHandle)NULL;
    }

    void store(void* memory) {
        boost::uint_fast32_t blocks = 0;
        memory = (void*)((char*)memory - sizeof(blocks));
        blocks = *(boost::uint_fast32_t*)memory;
        if (blocks <= private_::MALLOC_BLOCKS_THESHOLD) {
            tbb_a.deallocate((mil::pool::TBBMemoryUnit*)memory, blocks);
        } else {
            ::free((void*)memory);
        }       
    }
};

}
}
#endif
namespace mil {
namespace pool {

class MyProducer : public boost::noncopyable {
public:
    boost::pool<> p;
    const thread::id_t thread_id;
    MyProducer(thread::id_t thread_id) : p(private_::BLOCK_SIZE), thread_id(thread_id) {
    }

    void* allocate(int bytes) {
        bytes += sizeof(MemoryHeader);
        boost::uint16_t blocks = private_::bytes_to_blocks(bytes);

        void* memory = NULL;
        if (blocks == 1) {
            memory = p.malloc();
        } else if (blocks <= private_::MALLOC_BLOCKS_THESHOLD) {
            memory = p.ordered_malloc(blocks);
        } else {
            memory = malloc(bytes);
        }
        if (!memory) {
            halt << "can't allocate memory";
        }
        MemoryHeader& header = MemoryHeader::create(memory, blocks, thread_id);

#if MIL_DEBUG_PRODUCER
        {
            header.os_thread_id  = mil::thread::get_native_id();
            header.mil_thread_id = thread_id;
            header.blocks        = private_::bytes_to_blocks(bytes);
            header.instance      = (void*)this;
            header.cleaned       = false;
        }
#endif

        return header.getMemory();
    }

    template <typename Type>
    Type* allocate() {
        return (Type*)allocate(sizeof(Type));
    }

    void free(void* memory) {
        MemoryHeader& header = MemoryHeader::get(memory);
        boost::uint16_t blocks = header.getBlocks();
        thread::id_t memory_thread_id = header.getThreadId();
        memory = (void*)&header;

#if MIL_DEBUG_PRODUCER
        {
            if (header.os_thread_id != mil::thread::get_native_id()) {
                halt << "header.os_thread_id != mil::thread::get_native_id(), "
                     << header.os_thread_id << " != " << mil::thread::get_native_id();
            }
            if (header.mil_thread_id != thread_id) {
                halt << "header.mil_thread_id == thread_id, "
                     << header.mil_thread_id << " != " << thread_id;
            }
            if (header.mil_thread_id != memory_thread_id) {
                halt << "header.mil_thread_id == memory_thread_id, "
                     << header.mil_thread_id << " != " << thread_id;
            }
            if (header.blocks != blocks) {
                halt << "header.blocks != blocks, "
                     << header.blocks << " != " << blocks;
            }
            if (header.instance != (void*)this) {
                halt << "header.instance != this, "
                     << header.instance << " != " << this;
            }
            if (header.cleaned) {
                halt << "header.cleaned == true, ";
            }
            header.cleaned = true;
        }
#else
        (void)memory_thread_id;
#endif

        if (blocks == 1) {
            p.free(memory);
        } else if (blocks <= private_::MALLOC_BLOCKS_THESHOLD) {
            p.free(memory, blocks);
        } else {
            ::free(memory);
        }
    }

    void free(MemoryHandle m) {
        private_::MemoryList* current = (private_::MemoryList*)m;
        for (;;) {
            if (!current) {
                break;
            }
            private_::MemoryList* next = current->next;
            this->free((void*)current);
            current = next;
        }
    }
};

class MyConsumer : public boost::noncopyable {
    private_::MemoryList* heads[MIL_MAX_THREADS];
    int sizes[MIL_MAX_THREADS];

    enum {
        MAX_STORES = 50,
    };

public:
    MyConsumer() {
        memset((void*)heads, 0, sizeof(heads));
        memset((void*)sizes, 0, sizeof(sizes));
    }

    MemoryHandle pop(thread::id_t owner_id) {
        if (sizes[owner_id] < MAX_STORES) {
            return NULL;
        }
        private_::MemoryList* result = heads[owner_id];
        heads[owner_id] = 0;
        sizes[owner_id] = 0;
        return (MemoryHandle)result;
    }

    void store(void* memory) {
        MemoryHeader& header = MemoryHeader::get(memory);
        //if (header.isMalloced()) {
        //    free(&header);
        //    return;
        //}
        thread::id_t owner_id = header.getThreadId();
        private_::MemoryList* l = (private_::MemoryList*)memory;
        l->next = heads[owner_id];
        heads[owner_id] = l;
        sizes[owner_id]++;
    }
};
}
}

namespace mil {
namespace pool {
#if MIL_MALLOC_PRODUCER
    typedef MallocProducer Producer;
    typedef MallocConsumer Consumer;
#elif MIL_TBB_PRODUCER
    typedef TBBProducer Producer;
    typedef TBBConsumer Consumer;
#elif MIL_MY_PRODUCER
    typedef MyProducer Producer;
    typedef MyConsumer Consumer;
#else
#error
#endif
}
}