buffer_pool.hpp

Go to the documentation of this file.

/*
 * (c) Copyright 2011-2014, Hewlett-Packard Development Company, LP
 */

#ifndef __SM_BUFFER_POOL_HPP
#define __SM_BUFFER_POOL_HPP

#include "w_defines.h"
#include "bf_tree_cb.h"
#include "latch.h"
#include "vol.h"
#include "generic_page.h"
#include <iosfwd>
#include "buffer_pool_free_list.hpp"
#include "page_cleaner.h"
#include "page_evictioner.hpp"
#include "restart.h"
#include "restore.h"

#include <array>
#include "buffer_pool_hashtable.hpp"
#include "page_evictioner_typedefs.hpp"
#include "buffer_pool_pointer_swizzling.hpp"

#include "boost/align/aligned_allocator.hpp"

class sm_options;
class lsn_t;
class test_bf_tree;
class bf_tree_cleaner;
class btree_page_h;
class GenericPageIterator;

namespace zero::buffer_pool {

    class BufferPool {
        friend class ::test_bf_tree; // for testcases
        friend class ::bf_tree_cleaner; // for page cleaning
        friend class page_cleaner_decoupled; // for log-based "decoubled" page cleaning
        friend class ::GenericPageIterator;
    friend class FreeListLowContention;
    friend class FreeListHighContention;
    friend class PageEvictioner;

        template<class selector_class, class filter_class, bool filter_early> friend class PageEvictionerSelectAndFilter;

    public:
        BufferPool();

        void postInitialize();

        void shutdown();

        ~BufferPool();

        inline bf_idx getBlockCount() const noexcept {
            return _blockCount;
        };

        inline bool isNoDBMode() const noexcept {
            return _noDBMode;
        }

        inline bool usesWriteElision() const noexcept {
            return _useWriteElision;
        }

        inline bool isWarmupDone() const noexcept {
            return _warmupDone;
        }

        inline const std::shared_ptr<zero::buffer_pool::Hashtable> getHashtable() const noexcept {
            return _hashtable;
        };

        inline const std::shared_ptr<zero::buffer_pool::FreeListLowContention> getFreeList() const noexcept {
            return _freeList;
        };

        inline const std::shared_ptr<page_cleaner_base> getPageCleaner() const noexcept {
            return _cleaner;
        };

        inline void wakeupPageCleaner() const {
            if (_cleaner) {
                _cleaner->wakeup(true, 1);
            }
        };

        const std::shared_ptr<PAGE_EVICTIONER> getPageEvictioner() const noexcept;

        bool hasDirtyFrames();

        void fixRoot(generic_page*& targetPage, StoreID store, latch_mode_t latchMode, bool conditional, bool virgin);

        w_rc_t fixRootOldStyleExceptions(generic_page*& targetPage, StoreID store, latch_mode_t latchMode,
                                         bool conditional, bool virgin);

        bool fixNonRoot(generic_page*& targetPage, generic_page* parentPage, PageID pid, latch_mode_t latchMode,
                        bool conditional = false, bool virgin = false, bool onlyIfHit = false, bool doRecovery = true,
                        lsn_t emlsn = lsn_t::null);

        w_rc_t fixNonRootOldStyleExceptions(generic_page*& targetPage, generic_page* parentPage, PageID pid,
                                            latch_mode_t latchMode, bool conditional = false, bool virgin = false,
                                            bool onlyIfHit = false, bool doRecovery = true, lsn_t emlsn = lsn_t::null);

        bf_idx pinForRefix(const generic_page* pinPage);

        void refixDirect(generic_page*& targetPage, bf_idx refixIndex, latch_mode_t latchMode, bool conditional);

        w_rc_t refixDirectOldSytleExceptions(generic_page*& targetPage, bf_idx refixIndex, latch_mode_t latchMode,
                                             bool conditional);

        void unpinForRefix(bf_idx unpinIndex);

        void unfix(const generic_page* unfixPage, bool evict = false);

        bf_tree_cb_t& getControlBlock(bf_idx index) noexcept {
            return _controlBlocks[index];
        };

        const bf_tree_cb_t& getControlBlock(bf_idx index) const noexcept {
            return _controlBlocks[index];
        };

        bf_tree_cb_t& getControlBlock(const generic_page* page) noexcept {
            return getControlBlock(getIndex(page));
        };

        bf_idx getIndex(const bf_tree_cb_t& controlBlock) const noexcept {
            return std::distance(_controlBlocks.data(), &controlBlock);
        };

        bf_idx getIndex(const generic_page* page) const noexcept {
            return static_cast<bf_idx>(page - _buffer);
        };

        bf_idx getRootIndex(StoreID store) const noexcept {
            bf_idx rootIndex = _rootPages[store];
            if (!isValidIndex(rootIndex)) {
                return 0;
            } else {
                return rootIndex;
            }
        };

        generic_page* getPage(const bf_idx& index) noexcept {
            w_assert1(isValidIndex(index));
            return &_buffer[index];
        };

        const generic_page* getPage(const bf_idx& index) const noexcept {
            w_assert1(isValidIndex(index));
            return &_buffer[index];
        };

        bool isValidIndex(bf_idx index) const noexcept {
            return index > 0 && index < _blockCount;
        };

        bool isActiveIndex(bf_idx index) const noexcept {
            return isValidIndex(index) && getControlBlock(index)._used;
        };

        bool upgradeLatchConditional(const generic_page* page) noexcept;

        void downgradeLatch(const generic_page* page) noexcept;

        bool unswizzlePagePointer(generic_page* parentPage, general_recordid_t childSlotInParentPage,
                                  PageID* childPageID = nullptr);

        PageID normalizePID(const PageID pid) const noexcept {
            if constexpr (POINTER_SWIZZLER::usesPointerSwizzling) {
                if (POINTER_SWIZZLER::isSwizzledPointer(pid)) {
                    bf_idx index = POINTER_SWIZZLER::makeBufferIndex(pid);
                    w_assert1(isValidIndex(index));
                    const bf_tree_cb_t& controlBlock = getControlBlock(index);
                    w_assert1(!POINTER_SWIZZLER::isSwizzledPointer(controlBlock._pid));
                    return controlBlock._pid;
                } else {
                    return pid;
                }
            } else {
                return pid;
            }
        };

        bool isEvictable(const bf_idx indexToCheck, const bool doFlushIfDirty) noexcept;

        void batchPrefetch(PageID startPID, bf_idx numberOfPages) noexcept;

        void recoverIfNeeded(bf_tree_cb_t& controlBlock, generic_page* page, bool onlyIfDirty = true) noexcept;

        void fuzzyCheckpoint(chkpt_t& checkpoint) const noexcept;

        void sxUpdateChildEMLSN(btree_page_h& parentPage, general_recordid_t childSlotID, lsn_t childEMLSN) const;

        void switchParent(PageID childPID, generic_page* newParentPage) noexcept;

        void setMediaFailure() noexcept;

        void unsetMediaFailure() noexcept;

        PageID getMediaFailurePID() const noexcept {
            return _mediaFailurePID;
        };

        bool isMediaFailure() const noexcept {
            return _mediaFailurePID > 0;
        };

        bool isMediaFailure(PageID pid) const noexcept {
            return _mediaFailurePID > 0 && pid < _mediaFailurePID;
        };

        void debugDump(std::ostream& o) const;

        void debugDumpPagePointers(std::ostream& o, generic_page* page) const;

    private:
        bf_idx _blockCount;

        // CS TODO: concurrency???
        std::array<bf_idx, stnode_page::max> _rootPages;

        std::vector<bf_tree_cb_t, boost::alignment::aligned_allocator<bf_tree_cb_t, sizeof(bf_tree_cb_t)>>
                _controlBlocks;

        generic_page* _buffer;

        std::shared_ptr<Hashtable> _hashtable;

        std::shared_ptr<FreeListLowContention> _freeList;

        std::shared_ptr<page_cleaner_base> _cleaner;

        bool _cleanerDecoupled;

        std::shared_ptr<PAGE_EVICTIONER> _evictioner;

        bool _asyncEviction;

        bool _maintainEMLSN;

        static thread_local SprIterator _localSprIter;

        using RestoreCoord = RestoreCoordinator<std::function<decltype(SegmentRestorer::bf_restore)>>;

        std::shared_ptr<RestoreCoord> _restoreCoordinator;

        using BgRestorer = BackgroundRestorer<RestoreCoord, std::function<void(void)>>;

        std::shared_ptr<BgRestorer> _backgroundRestorer;

        bool _useWriteElision;

        std::atomic<PageID> _mediaFailurePID;

        bool _instantRestore;

        bool _noDBMode;

        bool _logFetches;

        size_t _batchSegmentSize;

        bool _batchWarmup;

        bool _warmupDone;

        double _warmupHitRatio;

        unsigned _warmupMinFixes;

        static thread_local unsigned _fixCount;

        static thread_local unsigned _hitCount;

        bool _fix(generic_page* parentPage, generic_page*& targetPage, PageID pid, latch_mode_t latchMode,
                  bool conditional, bool virgin, bool onlyIfHit = false, bool doRecovery = true,
                  lsn_t emlsn = lsn_t::null);

        void _convertToDiskPage(generic_page* page) const noexcept;

        void _readPage(PageID pid, generic_page* targetPage, bool fromBackup = false);

        void _deletePage(bf_idx index) noexcept;

        void _checkWarmupDone() noexcept;

        void _setWarmupDone() noexcept;
    };

    class BufferPoolException : public std::exception {
    public:
        const char* what() const noexcept override {
            return "Some error happened in this buffer pool!";
        };
    };

    class BufferPoolSizeException : public BufferPoolException {
    public:
        BufferPoolSizeException(const bf_idx& blockCount) :
                _blockCount(blockCount) {};

        const char* what() const noexcept override {
            int whatStringLength = snprintf(nullptr, 0,
                                            "The set buffer pool size of %zdMB causes an error in this buffer pool!",
                                            (_blockCount * sizeof(generic_page) + 33) / 1024 / 1024);
            char* whatSentence = new char[whatStringLength + 1];
            snprintf(whatSentence, whatStringLength,
                     "The set buffer pool size of %zdMB causes an error in this buffer pool!",
                     (_blockCount * sizeof(generic_page) + 33) / 1024 / 1024);
            return whatSentence;
        };

    protected:
        bf_idx _blockCount;
    };

    class BufferPoolTooSmallException : public BufferPoolSizeException {
    public:
        BufferPoolTooSmallException(const bf_idx& blockCount, const bf_idx& minimumBlockCount) :
                BufferPoolSizeException(blockCount),
                _minimumBlockCount(minimumBlockCount) {};

        const char* what() const noexcept override {
            int whatStringLength = snprintf(nullptr, 0,
                                            "The set buffer pool size of %zdMB is too small! At least %zdMB are required.",
                                            (_blockCount * sizeof(generic_page) + 33) / 1024 / 1024,
                                            (_minimumBlockCount * sizeof(generic_page) + 33) / 1024 / 1024);
            char* whatSentence = new char[whatStringLength + 1];
            snprintf(whatSentence, whatStringLength,
                     "The set buffer pool size of %zdMB is too small! At least %zdMB are required.",
                     (_blockCount * sizeof(generic_page) + 33) / 1024 / 1024,
                     (_minimumBlockCount * sizeof(generic_page) + 33) / 1024 / 1024);
            return whatSentence;
        };

    protected:
        bf_idx _minimumBlockCount;
    };

    class BufferPoolTooLargeException : public BufferPoolSizeException {
    public:
        BufferPoolTooLargeException(const bf_idx& blockCount) :
                BufferPoolSizeException(blockCount) {};

        const char* what() const noexcept override {
            int whatStringLength = snprintf(nullptr, 0,
                                            "The set buffer pool size of %zdMB cannot be allocated!",
                                            (_blockCount * sizeof(generic_page) + 33) / 1024 / 1024);
            char* whatSentence = new char[whatStringLength + 1];
            snprintf(whatSentence, whatStringLength,
                     "The set buffer pool size of %zdMB cannot be allocated!",
                     (_blockCount * sizeof(generic_page) + 33) / 1024 / 1024);
            return whatSentence;
        };
    };

    class BufferPoolOldStyleException : public BufferPoolException {
    public:
        BufferPoolOldStyleException(const w_rc_t& oldStyleException) :
                _oldStyleException(oldStyleException) {};

        const char* what() const noexcept override {
            if (_oldStyleException.err_num() == w_error_ok) {
                return "No error";
            } else {
                char* whatStringFirstLine;
                int whatStringFirstLineLength;
                if (_oldStyleException.get_custom_message() != nullptr) {
                    whatStringFirstLineLength = snprintf(nullptr, 0, "%s(%d):%s:%s",
                                                         w_error_name(_oldStyleException.err_num()),
                                                         _oldStyleException.err_num(),
                                                         _oldStyleException.get_message(),
                                                         _oldStyleException.get_custom_message());
                    whatStringFirstLine = new char[whatStringFirstLineLength + 1];
                    snprintf(whatStringFirstLine, whatStringFirstLineLength, "%s(%d):%s:%s",
                             w_error_name(_oldStyleException.err_num()),
                             _oldStyleException.err_num(),
                             _oldStyleException.get_message(),
                             _oldStyleException.get_custom_message());
                } else {
                    whatStringFirstLineLength = snprintf(nullptr, 0, "%s(%d):%s:%s",
                                                         w_error_name(_oldStyleException.err_num()),
                                                         _oldStyleException.err_num(),
                                                         _oldStyleException.get_message(),
                                                         _oldStyleException.get_custom_message());
                    whatStringFirstLine = new char[whatStringFirstLineLength + 1];
                    snprintf(whatStringFirstLine, whatStringFirstLineLength, "%s(%d):%s",
                             w_error_name(_oldStyleException.err_num()),
                             _oldStyleException.err_num(),
                             _oldStyleException.get_message());
                }

                char** whatStringStack = new char* [_oldStyleException.get_stack_depth()];
                int* whatStringStackLength = new int[_oldStyleException.get_stack_depth()];
                int whatStringStackTotalLength = 0;
                for (int stackIndex = 0; stackIndex < _oldStyleException.get_stack_depth(); stackIndex++) {
                    whatStringStackLength[stackIndex] = snprintf(nullptr, 0, "  %s:%d",
                                                                 _oldStyleException.get_filename(stackIndex),
                                                                 _oldStyleException.get_linenum(stackIndex));
                    whatStringStack[stackIndex] = new char[whatStringStackLength[stackIndex] + 1];
                    snprintf(whatStringStack[stackIndex], whatStringStackLength[stackIndex], "  %s:%d",
                             _oldStyleException.get_filename(stackIndex),
                             _oldStyleException.get_linenum(stackIndex));
                    whatStringStackTotalLength += whatStringStackLength[stackIndex];
                }

                char* whatStringLastLine;
                int whatStringLastLineLength = 0;
                if (_oldStyleException.get_stack_depth() >= MAX_RCT_STACK_DEPTH) {
                    whatStringLastLine = "  .. and more. Increase MAX_RCT_STACK_DEPTH to see full stacktraces";
                    whatStringLastLineLength = strlen(whatStringLastLine);
                }

                char* whatString = new char[whatStringFirstLineLength + 1
                                            + whatStringStackTotalLength + _oldStyleException.get_stack_depth() - 1
                                            + whatStringLastLineLength + (whatStringLastLineLength ? 1 : 0)
                                            + 1];
                strcpy(whatString, whatStringFirstLine);
                for (int stackLine = 0; stackLine < sizeof(whatStringStack) / sizeof(whatStringStack[0]); stackLine++) {
                    strcat(whatString, "\n");
                    strcat(whatString, whatStringStack[stackLine]);
                }
                if (whatStringLastLineLength > 0) {
                    strcat(whatString, "\n");
                    strcat(whatString, whatStringLastLine);
                }

                return whatString;
            }
        }

        const w_rc_t& getOldStyleException() const noexcept {
            return _oldStyleException;
        };

    protected:
        w_rc_t _oldStyleException;
    };
} // zero::buffer_pool

class pin_for_refix_holder {
public:
    pin_for_refix_holder() :
            _idx(0) {};

    pin_for_refix_holder(bf_idx idx) :
            _idx(idx) {};

    pin_for_refix_holder(pin_for_refix_holder& h) {
        steal_ownership(h);
    };

    ~pin_for_refix_holder() {
        if (_idx != 0) {
            release();
        }
    };

    pin_for_refix_holder& operator=(pin_for_refix_holder& h) {
        steal_ownership(h);
        return *this;
    };

    void steal_ownership(pin_for_refix_holder& h) {
        if (_idx != 0) {
            release();
        }
        _idx = h._idx;
        h._idx = 0;
    };

    void set(bf_idx idx) {
        if (_idx != 0) {
            release();
        }
        _idx = idx;
    };

    void release();

    bf_idx _idx;
};

class GenericPageIterator {
public:
    GenericPageIterator() :
            _first(0),
            _count(0),
            _virgin(false),
            _current(nullptr),
            _current_pid(0),
            _fix_depth(0) {};

    GenericPageIterator(PageID first, PageID count, bool virgin) :
            _first(first),
            _count(count),
            _virgin(virgin),
            _current(nullptr),
            _fix_depth(0) {
        if (count > 0) {
            _current_pid = _first - 1;
            operator++();
        }
    };

    GenericPageIterator(const GenericPageIterator& other) :
            _first(other._first),
            _count(other._count),
            _virgin(other._virgin),
            _current(nullptr),
            _fix_depth(0) {
        if (_count > 0) {
            _current_pid = _first - 1;
            operator++();
        }
    };

    ~GenericPageIterator() {
        unfix_current();
        w_assert1(_fix_depth == 0);
    };

    generic_page* operator*() {
        if (!_current || _current_pid >= end_pid()) {
            return nullptr;
        }
        return _current;
    };

    /*
     * WARNING: this operator may skip a PID (e.g., jump from 42 to 44) if
     * fix_current() returns false! I couldn't find a quick, elegant way to
     * work around this problem yet.
     */
    GenericPageIterator& operator++() {
        unfix_current();

        bool success = false;
        while (!success) {
            _current_pid++;
            if (_current_pid >= end_pid()) {
                return *this;
            }
            success = fix_current();
        }

        return *this;
    };

    GenericPageIterator& operator=(GenericPageIterator other) {
        std::swap(*this, other);
        return *this;
    };

    friend void swap(GenericPageIterator& a, GenericPageIterator& b) {
        std::swap(a._first, b._first);
        std::swap(a._count, b._count);
        std::swap(a._virgin, b._virgin);
        std::swap(a._current, b._current);
        std::swap(a._current_pid, b._current_pid);
        std::swap(a._fix_depth, b._fix_depth);
    };

    bool operator==(GenericPageIterator& other) {
        if (!_current && !other._current) {
            return true;
        }
        return other._current_pid == _current_pid && _current && other._current;
    };

    bool operator!=(GenericPageIterator& other) {
        return !(*this == other);
    };

    PageID begin_pid() const {
        return _first;
    };

    PageID end_pid() const {
        return _first + _count;
    };

    PageID _current_pid;

private:
    PageID _first;

    PageID _count;

    bool _virgin;

    generic_page* _current;

    int _fix_depth;

    bool fix_current() {
        w_assert1(_fix_depth == 0);
        constexpr bool conditional = true;
        constexpr bool do_recovery = false;
        constexpr bool only_if_hit = false;
        try {
            smlevel_0::bf->_fix(nullptr, _current, _current_pid, LATCH_EX, conditional, _virgin, only_if_hit,
                                do_recovery);
        } catch (const zero::buffer_pool::BufferPoolOldStyleException& exception) {
            /*
             * The latch is already held, either by this thread (in SH mode, which
             * results in stINUSE to avoid deadlock) or by another thread. In that
             * case, we assume that if the frame is latched, the thread that holds
             * that latch already made sure that the page is consistent, and thus
             * log replay is not required.
             */
            if (exception.getOldStyleException().err_num() == stINUSE
                || exception.getOldStyleException().err_num() == stTIMEOUT) {
                ERROUT(<< "failed to fix "
                               << _current_pid);
                _current = nullptr;
                return false;
            }
            W_COERCE(exception.getOldStyleException());
        }

        _fix_depth++;

        return true;
    };

    void unfix_current() {
        if (_current) {
            w_assert1(_fix_depth == 1);
            bf_tree_cb_t& currentControlBlock = smlevel_0::bf->getControlBlock(_current);
            currentControlBlock.unpin_for_restore();
            currentControlBlock.set_check_recovery(true);
            smlevel_0::bf->unfix(_current);
            _current = nullptr;
            _fix_depth--;
        }
    };
};

#endif // __SM_BUFFER_POOL_HPP