#include <sys/mman.h>
#include <unistd.h>
#include <utility>


template<typename T>
struct vector_mmap_allocator {
    using value_type = T;

    vector_mmap_allocator() = default;

    ~vector_mmap_allocator()
    {
        munmap(mem1, len1);
        munmap(mem2, len2);
    }

    template<typename U>
    vector_mmap_allocator(const vector_mmap_allocator<U>& that)
    {
        munmap(mem1, len1);
        munmap(mem2, len2);

        len1 = that.len1;
        len2 = that.len2;
        mem1 = alloc(len1);
        mem2 = alloc(len2);
    }

    T* allocate(size_t n)
    {

        if (n * sizeof(value_type) > len2) {
            munmap(mem2, len2);
            len2 = round_up(n * sizeof(value_type));
            mem2 = alloc(len2);
        }

        std::swap(len1, len2);
        std::swap(mem1, mem2);

        return mem1;
    }

    void deallocate(T*, size_t)
    {
    }

private:
    static size_t PAGESIZE;

    size_t len1 = PAGESIZE;
    size_t len2 = PAGESIZE;
    T* mem1 = alloc(len1);
    T* mem2 = alloc(len2);

    static size_t round_up(size_t size)
    { return (size + PAGESIZE - 1) & ~(PAGESIZE - 1); }

    static T* alloc(size_t size)
    {
        return static_cast<T*>(mmap(NULL, size, PROT_READ | PROT_WRITE,
                                    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
    }

template <class R, class S>
friend bool operator==(const vector_mmap_allocator<R>& lhs, const vector_mmap_allocator<S>& rhs)
{ return lhs.mem1 == rhs.mem2; }
template <class R, class S>
friend bool operator!=(const vector_mmap_allocator<R>& lhs, const vector_mmap_allocator<S>& rhs)
{ return lhs.mem1 != rhs.mem2; }

};

template<typename T>
size_t vector_mmap_allocator<T>::PAGESIZE = sysconf(_SC_PAGESIZE);