stnode_page.h

Go to the documentation of this file.

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

#ifndef __STNODE_PAGE_H
#define __STNODE_PAGE_H

#include <vector>

#include "generic_page.h"
#include "latches.h"
#include "w_defines.h"
#include "sm_base.h"
#include "alloc_page.h"

struct alignas(8) stnode_t {
    stnode_t() : root(0),
                 last_extent(0),
                 clustered(false) {}

    PageID root;

    extent_id_t last_extent;

    bool clustered;

    bool is_used() const {
        return root != 0;
    }
};

class stnode_page : public generic_page_header {
public:

    static constexpr size_t max =
            (page_sz - sizeof(generic_page_header)) / sizeof(stnode_t);

    // Page ID used by the stnode page
    static constexpr PageID stpid = 1;

    stnode_t get(size_t index) const {
        w_assert1(index < max);
        return stnode[index];
    }

    void set_root(size_t index, PageID root) {
        w_assert1(index < max);
        stnode[index].root = root;
    }

    void set_last_extent(size_t index, extent_id_t ext) {
        w_assert1(index < max);
        w_assert1(index == 0 || stnode[index].is_used());
        stnode[index].last_extent = ext;
    }

    extent_id_t get_last_extent(size_t index) {
        w_assert1(index < max);
        return stnode[index].last_extent;
    }

    void format_empty() {
        memset(this, 0, sizeof(generic_page_header));
        pid = stnode_page::stpid;
        tag = t_stnode_p;

        memset(&stnode, 0, sizeof(stnode_t) * max);
    }

    // Used to generate page_img_format log records.
    char* unused_part(size_t& length) {
        size_t first_unused = 0;
        for (size_t i = 1; i < stnode_page::max; ++i) {
            if (!stnode[i].is_used()) {
                first_unused = i;
                break;
            }
        }
        std::cout << "first unused store: " << first_unused << std::endl;
        char* unused = reinterpret_cast<char*>(&(stnode[first_unused]));
        char* page_begin = reinterpret_cast<char*>(this);
        length = (page_begin + sizeof(stnode_page)) - unused;
        return unused;
    }

private:
    stnode_t stnode[max];
};

BOOST_STATIC_ASSERT(sizeof(stnode_page) == generic_page_header::page_sz);

class stnode_cache_t {
public:
    stnode_cache_t(bool virgin);

    PageID get_root_pid(StoreID store) const;

    lsn_t get_root_elmsn(StoreID store) const;

    bool is_allocated(StoreID store) const;

    stnode_t get_stnode(StoreID store) const;

    void get_used_stores(std::vector<StoreID>&) const;

    rc_t sx_create_store(PageID root_pid, StoreID& snum) const;

    rc_t sx_append_extent(StoreID store, extent_id_t ext) const;

    void dump(std::ostream& out) const;

    extent_id_t get_last_extent(StoreID stid) const;

private:
    StoreID get_min_unused_stid(stnode_page* spage) const;
};

#endif // __STNODE_PAGE_H