page_evictioner_filter.hpp

Go to the documentation of this file.

#ifndef __PAGE_EVICTIONER_FILTER_HPP
#define __PAGE_EVICTIONER_FILTER_HPP

#include <vector>
#include <atomic>

#include "buffer_pool.hpp"
#include "btree_page_h.h"

namespace zero::buffer_pool {

    class PageEvictionerFilter {
    protected:
        explicit PageEvictionerFilter(const BufferPool* bufferPool) {};

    public:
        virtual ~PageEvictionerFilter() {};

        virtual bool filter(bf_idx idx) const noexcept = 0;

        virtual bool filterAndUpdate(bf_idx idx) noexcept = 0;

        virtual void updateOnPageHit(bf_idx idx) noexcept = 0;

        virtual void updateOnPageUnfix(bf_idx idx) noexcept = 0;

        virtual void updateOnPageMiss(bf_idx idx, PageID pid) noexcept = 0;

        virtual void updateOnPageFixed(bf_idx idx) noexcept = 0;

        virtual void updateOnPageDirty(bf_idx idx) noexcept = 0;

        virtual void updateOnPageBlocked(bf_idx idx) noexcept = 0;

        virtual void updateOnPageSwizzled(bf_idx idx) noexcept = 0;

        virtual void updateOnPageExplicitlyUnbuffered(bf_idx idx) noexcept = 0;

        virtual void updateOnPointerSwizzling(bf_idx idx) noexcept = 0;

        virtual void releaseInternalLatches() noexcept = 0;
    };

    class PageEvictionerFilterNone : public PageEvictionerFilter {
    public:
        explicit PageEvictionerFilterNone(const BufferPool* bufferPool) :
                PageEvictionerFilter(bufferPool) {};

        inline bool filter(bf_idx idx) const noexcept final {
            return true;
        };

        inline bool filterAndUpdate(bf_idx idx) noexcept final {
            return true;
        };

        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 updateOnPointerSwizzling(bf_idx idx) noexcept final {};

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

    template<bool on_hit /*= true*/, bool on_unfix /*= false*/, bool on_miss /*= true*/, bool on_fixed /*= false*/, bool on_dirty /*= false*/, bool on_blocked /*= false*/, bool on_swizzled /*= false*/>
    class PageEvictionerFilterCLOCK : public PageEvictionerFilter {
    public:
        explicit PageEvictionerFilterCLOCK(const BufferPool* bufferPool) :
                PageEvictionerFilter(bufferPool),
                _refBits(bufferPool->getBlockCount()) {};

        inline bool filter(bf_idx idx) const noexcept final {
            if (_refBits[idx]) {
                return false;
            } else {
                return true;
            }
        };

        inline bool filterAndUpdate(bf_idx idx) noexcept final {
            if (_refBits[idx]) {
                _refBits[idx] = false;
                return false;
            } else {
                return true;
            }
        };

        inline void updateOnPageHit(bf_idx idx) noexcept final {
            if constexpr (on_hit) {
                _refBits[idx] = true;
            }
        };

        inline void updateOnPageUnfix(bf_idx idx) noexcept final {
            if constexpr (on_unfix) {
                _refBits[idx] = true;
            }
        };

        inline void updateOnPageMiss(bf_idx b_idx, PageID pid) noexcept final {
            if constexpr (on_miss) {
                _refBits[b_idx] = true;
            }
        };

        inline void updateOnPageFixed(bf_idx idx) noexcept final {
            if constexpr (on_fixed) {
                _refBits[idx] = true;
            }
        };

        inline void updateOnPageDirty(bf_idx idx) noexcept final {
            if constexpr (on_dirty) {
                _refBits[idx] = true;
            }
        };

        inline void updateOnPageBlocked(bf_idx idx) noexcept final {
            if constexpr (on_blocked) {
                _refBits[idx] = true;
            }
        };

        inline void updateOnPageSwizzled(bf_idx idx) noexcept final {
            if constexpr (on_swizzled) {
                _refBits[idx] = true;
            }
        };

        inline void updateOnPageExplicitlyUnbuffered(bf_idx idx) noexcept final {
            _refBits[idx] = true;
        };

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

        inline void releaseInternalLatches() noexcept final {};

    private:
        std::vector<std::atomic<bool>> _refBits;
    };

    template<uint16_t decrement/* = 1*/, bool discriminate_pages/* = false*/,
            bool on_hit/* = true*/, bool set_on_hit/* = false*/, uint16_t level0_on_hit/* = 5*/, uint16_t level1_on_hit/* = 2*/, uint16_t level2_on_hit/* = 1*/,
            bool on_unfix/* = false*/, bool set_on_unfix/* = false*/, uint16_t level0_on_unfix/* = 5*/, uint16_t level1_on_unfix/* = 2*/, uint16_t level2_on_unfix/* = 1*/,
            bool on_miss/* = true*/, bool set_on_miss/* = true*/, uint16_t level0_on_miss/* = 25*/, uint16_t level1_on_miss/* = 10*/, uint16_t level2_on_miss/* = 5*/,
            bool on_fixed/* = false*/, bool set_on_fixed/* = false*/, uint16_t level0_on_fixed/* = 5*/, uint16_t level1_on_fixed/* = 2*/, uint16_t level2_on_fixed/* = 1*/,
            bool on_dirty/* = false*/, bool set_on_dirty/* = false*/, uint16_t level0_on_dirty/* = 5*/, uint16_t level1_on_dirty/* = 2*/, uint16_t level2_on_dirty/* = 1*/,
            bool on_blocked/* = false*/, bool set_on_blocked/* = false*/, uint16_t level0_on_blocked/* = 5*/, uint16_t level1_on_blocked/* = 2*/, uint16_t level2_on_blocked/* = 1*/,
            bool on_swizzled/* = false*/, bool set_on_swizzled/* = false*/, uint16_t level0_on_swizzled/* = 5*/, uint16_t level1_on_swizzled/* = 2*/, uint16_t level2_on_swizzled/* = 1*/>
    class PageEvictionerFilterGCLOCK : PageEvictionerFilter {
    public:
        explicit PageEvictionerFilterGCLOCK(const BufferPool* bufferPool) :
                PageEvictionerFilter(bufferPool),
                _refInts(bufferPool->getBlockCount()) {};

        inline bool filter(bf_idx idx) const noexcept final {
            if (_refInts[idx] > 0) {
                return false;
            } else {
                return true;
            }
        };

        inline bool filterAndUpdate(bf_idx idx) noexcept final {
            if (_refInts[idx] > 0) {
                _refInts[idx] = std::max(_refInts[idx] - decrement, 0);
                return false;
            } else {
                return true;
            }
        };

        inline void updateOnPageHit(bf_idx idx) noexcept final {
            if constexpr (on_hit) {
                if constexpr (discriminate_pages) {
                    uint8_t page_level = getLevel(idx);
                    if constexpr (set_on_hit) {
                        if (page_level == 0) {
                            _refInts[idx] = level0_on_hit;
                        } else if (page_level == 1) {
                            _refInts[idx] = level1_on_hit;
                        } else {
                            _refInts[idx] = level2_on_hit;
                        }
                    } else {
                        if (page_level == 0) {
                            _refInts[idx] += level0_on_hit;
                        } else if (page_level == 1) {
                            _refInts[idx] += level1_on_hit;
                        } else {
                            _refInts[idx] += level2_on_hit;
                        }
                    }
                } else {
                    if constexpr (set_on_hit) {
                        _refInts[idx] = level2_on_hit;
                    } else {
                        _refInts[idx] += level2_on_hit;
                    }
                }
            }
        };

        inline void updateOnPageUnfix(bf_idx idx) noexcept final {
            if constexpr (on_unfix) {
                if constexpr (discriminate_pages) {
                    uint8_t page_level = getLevel(idx);
                    if constexpr (set_on_unfix) {
                        if (page_level == 0) {
                            _refInts[idx] = level0_on_unfix;
                        } else if (page_level == 1) {
                            _refInts[idx] = level1_on_unfix;
                        } else {
                            _refInts[idx] = level2_on_unfix;
                        }
                    } else {
                        if (page_level == 0) {
                            _refInts[idx] += level0_on_unfix;
                        } else if (page_level == 1) {
                            _refInts[idx] += level1_on_unfix;
                        } else {
                            _refInts[idx] += level2_on_unfix;
                        }
                    }
                } else {
                    if constexpr (set_on_unfix) {
                        _refInts[idx] = level2_on_unfix;
                    } else {
                        _refInts[idx] += level2_on_unfix;
                    }
                }
            }
        };

        inline void updateOnPageMiss(bf_idx b_idx, PageID pid) noexcept final {
            if constexpr (on_miss) {
                if constexpr (discriminate_pages) {
                    uint8_t page_level = getLevel(b_idx);
                    if constexpr (set_on_miss) {
                        if (page_level == 0) {
                            _refInts[b_idx] = level0_on_miss;
                        } else if (page_level == 1) {
                            _refInts[b_idx] = level1_on_miss;
                        } else {
                            _refInts[b_idx] = level2_on_miss;
                        }
                    } else {
                        if (page_level == 0) {
                            _refInts[b_idx] += level0_on_miss;
                        } else if (page_level == 1) {
                            _refInts[b_idx] += level1_on_miss;
                        } else {
                            _refInts[b_idx] += level2_on_miss;
                        }
                    }
                } else {
                    if constexpr (set_on_miss) {
                        _refInts[b_idx] = level2_on_miss;
                    } else {
                        _refInts[b_idx] += level2_on_miss;
                    }
                }
            }
        };

        inline void updateOnPageFixed(bf_idx idx) noexcept final {
            if constexpr (on_fixed) {
                if constexpr (discriminate_pages) {
                    uint8_t page_level = getLevel(idx);
                    if constexpr (set_on_fixed) {
                        if (page_level == 0) {
                            _refInts[idx] = level0_on_fixed;
                        } else if (page_level == 1) {
                            _refInts[idx] = level1_on_fixed;
                        } else {
                            _refInts[idx] = level2_on_fixed;
                        }
                    } else {
                        if (page_level == 0) {
                            _refInts[idx] += level0_on_fixed;
                        } else if (page_level == 1) {
                            _refInts[idx] += level1_on_fixed;
                        } else {
                            _refInts[idx] += level2_on_fixed;
                        }
                    }
                } else {
                    if constexpr (set_on_fixed) {
                        _refInts[idx] = level2_on_fixed;
                    } else {
                        _refInts[idx] += level2_on_fixed;
                    }
                }
            }
        };

        inline void updateOnPageDirty(bf_idx idx) noexcept final {
            if constexpr (on_dirty) {
                if constexpr (discriminate_pages) {
                    uint8_t page_level = getLevel(idx);
                    if constexpr (set_on_dirty) {
                        if (page_level == 0) {
                            _refInts[idx] = level0_on_dirty;
                        } else if (page_level == 1) {
                            _refInts[idx] = level1_on_dirty;
                        } else {
                            _refInts[idx] = level2_on_dirty;
                        }
                    } else {
                        if (page_level == 0) {
                            _refInts[idx] += level0_on_dirty;
                        } else if (page_level == 1) {
                            _refInts[idx] += level1_on_dirty;
                        } else {
                            _refInts[idx] += level2_on_dirty;
                        }
                    }
                } else {
                    if constexpr (set_on_dirty) {
                        _refInts[idx] = level2_on_dirty;
                    } else {
                        _refInts[idx] += level2_on_dirty;
                    }
                }
            }
        };

        inline void updateOnPageBlocked(bf_idx idx) noexcept final {
            if constexpr (on_blocked) {
                if constexpr (discriminate_pages) {
                    uint8_t page_level = getLevel(idx);
                    if constexpr (set_on_blocked) {
                        if (page_level == 0) {
                            _refInts[idx] = level0_on_blocked;
                        } else if (page_level == 1) {
                            _refInts[idx] = level1_on_blocked;
                        } else {
                            _refInts[idx] = level2_on_blocked;
                        }
                    } else {
                        if (page_level == 0) {
                            _refInts[idx] += level0_on_blocked;
                        } else if (page_level == 1) {
                            _refInts[idx] += level1_on_blocked;
                        } else {
                            _refInts[idx] += level2_on_blocked;
                        }
                    }
                } else {
                    if constexpr (set_on_blocked) {
                        _refInts[idx] = level2_on_blocked;
                    } else {
                        _refInts[idx] += level2_on_blocked;
                    }
                }
            }
        };

        inline void updateOnPageSwizzled(bf_idx idx) noexcept final {
            if constexpr (on_swizzled) {
                if constexpr (discriminate_pages) {
                    uint8_t page_level = getLevel(idx);
                    if constexpr (set_on_swizzled) {
                        if (page_level == 0) {
                            _refInts[idx] = level0_on_swizzled;
                        } else if (page_level == 1) {
                            _refInts[idx] = level1_on_swizzled;
                        } else {
                            _refInts[idx] = level2_on_swizzled;
                        }
                    } else {
                        if (page_level == 0) {
                            _refInts[idx] += level0_on_swizzled;
                        } else if (page_level == 1) {
                            _refInts[idx] += level1_on_swizzled;
                        } else {
                            _refInts[idx] += level2_on_swizzled;
                        }
                    }
                } else {
                    if constexpr (set_on_swizzled) {
                        _refInts[idx] = level2_on_swizzled;
                    } else {
                        _refInts[idx] += level2_on_swizzled;
                    }
                }
            }
        };

        inline void updateOnPageExplicitlyUnbuffered(bf_idx idx) noexcept final {
            _refInts[idx] = std::numeric_limits<uint16_t>::max();
        };

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

        inline void releaseInternalLatches() noexcept final {};

    private:
        inline uint8_t getLevel(const bf_idx& idx) const {
            const generic_page* page = smlevel_0::bf->getPage(idx);
            w_assert1(page != nullptr);
            if (page->tag == t_btree_p) {
                btree_page_h fixedPage;
                fixedPage.fix_nonbufferpool_page(const_cast<generic_page*>(page));
                if (fixedPage.pid() == fixedPage.btree_root() || fixedPage.level() > 2) {
                    return 0;
                } else if (fixedPage.level() == 2) {
                    return 1;
                } else if (fixedPage.level() == 1) {
                    return 2;
                }
            } else {     // Non-B-Tree pages are interpreted as B-Tree root pages!
                return 0;
            }
        };

        std::vector<std::atomic<uint16_t>> _refInts;
    };
} // zero::buffer_pool

#endif // __PAGE_EVICTIONER_FILTER_HPP