page_evictioner_selector_random.hpp

Go to the documentation of this file.

#ifndef __PAGE_EVICTIONER_SELECTOR_RANDOM_HPP
#define __PAGE_EVICTIONER_SELECTOR_RANDOM_HPP

#include "page_evictioner_selector.hpp"

#include <random>
#include <cstdlib>
#include <ctime>
#include <chrono>

namespace zero::buffer_pool {

    struct SeedGenerator {
    private:
        SeedGenerator() {};
    };

    template<typename seed_type>
    struct SeedGeneratorChrono : public SeedGenerator {
#if __SIZEOF_INT128__
        static_assert(std::is_same<seed_type, uint32_t>::value
                      || std::is_same<seed_type, uint64_t>::value
                      || std::is_same<seed_type, __uint128_t>::value, "'seed_type' is of unsupported type!");
#else // __SIZEOF_INT128__
        static_assert(std::is_same<seed_type, uint32_t>::value
                   || std::is_same<seed_type, uint64_t>::value, "'seed_type' is of unsupported type!");
#endif // __SIZEOF_INT128__

    private:
        static seed_type getSeed() noexcept {};
    };

    template<>
    struct SeedGeneratorChrono<uint32_t> {
        static inline uint32_t getSeed() noexcept {
            return static_cast<uint32_t>(chrono::high_resolution_clock::now().time_since_epoch().count());
        };
    };

    template<>
    struct SeedGeneratorChrono<uint64_t> {
        static inline uint64_t getSeed() noexcept {
            return static_cast<uint64_t>(chrono::high_resolution_clock::now().time_since_epoch().count());
        };
    };

#if __SIZEOF_INT128__

    template<>
    struct SeedGeneratorChrono<__uint128_t> {
        static inline __uint128_t getSeed() noexcept {
            return (static_cast<__uint128_t>(chrono::high_resolution_clock::now().time_since_epoch().count()) << 64)
                   + chrono::high_resolution_clock::now().time_since_epoch().count();
        };
    };

#endif // __SIZEOF_INT128__

    template<typename seed_type>
    struct SeedGeneratorRandomDevice : public SeedGenerator {
#if __SIZEOF_INT128__
        static_assert(std::is_same<seed_type, uint32_t>::value
                      || std::is_same<seed_type, uint64_t>::value
                      || std::is_same<seed_type, __uint128_t>::value, "'seed_type' is of unsupported type!");
#else // __SIZEOF_INT128__
        static_assert(std::is_same<seed_type, uint32_t>::value
                   || std::is_same<seed_type, uint64_t>::value, "'seed_type' is of unsupported type!");
#endif // __SIZEOF_INT128__

    private:
        static seed_type getSeed() noexcept {};
    };

    template<>
    struct SeedGeneratorRandomDevice<uint32_t> {
        static inline uint32_t getSeed() noexcept {
            std::random_device randomDevice;

            return randomDevice();
        };
    };

    template<>
    struct SeedGeneratorRandomDevice<uint64_t> {
        static inline uint64_t getSeed() noexcept {
            std::random_device randomDevice;

            return ((static_cast<uint64_t>(randomDevice()) << 32) | static_cast<uint64_t>(randomDevice()));
        };
    };

#if __SIZEOF_INT128__

    template<>
    struct SeedGeneratorRandomDevice<__uint128_t> {
        static inline __uint128_t getSeed() noexcept {
            std::random_device randomDevice;

            return (static_cast<__uint128_t>((static_cast<uint64_t>(randomDevice()) << 32)
                                             | static_cast<uint64_t>(randomDevice())) << 64)
                   + ((static_cast<uint64_t>(randomDevice()) << 32) | static_cast<uint64_t>(randomDevice()));
        };
    };

#endif // __SIZEOF_INT128__

    template<class random_number_generator, class random_distribution, class ... seed_generators>
    class PageEvictionerSelectorRANDOMExternal : public PageEvictionerSelector {
    public:
        explicit PageEvictionerSelectorRANDOMExternal(const BufferPool* bufferPool) :
                PageEvictionerSelector(bufferPool),
                _randomNumberGenerator(seed_generators::getSeed() ...),
                _randomDistribution(1, _maxBufferpoolIndex) {};

        inline bf_idx select() noexcept final {
            return static_cast<bf_idx>(_randomDistribution(_randomNumberGenerator));
        };

        inline void updateOnPageHit(bf_idx idx) noexcept final {};

        inline void updateOnPageUnfix(bf_idx idx) noexcept final {};

        inline void updateOnPageMiss(bf_idx idx, PageID pid) noexcept final {};

        inline void updateOnPageFixed(bf_idx idx) noexcept final {};

        inline void updateOnPageDirty(bf_idx idx) noexcept final {};

        inline void updateOnPageBlocked(bf_idx idx) noexcept final {};

        inline void updateOnPageSwizzled(bf_idx idx) noexcept final {};

        inline void updateOnPageExplicitlyUnbuffered(bf_idx idx) noexcept final {};

        inline void releaseInternalLatches() noexcept final {};

        void updateOnPointerSwizzling(bf_idx idx) noexcept final {};

    private:
        random_number_generator _randomNumberGenerator;

        random_distribution _randomDistribution;
    };

    template<class random_number_generator, class random_distribution, bool seed_explicitly, class ... seed_generators>
    class PageEvictionerSelectorRANDOMExternalThreadLocal : public PageEvictionerSelector {
    public:
        explicit PageEvictionerSelectorRANDOMExternalThreadLocal(const BufferPool* bufferPool) :
                PageEvictionerSelector(bufferPool),
                _randomDistribution(1, _maxBufferpoolIndex) {};

        inline bf_idx select() noexcept final {

            static thread_local bool _randomNumberGeneratorInitialized;

            static thread_local random_number_generator _randomNumberGenerator;

            if constexpr (seed_explicitly) {
                if (!_randomNumberGeneratorInitialized) {
                    _randomNumberGenerator = random_number_generator(seed_generators::getSeed() ...);
                    _randomNumberGeneratorInitialized = true;
                }
            }

            return static_cast<bf_idx>(_randomDistribution(_randomNumberGenerator));
        };

        inline void updateOnPageHit(bf_idx idx) noexcept final {};

        inline void updateOnPageUnfix(bf_idx idx) noexcept final {};

        inline void updateOnPageMiss(bf_idx idx, PageID pid) noexcept final {};

        inline void updateOnPageFixed(bf_idx idx) noexcept final {};

        inline void updateOnPageDirty(bf_idx idx) noexcept final {};

        inline void updateOnPageBlocked(bf_idx idx) noexcept final {};

        inline void updateOnPageSwizzled(bf_idx idx) noexcept final {};

        inline void updateOnPageExplicitlyUnbuffered(bf_idx idx) noexcept final {};

        void updateOnPointerSwizzling(bf_idx idx) noexcept final {};

        inline void releaseInternalLatches() noexcept final {};

    private:
        std::uniform_int_distribution<bf_idx> _randomDistribution;
    };

    template<class random_number_generator, class ... seed_generators>
    class PageEvictionerSelectorRANDOMCLHEP : public PageEvictionerSelector {
    public:
        explicit PageEvictionerSelectorRANDOMCLHEP(const BufferPool* bufferPool) :
                PageEvictionerSelector(bufferPool),
                _randomNumberGenerator(seed_generators::getSeed() ...) {};

        inline bf_idx select() noexcept final {
            return static_cast<uint32_t>(((uint32_t(_randomNumberGenerator)) % (_maxBufferpoolIndex - 1) + 1));
        };

        inline void updateOnPageHit(bf_idx idx) noexcept final {};

        inline void updateOnPageUnfix(bf_idx idx) noexcept final {};

        inline void updateOnPageMiss(bf_idx idx, PageID pid) noexcept final {};

        inline void updateOnPageFixed(bf_idx idx) noexcept final {};

        inline void updateOnPageDirty(bf_idx idx) noexcept final {};

        inline void updateOnPageBlocked(bf_idx idx) noexcept final {};

        inline void updateOnPageSwizzled(bf_idx idx) noexcept final {};

        inline void updateOnPageExplicitlyUnbuffered(bf_idx idx) noexcept final {};

        void updateOnPointerSwizzling(bf_idx idx) noexcept final {};

        inline void releaseInternalLatches() noexcept final {};

    private:
        random_number_generator _randomNumberGenerator;
    };

    template<class random_number_generator, bool seed_explicitly, class ... seed_generators>
    class PageEvictionerSelectorRANDOMCLHEPThreadLocal : public PageEvictionerSelector {
    public:
        explicit PageEvictionerSelectorRANDOMCLHEPThreadLocal(const BufferPool* bufferPool) :
                PageEvictionerSelector(bufferPool) {};

        inline bf_idx select() noexcept final {

            static thread_local bool _randomNumberGeneratorInitialized;

            static thread_local random_number_generator _randomNumberGenerator;

            if constexpr (seed_explicitly) {
                if (!_randomNumberGeneratorInitialized) {
                    _randomNumberGenerator = random_number_generator(seed_generators::getSeed() ...);
                    _randomNumberGeneratorInitialized = true;
                }
            }

            return static_cast<uint32_t>(((uint32_t(_randomNumberGenerator)) % (_maxBufferpoolIndex - 1) + 1));
        };

        inline void updateOnPageHit(bf_idx idx) noexcept final {};

        inline void updateOnPageUnfix(bf_idx idx) noexcept final {};

        inline void updateOnPageMiss(bf_idx idx, PageID pid) noexcept final {};

        inline void updateOnPageFixed(bf_idx idx) noexcept final {};

        inline void updateOnPageDirty(bf_idx idx) noexcept final {};

        inline void updateOnPageBlocked(bf_idx idx) noexcept final {};

        inline void updateOnPageSwizzled(bf_idx idx) noexcept final {};

        inline void updateOnPageExplicitlyUnbuffered(bf_idx idx) noexcept final {};

        void updateOnPointerSwizzling(bf_idx idx) noexcept final {};

        inline void releaseInternalLatches() noexcept final {};
    };

    class PageEvictionerSelectorRANDOMCRand : public PageEvictionerSelector {
    public:
        explicit PageEvictionerSelectorRANDOMCRand(const BufferPool* bufferPool) :
                PageEvictionerSelector(bufferPool) {
            std::srand(std::time(nullptr));
        };

        inline bf_idx select() noexcept final {
            return 1 + std::rand() / ((RAND_MAX + 1u) / _maxBufferpoolIndex);
        };

        inline void updateOnPageHit(bf_idx idx) noexcept final {};

        inline void updateOnPageUnfix(bf_idx idx) noexcept final {};

        inline void updateOnPageMiss(bf_idx idx, PageID pid) noexcept final {};

        inline void updateOnPageFixed(bf_idx idx) noexcept final {};

        inline void updateOnPageDirty(bf_idx idx) noexcept final {};

        inline void updateOnPageBlocked(bf_idx idx) noexcept final {};

        inline void updateOnPageSwizzled(bf_idx idx) noexcept final {};

        inline void updateOnPageExplicitlyUnbuffered(bf_idx idx) noexcept final {};

        void updateOnPointerSwizzling(bf_idx idx) noexcept final {};

        inline void releaseInternalLatches() noexcept final {};
    };

    class PageEvictionerSelectorRANDOMXORWow : public PageEvictionerSelector {
    public:
        explicit PageEvictionerSelectorRANDOMXORWow(const BufferPool* bufferPool) :
                PageEvictionerSelector(bufferPool) {};

        inline bf_idx select() noexcept final {

            static thread_local bool _seedInitialized;

            static thread_local uint32_t _x;

            static thread_local uint32_t _y;

            static thread_local uint32_t _z;

            static thread_local uint32_t _w;

            static thread_local uint32_t _v;

            static thread_local uint32_t _d;

            if (!_seedInitialized) {
                _x = std::random_device{}();
                _y = std::random_device{}();
                _z = std::random_device{}();
                _w = std::random_device{}();
                _v = std::random_device{}();
                _d = std::random_device{}();
                _seedInitialized = true;
            }
            uint32_t t = _x ^(_x >> 2);
            _x = _y;
            _y = _z;
            _z = _w;
            _w = _v;
            _v = (_v ^ (_v << 4)) ^ (t ^ (t << 1));

            return (((_d += 362437) + _v) % (_maxBufferpoolIndex - 1) + 1);
        };

        inline void updateOnPageHit(bf_idx idx) noexcept final {};

        inline void updateOnPageUnfix(bf_idx idx) noexcept final {};

        inline void updateOnPageMiss(bf_idx idx, PageID pid) noexcept final {};

        inline void updateOnPageFixed(bf_idx idx) noexcept final {};

        inline void updateOnPageDirty(bf_idx idx) noexcept final {};

        inline void updateOnPageBlocked(bf_idx idx) noexcept final {};

        inline void updateOnPageSwizzled(bf_idx idx) noexcept final {};

        inline void updateOnPageExplicitlyUnbuffered(bf_idx idx) noexcept final {};

        void updateOnPointerSwizzling(bf_idx idx) noexcept final {};

        inline void releaseInternalLatches() noexcept final {};
    };

    class PageEvictionerSelectorRANDOMXORShift128Plus : public PageEvictionerSelector {
    public:
        explicit PageEvictionerSelectorRANDOMXORShift128Plus(const BufferPool* bufferPool) :
                PageEvictionerSelector(bufferPool) {};

        inline bf_idx select() noexcept final {

            static thread_local bool _seedInitialized;

            static thread_local uint64_t _seed0;

            static thread_local uint64_t _seed1;

            if (!_seedInitialized) {
                _seed0 = std::random_device{}();
                _seed1 = std::random_device{}();
                _seedInitialized = true;
            }
            uint64_t x = _seed0;
            uint64_t const y = _seed1;
            _seed0 = y;
            x ^= x << 23;
            _seed1 = x ^ y ^ (x >> 17) ^ (y >> 26);
            return ((_seed1 + y) % (_maxBufferpoolIndex - 1) + 1);
        };

        inline void updateOnPageHit(bf_idx idx) noexcept final {};

        inline void updateOnPageUnfix(bf_idx idx) noexcept final {};

        inline void updateOnPageMiss(bf_idx idx, PageID pid) noexcept final {};

        inline void updateOnPageFixed(bf_idx idx) noexcept final {};

        inline void updateOnPageDirty(bf_idx idx) noexcept final {};

        inline void updateOnPageBlocked(bf_idx idx) noexcept final {};

        inline void updateOnPageSwizzled(bf_idx idx) noexcept final {};

        inline void updateOnPageExplicitlyUnbuffered(bf_idx idx) noexcept final {};

        void updateOnPointerSwizzling(bf_idx idx) noexcept final {};

        inline void releaseInternalLatches() noexcept final {};
    };
} // zero::buffer_pool

#endif // __PAGE_EVICTIONER_SELECTOR_RANDOM_HPP