MultilingualSimpleObject

//
// Created by whg on 2020/8/25.
//
#pragma once
#include <utility>
#include <memory>
#include <vector>
#include <chrono>

namespace typany {
namespace ObjectPool {

    inline int64_t GetCurrentTimeStamp() {
        std::chrono::time_point<std::chrono::system_clock> current = std::chrono::system_clock::now();
        auto stamp = std::chrono::duration_cast<std::chrono::milliseconds>(current.time_since_epoch());
        return stamp.count();
    }

    template <typename T, size_t ChunkMaxBlockSize = 128, std::int64_t MaxAccessIntervalMillisecond = 3*60*1000>
    class Allocator
    {
    public:
        typedef T               value_type;
        typedef T*              pointer;
        typedef const T*        const_pointer;

    private:
        Allocator() {}
        ~Allocator(){
            Chunk* chunkPointer = chunk_;
            while (chunkPointer != nullptr) {
                Chunk* next = chunkPointer->Next();
                ::delete chunkPointer;
                chunkPointer = next;
            }
        }

    public:
        static Allocator<value_type>& Instance() {
            static Allocator<value_type> allocator_;
            return allocator_;
        }
        void* Allocate(size_t size) {
            if (size > MaxSize()) {
                throw std::runtime_error("");
            }

            if (chunk_ == nullptr) {
                chunk_ = ::new Chunk(ChunkMaxBlockSize, minBlockSize_, align_);
            }

            Chunk* chunkPointer = chunk_;
            while (chunkPointer != nullptr) {
                if (!chunkPointer->Full() || chunkPointer->Next() == nullptr) {
                    break;
                }
                chunkPointer = chunkPointer->Next();
            }
            if (!chunkPointer->Full()) {
                return chunkPointer->Acquire();
            }
            if (chunkPointer->Next() == nullptr) {
                chunkPointer->Next(::new Chunk(ChunkMaxBlockSize, minBlockSize_, align_));
            }
            return chunkPointer->Next()->Acquire();
        }

        void Deallocate(void* ptr, size_t length) noexcept {
            if (chunk_ == nullptr) {
                throw std::runtime_error("Allocator<T>::allocate(size_t n) 'n' exceeds maximum supported size");
            }

            Chunk* chunkPointer = chunk_;
            while (chunkPointer != nullptr) {
                if (chunkPointer->InRange(ptr) || chunkPointer->Next() == nullptr) {
                    break;
                }
                chunkPointer = chunkPointer->Next();
            }
            if (chunkPointer->InRange(ptr) && chunkPointer->CheckAddressValid(ptr)) {
                chunkPointer->Release(ptr);
            } else {
                throw std::runtime_error("Allocator<T>::allocate(size_t n) 'n' exceeds maximum supported size");
            }

            ++deallocateCount_;
            ShrinkChunk();
        }
        inline size_t MaxSize() const noexcept {
            return size_t(~0) / type_size_;
        }

    private:
        // 收缩，超出MaxAccessIntervalMillisecond未访问，且Empty = true，则删掉该Chunk
        void ShrinkChunk() {
            if (chunk_ == nullptr || deallocateCount_ % ChunkMaxBlockSize != 0) {
                return;
            }
            // 至少保留一个chunk
            Chunk* chunkPointer = chunk_;
            while (chunkPointer != nullptr) {
                Chunk* next = chunkPointer->Next();
                if (next == nullptr) {
                    break;
                }
                if (next->Idle()) {
                    std::int64_t chunkStamp = next->LastReleaseTimeStamp();
                    std::int64_t currentStamp = GetCurrentTimeStamp();
                    if (currentStamp - chunkStamp >= MaxAccessIntervalMillisecond) {
                        chunkPointer->Next(next->Next());
                        ::delete next;
                    } else {
                        chunkPointer = chunkPointer->Next();
                    }
                } else {
                    chunkPointer = chunkPointer->Next();
                }
            }
        }
    private:
        // 数据块，
        class Chunk {
        public:
            Chunk(size_t maxBlockCount, size_t blockSize, size_t align) : maxBlockCount_(maxBlockCount), blockSize_(blockSize), length_(maxBlockCount_*blockSize_), align_(align) {
                unsigned char* address = (unsigned char*)malloc(length_);
                data_ = reinterpret_cast<pointer>(address);
                enabled_ = (data_ != nullptr);
                if (enabled_) {
                    idle_.reserve(maxBlockCount_);
                    for (size_t i = 0; i < maxBlockCount; ++i) {
                        idle_.push_back(i);
                    }
                }
            }
            ~Chunk(){
                Destory();
            }
            void* Acquire() {
                if (!enabled_ || Full()) {
                    return nullptr;
                }
                size_t index = idle_.back();
                idle_.pop_back();
                lastReleaseTimeStamp_ = std::numeric_limits<std::int64_t>::max();
                return IndexToAddress(index);
            }
            void Release(void* ptr) {
                if (!InRange(ptr) || !CheckAddressValid(ptr)) {
                    return;
                }
                size_t index = AddressToIndex(ptr);
                idle_.push_back(index);
                if (Idle()) {
                    // 只记最后一次归还的时间
                    lastReleaseTimeStamp_ = GetCurrentTimeStamp();
                }
            }
            void Destory() {
                if (!enabled_) {
                    return;
                }
                free(data_);
                idle_.clear();
            }
            bool Full() const {
                return data_ == nullptr ? true : idle_.empty();
            }
            bool Idle() const {
                return idle_.size() == ChunkMaxBlockSize;
            }
            const_pointer Begin() const {
                return data_;
            }
            pointer End() const {
                return data_ + maxBlockCount_;
            }
            bool InRange(void* ptr) {
                return (data_ <= reinterpret_cast<pointer>(ptr) && reinterpret_cast<pointer>(ptr) < data_ + maxBlockCount_);
            }
            bool CheckAddressValid(void* ptr) {
                return (reinterpret_cast<size_t >(ptr) % align_ == 0)
                       && ((reinterpret_cast<size_t >(ptr) - reinterpret_cast<size_t >(data_)) % blockSize_ == 0);
            }
            Chunk* Next() {
                return next_;
            }
            void Next(Chunk* chunkPointer) {
                next_ = chunkPointer;
            }
            const std::int64_t& LastReleaseTimeStamp() {
                return lastReleaseTimeStamp_;
            }
        private:
            size_t AddressToIndex (void* ptr) {
                return reinterpret_cast<pointer>(ptr) - data_ ;
            }
            void* IndexToAddress(const size_t& index) {
                if (data_ == nullptr || index >= maxBlockCount_) {
                    return nullptr;
                }
                return data_ + index;
            }
        private:
            bool enabled_{false};
            pointer data_{nullptr};
            std::vector<size_t> idle_;
            size_t maxBlockCount_{0};
            size_t blockSize_{0};
            size_t length_{0};
            size_t align_{0};
            std::int64_t lastReleaseTimeStamp_{std::numeric_limits<std::int64_t>::max()};
        private:
            Chunk* next_{nullptr};
        };
    private:
        const size_t type_size_{sizeof(value_type)};
        const size_t align_{alignof(value_type)};
        const size_t minBlockSize_ {(sizeof(value_type) + alignof(value_type) - 1) / alignof(value_type) * alignof(value_type)};
        size_t deallocateCount_{0};
        Chunk* chunk_{nullptr};
    };

    // 简易对象
    template<typename ClassName>
    class MultilingualSimpleObject : public ClassName
    {
        // 不要使用虚函数，虚表会增加内存开销
        // 不要定义成员变量
        typedef MultilingualSimpleObject<ClassName> BuiltInClass;
    public:
        template<typename... T>
        MultilingualSimpleObject(T&&... t) : ClassName(std::forward<T>(t)...) {}
//        virtual ~MultilingualSimpleObject(){}

        template<typename... T>
        static std::shared_ptr<ClassName> Create(T&&... t) {
            return std::shared_ptr<ClassName>(new BuiltInClass(t...));
        }

        static void* operator new(size_t size) {
            return Allocator<BuiltInClass>::Instance().Allocate(1);
        }

        static void operator delete (void* ptr, size_t size) {
            Allocator<BuiltInClass>::Instance().Deallocate(ptr, size);
        }
    };

}
}