page.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014-2015, Hewlett-Packard Development Company, LP.
 * This program 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 2 of the License, or (at your option)
 * any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * HP designates this particular file as subject to the "Classpath" exception
 * as provided by HP in the LICENSE.txt file that accompanied this code.
 */
#ifndef FOEDUS_STORAGE_PAGE_HPP_
#define FOEDUS_STORAGE_PAGE_HPP_

#include <cstring>
#include <iosfwd>

#include "foedus/assert_nd.hpp"
#include "foedus/compiler.hpp"
#include "foedus/cxx11.hpp"
#include "foedus/epoch.hpp"
#include "foedus/assorted/atomic_fences.hpp"
#include "foedus/assorted/prob_counter.hpp"
#include "foedus/memory/fwd.hpp"
#include "foedus/storage/fwd.hpp"
#include "foedus/storage/storage_id.hpp"
#include "foedus/thread/fwd.hpp"
#include "foedus/thread/thread_id.hpp"
#include "foedus/xct/xct_id.hpp"

namespace foedus {
namespace storage {
enum PageType {
  kUnknownPageType = 0,
  kArrayPageType = 1,
  kMasstreeIntermediatePageType = 2,
  kMasstreeBorderPageType = 3,
  kSequentialPageType = 4,
  kSequentialRootPageType = 5,
  kHashIntermediatePageType = 6,
  kHashDataPageType = 7,
  kHashComposedBinsPageType = 8,
  kDummyLastPageType,
};

struct PageVersionStatus CXX11_FINAL {
  enum Constants {
    kRetiredBit = 1 << 31,
    kMovedBit = 1 << 30,
    kHasNextPageBit = 1 << 29,
    kReservedBit2 = 1 << 28,
    kVersionMask = 0x0FFFFFFF,
  };
  PageVersionStatus() : status_(0) {}
  void    reset() ALWAYS_INLINE { status_ = 0; }

  bool    is_moved() const ALWAYS_INLINE { return (status_ & kMovedBit) != 0; }
  bool    is_retired() const ALWAYS_INLINE { return (status_ & kRetiredBit) != 0; }
  bool    has_next_page() const ALWAYS_INLINE { return (status_ & kHasNextPageBit) != 0; }

  bool operator==(const PageVersionStatus& other) const ALWAYS_INLINE {
    return status_ == other.status_;
  }
  bool operator!=(const PageVersionStatus& other) const ALWAYS_INLINE {
    return status_ != other.status_;
  }

  void      set_moved() ALWAYS_INLINE {
    ASSERT_ND(!is_moved());
    status_ |= kMovedBit;
  }
  void      set_retired() ALWAYS_INLINE {
    ASSERT_ND(is_moved());  // we always set moved bit first. retire must happen later.
    ASSERT_ND(!is_retired());
    status_ |= kRetiredBit;
  }
  void      set_has_next_page() ALWAYS_INLINE {
    ASSERT_ND(!is_moved());
    ASSERT_ND(!is_retired());
    ASSERT_ND(!has_next_page());
    status_ |= kHasNextPageBit;
  }

  // TASK(Hideaki) deprecated. we don't need page-version number any more. No longer used in any way
  uint32_t  get_version_counter() const ALWAYS_INLINE {
    return status_ & kVersionMask;
  }
  // TASK(Hideaki) deprecated. we don't need page-version number any more. No longer used in any way
  void      increment_version_counter() ALWAYS_INLINE {
    // we do this only when we insert a new key or split, so this never overflows.
    ASSERT_ND(get_version_counter() < kVersionMask);
    ++status_;
  }

  friend std::ostream& operator<<(std::ostream& o, const PageVersionStatus& v);

  uint32_t      status_;
};

struct PageVersion CXX11_FINAL {
  PageVersion() ALWAYS_INLINE : lock_(), status_() {}

  void    reset() ALWAYS_INLINE {
    lock_.reset();
    status_.reset();
  }

  bool    is_locked() const ALWAYS_INLINE { return lock_.is_locked(); }
  bool    is_moved() const ALWAYS_INLINE { return status_.is_moved(); }
  bool    is_retired() const ALWAYS_INLINE { return status_.is_retired(); }
  bool    has_next_page() const ALWAYS_INLINE { return status_.has_next_page(); }

  bool operator==(const PageVersion& other) const ALWAYS_INLINE { return status_ == other.status_; }
  bool operator!=(const PageVersion& other) const ALWAYS_INLINE { return status_ != other.status_; }

  void      set_moved() ALWAYS_INLINE {
    ASSERT_ND(is_locked());
    status_.set_moved();
  }
  void      set_retired() ALWAYS_INLINE {
    ASSERT_ND(is_locked());
    status_.set_retired();
  }
  void      set_has_next_page() ALWAYS_INLINE {
    ASSERT_ND(is_locked());
    status_.set_has_next_page();
  }

  // TASK(Hideaki) deprecated. we don't need page-version number any more. No longer used in any way
  uint32_t  get_version_counter() const ALWAYS_INLINE {
    return status_.get_version_counter();
  }
  // TASK(Hideaki) deprecated. we don't need page-version number any more. No longer used in any way
  void      increment_version_counter() ALWAYS_INLINE {
    ASSERT_ND(is_locked());
    status_.increment_version_counter();
  }

  friend std::ostream& operator<<(std::ostream& o, const PageVersion& v);

  xct::McsWwLock      lock_;    // +8 -> 8
  PageVersionStatus status_;  // +4 -> 12
  uint32_t          unused_;  // +4 -> 16. this space might be used for interesting range "lock".
};

struct PageHeader CXX11_FINAL {
  uint64_t      page_id_;     // +8 -> 8

  StorageId     storage_id_;  // +4 -> 12

  Checksum      checksum_;    // +4 -> 16

  uint8_t       page_type_;   // +1 -> 17

  bool          snapshot_;    // +1 -> 18

  uint16_t      key_count_;   // +2 -> 20

  uint8_t       masstree_layer_;  // +1 -> 21

  uint8_t       masstree_in_layer_level_;     // +1 -> 22

  uint8_t       stat_last_updater_node_;       // +1 -> 23

  assorted::ProbCounter hotness_;            // +1 -> 24
  PageVersion   page_version_;   // +16  -> 40

  // No instantiation.
  PageHeader() CXX11_FUNC_DELETE;
  PageHeader(const PageHeader& other) CXX11_FUNC_DELETE;
  PageHeader& operator=(const PageHeader& other) CXX11_FUNC_DELETE;
  friend std::ostream& operator<<(std::ostream& o, const PageHeader& v);

  PageType get_page_type() const { return static_cast<PageType>(page_type_); }
  uint8_t get_in_layer_level() const { return masstree_in_layer_level_; }
  void set_in_layer_level(uint8_t level) { masstree_in_layer_level_ = level; }

  inline void init_volatile(
    VolatilePagePointer page_id,
    StorageId storage_id,
    PageType page_type) ALWAYS_INLINE {
    page_id_ = page_id.word;
    storage_id_ = storage_id;
    checksum_ = 0;
    page_type_ = page_type;
    snapshot_ = false;
    key_count_ = 0;
    masstree_layer_ = 0;
    masstree_in_layer_level_ = 0;
    stat_last_updater_node_ = page_id.get_numa_node();
    hotness_.reset();
    page_version_.reset();
  }

  inline void init_snapshot(
    SnapshotPagePointer page_id,
    StorageId storage_id,
    PageType page_type) ALWAYS_INLINE {
    page_id_ = page_id;
    storage_id_ = storage_id;
    checksum_ = 0;
    page_type_ = page_type;
    snapshot_ = true;
    key_count_ = 0;
    masstree_layer_ = 0;
    masstree_in_layer_level_ = 0;
    stat_last_updater_node_ = extract_numa_node_from_snapshot_pointer(page_id);
    hotness_.reset();
    page_version_.reset();
  }

  void      increment_key_count() ALWAYS_INLINE { ++key_count_; }
  void      set_key_count(uint8_t key_count) ALWAYS_INLINE { key_count_ = key_count;  }

  bool contains_hot_records(thread::Thread* context);
};

struct Page CXX11_FINAL {
  PageHeader&  get_header()              { return header_; }
  const PageHeader&  get_header() const  { return header_; }
  PageType     get_page_type() const     { return header_.get_page_type(); }
  VolatilePagePointer get_volatile_page_id() const {
    ASSERT_ND(!header_.snapshot_);
    return VolatilePagePointer(header_.page_id_);
  }
  SnapshotPagePointer get_snapshot_page_id() const {
    ASSERT_ND(header_.snapshot_);
    return static_cast<SnapshotPagePointer>(header_.page_id_);
  }
  char*        get_data() { return data_; }
  const char*  get_data() const { return data_; }

 private:
  PageHeader  header_;
  char        data_[kPageSize - sizeof(PageHeader)];

  // No instantiation.

  Page() CXX11_FUNC_DELETE;
  Page(const Page& other) CXX11_FUNC_DELETE;
  Page& operator=(const Page& other) CXX11_FUNC_DELETE;
};

struct VolatilePageInitArguments {
  thread::Thread* context_;
  VolatilePagePointer page_id;
  Page*           page_;
  const Page*     parent_;
  uint16_t        index_in_parent_;
};

typedef void (*VolatilePageInit)(const VolatilePageInitArguments& args);

inline Page* to_page(const void* address) {
  uintptr_t int_address = reinterpret_cast<uintptr_t>(address);
  uint64_t aligned_address = static_cast<uint64_t>(int_address) / kPageSize * kPageSize;
  return reinterpret_cast<Page*>(
    reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(aligned_address)));
}

inline void assert_aligned_page(const void* page) {
  ASSERT_ND(page);
  ASSERT_ND(reinterpret_cast<uintptr_t>(page) % kPageSize == 0);
}

inline void assert_valid_volatile_page(const Page* page, uint32_t offset) {
  ASSERT_ND(page);
  ASSERT_ND(offset);
#ifndef NDEBUG
  assert_aligned_page(page);
  PageType type = page->get_header().get_page_type();
  ASSERT_ND(type >= kArrayPageType);
  ASSERT_ND(type < kDummyLastPageType);
  VolatilePagePointer pointer;
  pointer.word = page->get_header().page_id_;
  ASSERT_ND(pointer.get_offset() == offset);
#endif  // NDEBUG
}

// Defined in cpp. Don't directly invoke because it causes overhead to invoke one func.
void assert_within_valid_volatile_page_impl(
  const memory::GlobalVolatilePageResolver& resolver,
  const void* address);

// Use this instead. In release version, this method is completely eliminated by compiler
#ifndef NDEBUG
inline void assert_within_valid_volatile_page(
  const memory::GlobalVolatilePageResolver& resolver,
  const void* address) {
  assert_within_valid_volatile_page_impl(resolver, address);
}
#else  // NDEBUG
inline void assert_within_valid_volatile_page(
  const memory::GlobalVolatilePageResolver& /*resolver*/,
  const void* /*address*/) {
}
#endif  // NDEBUG

STATIC_SIZE_CHECK(sizeof(PageVersion), 16)

}  // namespace storage
}  // namespace foedus
#endif  // FOEDUS_STORAGE_PAGE_HPP_