single-array-allocation.hpp

/*
 * single-array-allocation.hpp
 *
 * Created on: 06 Nov 2022
 * Author: Holger Schmitz
 * Email: holger@notjustphysics.com
 *
 * Copyright 2012-2022 Holger Schmitz
 *
 * This file is part of Schnek.
 *
 * Schnek is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Schnek is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Schnek.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef SCHNEK_GRID_GRIDSTORAGE_SINGLEARRAYALLOCATION_HPP_
#define SCHNEK_GRID_GRIDSTORAGE_SINGLEARRAYALLOCATION_HPP_

#include "../array.hpp"

#include <memory>
#include <cmath>
#include <functional>
#include <map>


namespace schnek
{

    namespace internal {
        template <typename T, typename SizeInfo>
        class SingleArrayAllocationData
        {
        public:
            typedef std::function<void(const SizeInfo&)> UpdaterType;
        private:
            std::map<void*, UpdaterType> updaters;
        public:
            T *ptr;
            SingleArrayAllocationData(): ptr(NULL) {}
            ~SingleArrayAllocationData() {
                delete[] ptr;
            }

            void addUpdater(void* key, const UpdaterType &updater) {
                updaters[key] = updater;
            }

            void removeUpdater(void* key) {
                updaters.erase(key);
            }

            void update(const SizeInfo& sizeInfo) {
                for (auto& updater: updaters) {
                    updater.second(sizeInfo);
                }
            }
        };
    }

    template <typename T, size_t rank>
    class SingleArrayInstantAllocation
    {
    public:
        typedef Array<int, rank> IndexType;

        typedef Range<int, rank> RangeType;
    protected:
        struct SizeInfo {
            IndexType lo;
            IndexType hi;
        };

        typedef std::function<void()> UpdaterType;

        std::shared_ptr<internal::SingleArrayAllocationData<T, SizeInfo> > data;

        size_t size;

        RangeType range;

        IndexType dims;
    public:
        SingleArrayInstantAllocation();

        SingleArrayInstantAllocation(const SingleArrayInstantAllocation<T, rank> &);

        SingleArrayInstantAllocation<T, rank> &operator=(const SingleArrayInstantAllocation<T, rank> &);

        ~SingleArrayInstantAllocation();
    protected:
        void resizeImpl(const IndexType &lo, const IndexType &hi);

        void onUpdate(const UpdaterType &updater);

    private:
        UpdaterType updater;

        void updateSizeInfo(const SizeInfo& sizeInfo);

        void deleteData();

        void newData(const IndexType &lo, const IndexType &hi);
    };

    template <typename T, size_t rank>
    class SingleArrayLazyAllocation
    {
    public:
        typedef Array<size_t, rank> IndexType;

        typedef Range<size_t, rank> RangeType;
    protected:
        struct SizeInfo {
            IndexType lo;
            IndexType hi;
            size_t size;
            size_t bufSize;
            double avgSize;
            double avgVar;
        };


        typedef std::function<void()> UpdaterType;

        std::shared_ptr<internal::SingleArrayAllocationData<T, SizeInfo> > data;

        size_t size;

        RangeType range;

        IndexType dims;

    private:
        size_t bufSize;

        double avgSize;

        double avgVar;

        double r;

    public:
        SingleArrayLazyAllocation();

        SingleArrayLazyAllocation(const SingleArrayLazyAllocation &);

        SingleArrayLazyAllocation<T, rank> &operator=(const SingleArrayLazyAllocation<T, rank> &);

        ~SingleArrayLazyAllocation();
    protected:
        void resizeImpl(const IndexType &lo, const IndexType &hi);

        void onUpdate(const UpdaterType &updater);

    private:
        UpdaterType updater;

        void updateSizeInfo(const SizeInfo& sizeInfo);

        void deleteData();

        void newData(size_t size);
    };

    //=================================================================
    //=============== SingleArrayInstantAllocation ====================
    //=================================================================

    template <typename T, size_t rank>
    SingleArrayInstantAllocation<T, rank>::SingleArrayInstantAllocation()
        : data(new internal::SingleArrayAllocationData<T, SizeInfo>()), size(0) 
    {
        this->data->addUpdater(this, [this](const SizeInfo& sizeInfo) { this->updateSizeInfo(sizeInfo); }); 
    }

    template <typename T, size_t rank>
    SingleArrayInstantAllocation<T, rank>::SingleArrayInstantAllocation(const SingleArrayInstantAllocation<T, rank> &other)
        : data(other.data), size(other.size), range(other.range), dims(other.dims)
    {
        this->data->addUpdater(this, [this](const SizeInfo& sizeInfo) { this->updateSizeInfo(sizeInfo); }); 
    };

    template <typename T, size_t rank>
    SingleArrayInstantAllocation<T, rank> &SingleArrayInstantAllocation<T, rank>::operator=(const SingleArrayInstantAllocation<T, rank> &other) 
    {
        this->data = other.data;
        this->size = other.size;
        this->range = other.range;
        this->dims = other.dims;
        this->data->addUpdater(this, [this](const SizeInfo& sizeInfo) { this->updateSizeInfo(sizeInfo); });
        return *this;
    };

    template <typename T, size_t rank>
    SingleArrayInstantAllocation<T, rank>::~SingleArrayInstantAllocation()
    {
        this->data->removeUpdater(this);
    }

    template <typename T, size_t rank>
    void SingleArrayInstantAllocation<T, rank>::onUpdate(const UpdaterType &updater)
    {
        this->updater = updater;
    }

    template <typename T, size_t rank>
    void SingleArrayInstantAllocation<T, rank>::updateSizeInfo(const SizeInfo &sizeInfo) {
        size = 1;
        range = RangeType{sizeInfo.lo, sizeInfo.hi};

        for (size_t d = 0; d < rank; ++d)
        {
            dims[d] = sizeInfo.hi[d] - sizeInfo.lo[d] + 1;
            size *= dims[d];
        }

        if (updater) {
            updater();
        }
    }

    template <typename T, size_t rank>
    void SingleArrayInstantAllocation<T, rank>::resizeImpl(const IndexType &lo, const IndexType &hi)
    {
        this->deleteData();
        this->newData(lo, hi);
        data->update(SizeInfo{lo, hi});
    }

    template <typename T, size_t rank>
    void SingleArrayInstantAllocation<T, rank>::deleteData()
    {
        if (data->ptr)
        {
            delete[] data->ptr;
        }
        data->ptr = NULL;
        size = 0;
    }

    template <typename T, size_t rank>
    void SingleArrayInstantAllocation<T, rank>::newData(
        const IndexType &lo,
        const IndexType &hi
    )
    {
        size = 1;
        range = RangeType{lo, hi};

        for (size_t d = 0; d < rank; ++d)
        {
            dims[d] = hi[d] - lo[d] + 1;
            size *= dims[d];
        }
        data->ptr = new T[size];
    }

    //=================================================================
    //================== SingleArrayLazyAllocation ====================
    //=================================================================

    template <typename T, size_t rank>
    SingleArrayLazyAllocation<T, rank>::SingleArrayLazyAllocation()
        : data(new internal::SingleArrayAllocationData<T, SizeInfo>()), 
          size(0), 
          bufSize(0), 
          avgSize(0.0), 
          avgVar(0.0), 
          r(0.05)
    {
        this->data->addUpdater(this, [this](const SizeInfo& sizeInfo) { this->updateSizeInfo(sizeInfo); });       
    }

    template <typename T, size_t rank>
    SingleArrayLazyAllocation<T, rank>::SingleArrayLazyAllocation(const SingleArrayLazyAllocation<T, rank> &other)
        : data(other.data), 
          size(other.size), 
          range(other.range), 
          dims(other.dims), 
          bufSize(other.bufSize), 
          avgSize(other.avgSize), 
          avgVar(other.avgVar), 
          r(other.r)
    {
        this->data->addUpdater(this, [this](const SizeInfo& sizeInfo) { this->updateSizeInfo(sizeInfo); });      
    };

    template <typename T, size_t rank>
    SingleArrayLazyAllocation<T, rank> &SingleArrayLazyAllocation<T, rank>::operator=(const SingleArrayLazyAllocation<T, rank> &other) 
    {
        this->data = other.data;
        this->size = other.size;
        this->range = other.range;
        this->dims = other.dims;
        this->data->addUpdater(this, [this](const SizeInfo& sizeInfo) { this->updateSizeInfo(sizeInfo); });
        return *this;
    };


    template <typename T, size_t rank>
    SingleArrayLazyAllocation<T, rank>::~SingleArrayLazyAllocation()
    {
        this->data->removeUpdater(this);
    }

    template <typename T, size_t rank>
    void SingleArrayLazyAllocation<T, rank>::onUpdate(const UpdaterType &updater)
    {
        this->updater = updater;
    }

    template <typename T, size_t rank>
    void SingleArrayLazyAllocation<T, rank>::updateSizeInfo(const SizeInfo &sizeInfo) {
        size = 1;
        range = RangeType{sizeInfo.lo, sizeInfo.hi};

        for (size_t d = 0; d < rank; ++d)
        {
            dims[d] = sizeInfo.hi[d] - sizeInfo.lo[d] + 1;
            size *= dims[d];
        }
        bufSize = sizeInfo.bufSize;
        avgSize = sizeInfo.avgSize;
        avgVar = sizeInfo.avgVar;

        if (updater) {
            updater();
        }
    }

    template <typename T, size_t rank>
    void SingleArrayLazyAllocation<T, rank>::resizeImpl(const IndexType &lo, const IndexType &hi)
    {
        size_t newSize = 1;
        range = RangeType{lo, hi};

        for (size_t d = 0; d < rank; d++)
        {
            dims[d] = hi[d] - lo[d] + 1;
            newSize *= dims[d];
        }

        avgSize = r * newSize + (1 - r) * avgSize;
        ptrdiff_t diff = newSize - avgSize;
        avgVar = r * diff * diff + (1 - r) * avgVar;

        if ((newSize > bufSize) || (((newSize + 32.0 * sqrt(avgVar)) < bufSize) && (bufSize > 100)))
        {
            this->deleteData();
            this->newData(newSize);
        }
        size = newSize;
        this->data->update(SizeInfo{lo, hi, size, bufSize, avgSize, avgVar});
    }

    template <typename T, size_t rank>
    void SingleArrayLazyAllocation<T, rank>::deleteData()
    {
        SCHNEK_TRACE_LOG(5, "Deleting pointer (" << (void *)data << "): size=" << size << " avgSize=" << avgSize << " avgVar=" << avgVar << " bufSize=" << bufSize);
        if (data->ptr)
        {
            delete[] data->ptr;
        }
        data->ptr = NULL;
        size = 0;
        bufSize = 0;
    }

    template <typename T, size_t rank>
    void SingleArrayLazyAllocation<T, rank>::newData(
        size_t newSize)
    {
        bufSize = newSize + (size_t)(4 * sqrt(avgVar));
        if (bufSize <= 0)
        {
            bufSize = 10;
        }
        data->ptr = new T[bufSize];
    }
}

#endif // SCHNEK_GRID_GRIDSTORAGE_SINGLEARRAYALLOCATION_HPP_