foedus::storage::array::ArrayStoragePimpl Class Reference

Pimpl object of ArrayStorage. More...

Detailed Description

Pimpl object of ArrayStorage.

A private pimpl object for ArrayStorage. Do not include this header from a client program unless you know what you are doing.

Definition at line 88 of file array_storage_pimpl.hpp.

#include <array_storage_pimpl.hpp>

Collaboration diagram for foedus::storage::array::ArrayStoragePimpl:

Public Types
enum	Constants { kBatchMax = 16 }

Public Member Functions
	ArrayStoragePimpl ()=delete
	ArrayStoragePimpl (ArrayStorage *storage)
	ArrayStoragePimpl (Engine *engine, ArrayStorageControlBlock *control_block)
	~ArrayStoragePimpl ()
ErrorStack	create (const Metadata &metadata)
ErrorStack	load (const StorageControlBlock &snapshot_block)
ErrorStack	load_empty ()
void	report_page_distribution ()
bool	exists () const
const ArrayMetadata &	get_meta () const
StorageId	get_id () const
uint16_t	get_levels () const
uint16_t	get_snapshot_drop_volatile_pages_threshold () const
uint16_t	get_payload_size () const
ArrayOffset	get_array_size () const
ErrorCode	get_root_page (thread::Thread *context, bool for_write, ArrayPage **out) __attribute__((always_inline))
ErrorStack	verify_single_thread (thread::Thread *context)
ErrorStack	verify_single_thread (thread::Thread *context, ArrayPage *page)
ErrorStack	hcc_reset_all_temperature_stat ()
ErrorStack	hcc_reset_all_temperature_stat_intermediate (VolatilePagePointer intermediate_page_id)
ErrorCode	prefetch_pages (thread::Thread *context, bool install_volatile, bool cache_snapshot, ArrayOffset from, ArrayOffset to)
	defined in array_storage_prefetch.cpp More...
ErrorCode	prefetch_pages_recurse (thread::Thread *context, bool install_volatile, bool cache_snapshot, ArrayOffset from, ArrayOffset to, ArrayPage *page)
ErrorCode	locate_record_for_read (thread::Thread *context, ArrayOffset offset, Record **out, bool *snapshot_record) __attribute__((always_inline))
ErrorCode	locate_record_for_write (thread::Thread *context, ArrayOffset offset, Record **out) __attribute__((always_inline))
ErrorCode	get_record (thread::Thread *context, ArrayOffset offset, void *payload, uint16_t payload_offset, uint16_t payload_count) __attribute__((always_inline))
template<typename T >
ErrorCode	get_record_primitive (thread::Thread *context, ArrayOffset offset, T *payload, uint16_t payload_offset)
ErrorCode	get_record_payload (thread::Thread *context, ArrayOffset offset, const void **payload) __attribute__((always_inline))
ErrorCode	get_record_for_write (thread::Thread *context, ArrayOffset offset, Record **record) __attribute__((always_inline))
template<typename T >
ErrorCode	get_record_primitive_batch (thread::Thread *context, uint16_t payload_offset, uint16_t batch_size, const ArrayOffset *offset_batch, T *payload_batch) __attribute__((always_inline))
ErrorCode	get_record_payload_batch (thread::Thread *context, uint16_t batch_size, const ArrayOffset *offset_batch, const void **payload_batch) __attribute__((always_inline))
ErrorCode	get_record_for_write_batch (thread::Thread *context, uint16_t batch_size, const ArrayOffset *offset_batch, Record **record_batch) __attribute__((always_inline))
ErrorCode	overwrite_record (thread::Thread *context, ArrayOffset offset, const void *payload, uint16_t payload_offset, uint16_t payload_count) __attribute__((always_inline))
template<typename T >
ErrorCode	overwrite_record_primitive (thread::Thread *context, ArrayOffset offset, T payload, uint16_t payload_offset)
ErrorCode	overwrite_record (thread::Thread *context, ArrayOffset offset, Record *record, const void *payload, uint16_t payload_offset, uint16_t payload_count) __attribute__((always_inline))
template<typename T >
ErrorCode	overwrite_record_primitive (thread::Thread *context, ArrayOffset offset, Record *record, T payload, uint16_t payload_offset) __attribute__((always_inline))
template<typename T >
ErrorCode	increment_record (thread::Thread *context, ArrayOffset offset, T *value, uint16_t payload_offset)
template<typename T >
ErrorCode	increment_record_oneshot (thread::Thread *context, ArrayOffset offset, T value, uint16_t payload_offset)
ErrorCode	lookup_for_read (thread::Thread *context, ArrayOffset offset, ArrayPage **out, uint16_t *index, bool *snapshot_page) __attribute__((always_inline))
ErrorCode	lookup_for_write (thread::Thread *context, ArrayOffset offset, ArrayPage **out, uint16_t *index) __attribute__((always_inline))
	This version always returns a volatile page, installing a new one if needed. More...
ErrorCode	locate_record_for_read_batch (thread::Thread *context, uint16_t batch_size, const ArrayOffset *offset_batch, Record **out_batch, bool *snapshot_page_batch)
ErrorCode	lookup_for_read_batch (thread::Thread *context, uint16_t batch_size, const ArrayOffset *offset_batch, ArrayPage **out_batch, uint16_t *index_batch, bool *snapshot_page_batch)
ErrorCode	lookup_for_write_batch (thread::Thread *context, uint16_t batch_size, const ArrayOffset *offset_batch, Record **record_batch)
ErrorCode	follow_pointer (thread::Thread *context, bool in_snapshot, bool for_write, DualPagePointer *pointer, ArrayPage **out, const ArrayPage *parent, uint16_t index_in_parent) __attribute__((always_inline))
ErrorCode	follow_pointers_for_read_batch (thread::Thread *context, uint16_t batch_size, bool *in_snapshot, ArrayPage **parents, const uint16_t *index_in_parents, ArrayPage **out)
ErrorCode	follow_pointers_for_write_batch (thread::Thread *context, uint16_t batch_size, ArrayPage **parents, const uint16_t *index_in_parents, ArrayPage **out)

Static Public Member Functions
static void	release_pages_recursive (const memory::GlobalVolatilePageResolver &resolver, memory::PageReleaseBatch *batch, VolatilePagePointer volatile_page_id)
	Used only from drop() More...
static std::vector< uint64_t >	calculate_required_pages (uint64_t array_size, uint16_t payload)
	Calculate leaf/interior pages we need. More...
static std::vector< uint64_t >	calculate_offset_intervals (uint8_t levels, uint16_t payload)
	The offset interval a single page represents in each level. More...

Public Attributes
Engine *const	engine_
ArrayStorageControlBlock *const	control_block_

Member Enumeration Documentation

enum foedus::storage::array::ArrayStoragePimpl::Constants

Enumerator
kBatchMax	If you want more than this, you should loop. ArrayStorage should take care of it.

Definition at line 90 of file array_storage_pimpl.hpp.

                 {
    kBatchMax = 16,
  };

Constructor & Destructor Documentation

foedus::storage::array::ArrayStoragePimpl::ArrayStoragePimpl ( )

delete

foedus::storage::array::ArrayStoragePimpl::ArrayStoragePimpl ( ArrayStorage *  storage )

inlineexplicit

Definition at line 96 of file array_storage_pimpl.hpp.

    : engine_(storage->get_engine()), control_block_(storage->get_control_block()) {}

foedus::storage::array::ArrayStoragePimpl::ArrayStoragePimpl ( Engine *  engine, ArrayStorageControlBlock *  control_block  )

inline

Definition at line 98 of file array_storage_pimpl.hpp.

    : engine_(engine), control_block_(control_block) {}

foedus::storage::array::ArrayStoragePimpl::~ArrayStoragePimpl ( )

inline

Definition at line 101 of file array_storage_pimpl.hpp.

{}

Member Function Documentation

std::vector< uint64_t > foedus::storage::array::ArrayStoragePimpl::calculate_offset_intervals ( uint8_t  levels, uint16_t  payload  )

static

The offset interval a single page represents in each level.

index=level. So, offset_intervals[0] is the number of records in a leaf page.

Definition at line 241 of file array_storage_pimpl.cpp.

References foedus::assorted::align8(), foedus::storage::array::kDataSize, foedus::storage::array::kInteriorFanout, and foedus::storage::kRecordOverhead.

                    {
  const uint16_t payload_size_aligned = (assorted::align8(payload));

  std::vector<uint64_t> offset_intervals;
  offset_intervals.push_back(kDataSize / (payload_size_aligned + kRecordOverhead));
  for (uint8_t level = 1; level < levels; ++level) {
    offset_intervals.push_back(offset_intervals[level - 1] * kInteriorFanout);
  }
  return offset_intervals;
}

Here is the call graph for this function:

std::vector< uint64_t > foedus::storage::array::ArrayStoragePimpl::calculate_required_pages ( uint64_t  array_size, uint16_t  payload  )

static

Calculate leaf/interior pages we need.

Returns

index=level.

Definition at line 170 of file array_storage_pimpl.cpp.

References foedus::assorted::align8(), foedus::assorted::int_div_ceil(), foedus::storage::array::kDataSize, foedus::storage::array::kInteriorFanout, and foedus::storage::kRecordOverhead.

                                         {
  payload = assorted::align8(payload);
  uint64_t records_per_page = kDataSize / (payload + kRecordOverhead);

  // so, how many leaf pages do we need?
  uint64_t leaf_pages = assorted::int_div_ceil(array_size, records_per_page);
  LOG(INFO) << "We need " << leaf_pages << " leaf pages";

  // interior nodes
  uint64_t total_pages = leaf_pages;
  std::vector<uint64_t> pages;
  pages.push_back(leaf_pages);
  while (pages.back() != 1) {
    uint64_t next_level_pages = assorted::int_div_ceil(pages.back(), kInteriorFanout);
    LOG(INFO) << "Level-" << pages.size() << " would have " << next_level_pages << " pages";
    pages.push_back(next_level_pages);
    total_pages += next_level_pages;
  }

  LOG(INFO) << "In total, we need " << total_pages << " pages";
  return pages;
}

Here is the call graph for this function:

ErrorStack foedus::storage::array::ArrayStoragePimpl::create

(

const Metadata &

metadata

)

Definition at line 288 of file array_storage_pimpl.cpp.

References CHECK_ERROR, control_block_, ERROR_STACK, exists(), foedus::storage::Metadata::id_, foedus::kErrorCodeStrAlreadyExists, foedus::storage::kExists, foedus::kRetOk, load_empty(), foedus::storage::array::ArrayStorageControlBlock::meta_, and foedus::storage::array::ArrayStorageControlBlock::status_.

Referenced by foedus::storage::array::ArrayStorage::create().

                                                             {
  if (exists()) {
    LOG(ERROR) << "This array-storage already exists-" << metadata.id_;
    return ERROR_STACK(kErrorCodeStrAlreadyExists);
  }
  control_block_->meta_ = static_cast<const ArrayMetadata&>(metadata);
  CHECK_ERROR(load_empty());
  LOG(INFO) << "Newly created an array-storage " << metadata.id_;

  control_block_->status_ = kExists;
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::storage::array::ArrayStoragePimpl::exists ( ) const

inline

Definition at line 109 of file array_storage_pimpl.hpp.

References control_block_, and foedus::storage::array::ArrayStorageControlBlock::exists().

Referenced by create(), locate_record_for_read(), locate_record_for_write(), lookup_for_read(), and lookup_for_write().

{ return control_block_->exists(); }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::follow_pointer ( thread::Thread *  context, bool  in_snapshot, bool  for_write, DualPagePointer *  pointer, ArrayPage **  out, const ArrayPage *  parent, uint16_t  index_in_parent  )

inline

Definition at line 304 of file array_storage_pimpl.hpp.

References foedus::storage::array::array_volatile_page_init(), ASSERT_ND, CHECK_ERROR_CODE, foedus::thread::Thread::follow_page_pointer(), foedus::storage::array::ArrayPage::get_level(), get_payload_size(), foedus::storage::array::ArrayPage::is_leaf(), foedus::xct::XctId::is_valid(), and foedus::kErrorCodeOk.

Referenced by lookup_for_read(), and lookup_for_write().

                            {
  ASSERT_ND(!in_snapshot || !for_write);  // if we are modifying, we must be in volatile world
  ASSERT_ND(!parent->is_leaf());
  CHECK_ERROR_CODE(context->follow_page_pointer(
    array_volatile_page_init,  // array might have null pointer. in that case create empty new page
    false,  // if both volatile/snapshot null, create a new volatile (logically all-zero)
    for_write,
    !in_snapshot,  // if we are already in snapshot world, no need to take more pointer set
    pointer,
    reinterpret_cast<Page**>(out),
    reinterpret_cast<const Page*>(parent),
    index_in_parent));

#ifndef NDEBUG
  ArrayPage* page = *out;
  ASSERT_ND(page != nullptr);
  ASSERT_ND(page->get_level() + 1U == parent->get_level());
  if (page->is_leaf()) {
    xct::XctId xct_id = page->get_leaf_record(0, get_payload_size())->owner_id_.xct_id_;
    ASSERT_ND(xct_id.is_valid());
  }
#endif  // NDEBUG
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::follow_pointers_for_read_batch	(	thread::Thread *	context,
		uint16_t	batch_size,
		bool *	in_snapshot,
		ArrayPage **	parents,
		const uint16_t *	index_in_parents,
		ArrayPage **	out
	)

Definition at line 1010 of file array_storage_pimpl.cpp.

References foedus::storage::array::array_volatile_page_init(), ASSERT_ND, CHECK_ERROR_CODE, foedus::thread::Thread::follow_page_pointers_for_read_batch(), foedus::storage::array::ArrayPage::get_interior_record(), foedus::storage::array::ArrayPage::get_leaf_record(), foedus::storage::array::ArrayPage::get_level(), get_payload_size(), foedus::storage::array::ArrayPage::header(), foedus::storage::array::ArrayPage::is_leaf(), foedus::xct::XctId::is_valid(), kBatchMax, foedus::kErrorCodeOk, foedus::storage::Record::owner_id_, foedus::storage::PageHeader::snapshot_, and foedus::xct::RwLockableXctId::xct_id_.

Referenced by lookup_for_read_batch().

                   {
  DualPagePointer* pointers[kBatchMax];
  for (uint8_t i = 0; i < batch_size; ++i) {
    ASSERT_ND(!parents[i]->is_leaf());
    ASSERT_ND(in_snapshot[i] == parents[i]->header().snapshot_);
    pointers[i] = &parents[i]->get_interior_record(index_in_parents[i]);
  }

#ifndef NDEBUG
  // there is a case of out==parents. for the assertion below, let's copy
  ArrayPage* parents_copy[kBatchMax];
  for (uint8_t i = 0; i < batch_size; ++i) {
    parents_copy[i] = parents[i];
  }
#endif  // NDEBUG

  CHECK_ERROR_CODE(context->follow_page_pointers_for_read_batch(
    batch_size,
    array_volatile_page_init,
    false,
    true,
    pointers,
    reinterpret_cast<Page**>(parents),
    index_in_parents,
    in_snapshot,
    reinterpret_cast<Page**>(out)));

#ifndef NDEBUG
  for (uint8_t i = 0; i < batch_size; ++i) {
    ArrayPage* page = out[i];
    ASSERT_ND(page != nullptr);
    /*
    if ((uintptr_t)(page) == 0xdadadadadadadadaULL) {
      for (uint8_t j = 0; j < batch_size; ++j) {
        in_snapshot[j] = parents_copy[j]->header().snapshot_;
      }
      CHECK_ERROR_CODE(context->follow_page_pointers_for_read_batch(
        batch_size,
        array_volatile_page_init,
        false,
        true,
        pointers,
        reinterpret_cast<Page**>(parents_copy),
        index_in_parents,
        in_snapshot,
        reinterpret_cast<Page**>(out)));
    }
    */
    ASSERT_ND(in_snapshot[i] == page->header().snapshot_);
    ASSERT_ND(page->get_level() + 1U == parents_copy[i]->get_level());
    if (page->is_leaf()) {
      xct::XctId xct_id = page->get_leaf_record(0, get_payload_size())->owner_id_.xct_id_;
      ASSERT_ND(xct_id.is_valid());
    }
  }
#endif  // NDEBUG
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::follow_pointers_for_write_batch	(	thread::Thread *	context,
		uint16_t	batch_size,
		ArrayPage **	parents,
		const uint16_t *	index_in_parents,
		ArrayPage **	out
	)

Definition at line 1075 of file array_storage_pimpl.cpp.

References foedus::storage::array::array_volatile_page_init(), ASSERT_ND, CHECK_ERROR_CODE, foedus::thread::Thread::follow_page_pointers_for_write_batch(), foedus::storage::array::ArrayPage::get_interior_record(), foedus::storage::array::ArrayPage::get_leaf_record(), foedus::storage::array::ArrayPage::get_level(), get_payload_size(), foedus::storage::array::ArrayPage::header(), foedus::storage::array::ArrayPage::is_leaf(), foedus::xct::XctId::is_valid(), kBatchMax, foedus::kErrorCodeOk, foedus::storage::Record::owner_id_, foedus::storage::PageHeader::snapshot_, and foedus::xct::RwLockableXctId::xct_id_.

Referenced by lookup_for_write_batch().

                   {
  DualPagePointer* pointers[kBatchMax];
  for (uint8_t i = 0; i < batch_size; ++i) {
    ASSERT_ND(!parents[i]->is_leaf());
    ASSERT_ND(!parents[i]->header().snapshot_);
    pointers[i] = &parents[i]->get_interior_record(index_in_parents[i]);
  }

#ifndef NDEBUG
  // there is a case of out==parents. for the assertion below, let's copy
  ArrayPage* parents_copy[kBatchMax];
  for (uint8_t i = 0; i < batch_size; ++i) {
    parents_copy[i] = parents[i];
  }
#endif  // NDEBUG

  CHECK_ERROR_CODE(context->follow_page_pointers_for_write_batch(
    batch_size,
    array_volatile_page_init,
    pointers,
    reinterpret_cast<Page**>(parents),
    index_in_parents,
    reinterpret_cast<Page**>(out)));

#ifndef NDEBUG
  for (uint8_t i = 0; i < batch_size; ++i) {
    ArrayPage* page = out[i];
    ASSERT_ND(page != nullptr);
    ASSERT_ND(!page->header().snapshot_);
    ASSERT_ND(page->get_level() + 1U == parents_copy[i]->get_level());
    if (page->is_leaf()) {
      xct::XctId xct_id = page->get_leaf_record(0, get_payload_size())->owner_id_.xct_id_;
      ASSERT_ND(xct_id.is_valid());
    }
  }
#endif  // NDEBUG
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ArrayOffset foedus::storage::array::ArrayStoragePimpl::get_array_size ( ) const

inline

Definition at line 117 of file array_storage_pimpl.hpp.

References foedus::storage::array::ArrayMetadata::array_size_, and get_meta().

Referenced by locate_record_for_read(), locate_record_for_write(), lookup_for_read(), lookup_for_read_batch(), lookup_for_write(), and lookup_for_write_batch().

{ return get_meta().array_size_; }

Here is the call graph for this function:

Here is the caller graph for this function:

StorageId foedus::storage::array::ArrayStoragePimpl::get_id ( ) const

inline

Definition at line 111 of file array_storage_pimpl.hpp.

References get_meta(), and foedus::storage::Metadata::id_.

Referenced by increment_record(), increment_record_oneshot(), load_empty(), lookup_for_read_batch(), lookup_for_write_batch(), overwrite_record(), and overwrite_record_primitive().

{ return get_meta().id_; }

Here is the call graph for this function:

Here is the caller graph for this function:

uint16_t foedus::storage::array::ArrayStoragePimpl::get_levels ( ) const

inline

Definition at line 112 of file array_storage_pimpl.hpp.

References control_block_, and foedus::storage::array::ArrayStorageControlBlock::levels_.

Referenced by lookup_for_read(), lookup_for_read_batch(), lookup_for_write(), and lookup_for_write_batch().

{ return control_block_->levels_; }

Here is the caller graph for this function:

const ArrayMetadata& foedus::storage::array::ArrayStoragePimpl::get_meta ( ) const

inline

Definition at line 110 of file array_storage_pimpl.hpp.

References control_block_, and foedus::storage::array::ArrayStorageControlBlock::meta_.

Referenced by get_array_size(), get_id(), get_payload_size(), get_snapshot_drop_volatile_pages_threshold(), load(), and prefetch_pages().

{ return control_block_->meta_; }

Here is the caller graph for this function:

uint16_t foedus::storage::array::ArrayStoragePimpl::get_payload_size ( ) const

inline

Definition at line 116 of file array_storage_pimpl.hpp.

References get_meta(), and foedus::storage::array::ArrayMetadata::payload_size_.

Referenced by follow_pointer(), follow_pointers_for_read_batch(), follow_pointers_for_write_batch(), get_record(), get_record_primitive(), increment_record(), increment_record_oneshot(), load(), locate_record_for_read(), locate_record_for_read_batch(), locate_record_for_write(), lookup_for_read(), lookup_for_read_batch(), lookup_for_write(), lookup_for_write_batch(), overwrite_record(), overwrite_record_primitive(), and verify_single_thread().

{ return get_meta().payload_size_; }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::get_record ( thread::Thread *  context, ArrayOffset  offset, void *  payload, uint16_t  payload_offset, uint16_t  payload_count  )

inline

Definition at line 372 of file array_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::thread::Thread::get_current_xct(), get_payload_size(), foedus::kErrorCodeOk, locate_record_for_read(), foedus::xct::Xct::on_record_read(), foedus::storage::Record::owner_id_, and foedus::storage::Record::payload_.

Referenced by foedus::storage::array::ArrayStorage::get_record().

                          {
  ASSERT_ND(payload_offset + payload_count <= get_payload_size());
  Record *record = nullptr;
  bool snapshot_record;
  CHECK_ERROR_CODE(locate_record_for_read(context, offset, &record, &snapshot_record));
  CHECK_ERROR_CODE(context->get_current_xct().on_record_read(false, &record->owner_id_));
  std::memcpy(payload, record->payload_ + payload_offset, payload_count);
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::get_record_for_write ( thread::Thread *  context, ArrayOffset  offset, Record **  record  )

inline

Definition at line 419 of file array_storage_pimpl.cpp.

References CHECK_ERROR_CODE, foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_isolation_level(), foedus::xct::kDirtyRead, foedus::kErrorCodeOk, locate_record_for_write(), and foedus::xct::Xct::on_record_read().

Referenced by foedus::storage::array::ArrayStorage::get_record_for_write().

                   {
  CHECK_ERROR_CODE(locate_record_for_write(context, offset, record));
  xct::Xct& current_xct = context->get_current_xct();
  if (current_xct.get_isolation_level() != xct::kDirtyRead) {
    CHECK_ERROR_CODE(current_xct.on_record_read(true, &(*record)->owner_id_));
  }
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::get_record_for_write_batch ( thread::Thread *  context, uint16_t  batch_size, const ArrayOffset *  offset_batch, Record **  record_batch  )

inline

Definition at line 746 of file array_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_isolation_level(), kBatchMax, foedus::xct::kDirtyRead, foedus::kErrorCodeOk, lookup_for_write_batch(), foedus::assorted::memory_fence_consume(), foedus::xct::Xct::on_record_read(), and foedus::storage::Record::owner_id_.

Referenced by foedus::storage::array::ArrayStorage::get_record_for_write_batch().

                         {
  ASSERT_ND(batch_size <= kBatchMax);
  CHECK_ERROR_CODE(lookup_for_write_batch(
    context,
    batch_size,
    offset_batch,
    record_batch));
  xct::Xct& current_xct = context->get_current_xct();
  if (current_xct.get_isolation_level() != xct::kDirtyRead) {
    for (uint8_t i = 0; i < batch_size; ++i) {
      CHECK_ERROR_CODE(current_xct.on_record_read(true, &record_batch[i]->owner_id_));
    }
    assorted::memory_fence_consume();
  }
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::get_record_payload ( thread::Thread *  context, ArrayOffset  offset, const void **  payload  )

inline

Definition at line 403 of file array_storage_pimpl.cpp.

References CHECK_ERROR_CODE, foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_isolation_level(), foedus::xct::kDirtyRead, foedus::kErrorCodeOk, locate_record_for_read(), foedus::xct::Xct::on_record_read(), foedus::storage::Record::owner_id_, and foedus::storage::Record::payload_.

Referenced by foedus::storage::array::ArrayStorage::get_record_payload().

                        {
  Record *record = nullptr;
  bool snapshot_record;
  CHECK_ERROR_CODE(locate_record_for_read(context, offset, &record, &snapshot_record));
  xct::Xct& current_xct = context->get_current_xct();
  if (!snapshot_record &&
    current_xct.get_isolation_level() != xct::kDirtyRead) {
    CHECK_ERROR_CODE(current_xct.on_record_read(false, &record->owner_id_));
  }
  *payload = record->payload_;
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::get_record_payload_batch ( thread::Thread *  context, uint16_t  batch_size, const ArrayOffset *  offset_batch, const void **  payload_batch  )

inline

Definition at line 717 of file array_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_isolation_level(), kBatchMax, foedus::xct::kDirtyRead, foedus::kErrorCodeOk, locate_record_for_read_batch(), foedus::assorted::memory_fence_consume(), foedus::xct::Xct::on_record_read(), foedus::storage::Record::owner_id_, and foedus::storage::Record::payload_.

Referenced by foedus::storage::array::ArrayStorage::get_record_payload_batch().

                              {
  ASSERT_ND(batch_size <= kBatchMax);
  Record* record_batch[kBatchMax];
  bool snapshot_record_batch[kBatchMax];
  CHECK_ERROR_CODE(locate_record_for_read_batch(
    context,
    batch_size,
    offset_batch,
    record_batch,
    snapshot_record_batch));
  xct::Xct& current_xct = context->get_current_xct();
  if (current_xct.get_isolation_level() != xct::kDirtyRead) {
    for (uint8_t i = 0; i < batch_size; ++i) {
      if (!snapshot_record_batch[i]) {
        CHECK_ERROR_CODE(current_xct.on_record_read(false, &record_batch[i]->owner_id_));
      }
    }
    assorted::memory_fence_consume();
  }
  for (uint8_t i = 0; i < batch_size; ++i) {
    payload_batch[i] = record_batch[i]->payload_;
  }
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

ErrorCode foedus::storage::array::ArrayStoragePimpl::get_record_primitive	(	thread::Thread *	context,
		ArrayOffset	offset,
		T *	payload,
		uint16_t	payload_offset
	)

Definition at line 388 of file array_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::thread::Thread::get_current_xct(), get_payload_size(), foedus::kErrorCodeOk, locate_record_for_read(), foedus::xct::Xct::on_record_read(), foedus::storage::Record::owner_id_, and foedus::storage::Record::payload_.

Referenced by foedus::storage::array::ArrayStorage::get_record_primitive().

                           {
  ASSERT_ND(payload_offset + sizeof(T) <= get_payload_size());
  Record *record = nullptr;
  bool snapshot_record;
  CHECK_ERROR_CODE(locate_record_for_read(context, offset, &record, &snapshot_record));
  CHECK_ERROR_CODE(context->get_current_xct().on_record_read(false, &record->owner_id_));
  char* ptr = record->payload_ + payload_offset;
  *payload = *reinterpret_cast<const T*>(ptr);
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

ErrorCode foedus::storage::array::ArrayStoragePimpl::get_record_primitive_batch ( thread::Thread *  context, uint16_t  payload_offset, uint16_t  batch_size, const ArrayOffset *  offset_batch, T *  payload_batch  )

inline

Definition at line 678 of file array_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_isolation_level(), kBatchMax, foedus::xct::kDirtyRead, foedus::kErrorCodeOk, foedus::storage::kRecordOverhead, locate_record_for_read_batch(), foedus::assorted::memory_fence_consume(), foedus::xct::Xct::on_record_read(), foedus::storage::Record::owner_id_, foedus::storage::Record::payload_, and foedus::assorted::prefetch_cacheline().

Referenced by foedus::storage::array::ArrayStorage::get_record_primitive_batch().

                    {
  ASSERT_ND(batch_size <= kBatchMax);
  Record* record_batch[kBatchMax];
  bool snapshot_record_batch[kBatchMax];
  CHECK_ERROR_CODE(locate_record_for_read_batch(
    context,
    batch_size,
    offset_batch,
    record_batch,
    snapshot_record_batch));
  xct::Xct& current_xct = context->get_current_xct();
  if (current_xct.get_isolation_level() != xct::kDirtyRead) {
    for (uint8_t i = 0; i < batch_size; ++i) {
      if (!snapshot_record_batch[i]) {
        CHECK_ERROR_CODE(current_xct.on_record_read(false, &record_batch[i]->owner_id_));
      }
    }
    assorted::memory_fence_consume();
  }
  // we anyway prefetched the first 64 bytes. if the column is not within there,
  // let's do parallel prefetch
  if (payload_offset + sizeof(T) + kRecordOverhead > 64) {
    for (uint8_t i = 0; i < batch_size; ++i) {
      assorted::prefetch_cacheline(record_batch[i]->payload_ + payload_offset);
    }
  }
  for (uint8_t i = 0; i < batch_size; ++i) {
    char* ptr = record_batch[i]->payload_ + payload_offset;
    payload_batch[i] = *reinterpret_cast<const T*>(ptr);
  }
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::get_root_page ( thread::Thread *  context, bool  for_write, ArrayPage **  out  )

inline

Definition at line 337 of file array_storage_pimpl.hpp.

References control_block_, foedus::thread::Thread::follow_page_pointer(), and foedus::storage::array::ArrayStorageControlBlock::root_page_pointer_.

Referenced by lookup_for_read(), lookup_for_read_batch(), lookup_for_write(), lookup_for_write_batch(), prefetch_pages(), and verify_single_thread().

                   {
  return context->follow_page_pointer(
    nullptr,
    false,
    for_write,
    true,
    &control_block_->root_page_pointer_,
    reinterpret_cast<Page**>(out),
    nullptr,
    0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint16_t foedus::storage::array::ArrayStoragePimpl::get_snapshot_drop_volatile_pages_threshold ( ) const

inline

Definition at line 113 of file array_storage_pimpl.hpp.

References get_meta(), and foedus::storage::array::ArrayMetadata::snapshot_drop_volatile_pages_threshold_.

                                                                 {
    return get_meta().snapshot_drop_volatile_pages_threshold_;
  }

Here is the call graph for this function:

ErrorStack foedus::storage::array::ArrayStoragePimpl::hcc_reset_all_temperature_stat

(

)

Definition at line 969 of file array_storage_pimpl.cpp.

References CHECK_ERROR, control_block_, engine_, hcc_reset_all_temperature_stat_intermediate(), foedus::storage::VolatilePagePointer::is_null(), foedus::kRetOk, foedus::storage::array::ArrayStorageControlBlock::root_page_pointer_, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by foedus::storage::array::ArrayStorage::hcc_reset_all_temperature_stat().

                                                             {
  LOG(INFO) << "**"
    << std::endl << "***************************************************************"
    << std::endl << "***   Reseting " << ArrayStorage(engine_, control_block_) << "'s "
    << std::endl << "*** temperature stat for HCC"
    << std::endl << "***************************************************************";

  DualPagePointer pointer = control_block_->root_page_pointer_;
  if (pointer.volatile_pointer_.is_null()) {
    LOG(INFO) << "No volatile pages.";
  } else {
    CHECK_ERROR(hcc_reset_all_temperature_stat_intermediate(pointer.volatile_pointer_));
  }

  LOG(INFO) << "Done resettting";
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::array::ArrayStoragePimpl::hcc_reset_all_temperature_stat_intermediate

(

VolatilePagePointer

intermediate_page_id

)

Definition at line 987 of file array_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR, engine_, foedus::memory::EngineMemory::get_global_volatile_page_resolver(), foedus::storage::array::ArrayPage::get_interior_record(), foedus::storage::array::ArrayPage::get_level(), foedus::Engine::get_memory_manager(), foedus::storage::array::ArrayPage::header(), foedus::storage::PageHeader::hotness_, foedus::storage::array::ArrayPage::is_leaf(), foedus::storage::VolatilePagePointer::is_null(), foedus::storage::array::kInteriorFanout, foedus::kRetOk, foedus::assorted::ProbCounter::reset(), and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by hcc_reset_all_temperature_stat().

                                            {
  const auto& resolver = engine_->get_memory_manager()->get_global_volatile_page_resolver();
  ArrayPage* page = reinterpret_cast<ArrayPage*>(resolver.resolve_offset(intermediate_page_id));
  ASSERT_ND(page);
  ASSERT_ND(!page->is_leaf());
  const bool bottom = page->get_level() == 1U;
  for (uint8_t i = 0; i < kInteriorFanout; ++i) {
    VolatilePagePointer page_id = page->get_interior_record(i).volatile_pointer_;
    if (page_id.is_null()) {
      continue;
    }
    if (bottom) {
      ArrayPage* leaf = reinterpret_cast<ArrayPage*>(resolver.resolve_offset(page_id));
      leaf->header().hotness_.reset();
    } else {
      CHECK_ERROR(hcc_reset_all_temperature_stat_intermediate(page_id));
    }
  }

  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

ErrorCode foedus::storage::array::ArrayStoragePimpl::increment_record	(	thread::Thread *	context,
		ArrayOffset	offset,
		T *	value,
		uint16_t	payload_offset
	)

Definition at line 486 of file array_storage_pimpl.cpp.

References foedus::xct::Xct::add_to_write_set(), ASSERT_ND, foedus::storage::array::ArrayOverwriteLogType::calculate_log_length(), CHECK_ERROR_CODE, foedus::thread::Thread::get_current_xct(), get_id(), get_payload_size(), foedus::thread::Thread::get_thread_log_buffer(), locate_record_for_write(), foedus::xct::Xct::on_record_read(), foedus::storage::Record::owner_id_, foedus::storage::Record::payload_, foedus::storage::array::ArrayOverwriteLogType::populate_primitive(), and foedus::log::ThreadLogBuffer::reserve_new_log().

Referenced by foedus::storage::array::ArrayStorage::increment_record().

                                                                                    {
  ASSERT_ND(payload_offset + sizeof(T) <= get_payload_size());
  Record *record = nullptr;
  CHECK_ERROR_CODE(locate_record_for_write(context, offset, &record));

  // this is get_record + overwrite_record
  // NOTE This version is like other storage's increment implementation.
  // Taking read-set (and potentially locks), read the value, then remember the overwrite log.
  // However the increment_record_oneshot() below is pretty different.
  CHECK_ERROR_CODE(context->get_current_xct().on_record_read(true, &record->owner_id_));
  char* ptr = record->payload_ + payload_offset;
  T tmp = *reinterpret_cast<const T*>(ptr);
  *value += tmp;
  uint16_t log_length = ArrayOverwriteLogType::calculate_log_length(sizeof(T));
  ArrayOverwriteLogType* log_entry = reinterpret_cast<ArrayOverwriteLogType*>(
    context->get_thread_log_buffer().reserve_new_log(log_length));
  log_entry->populate_primitive<T>(get_id(), offset, *value, payload_offset);
  return context->get_current_xct().add_to_write_set(
    get_id(),
    &record->owner_id_,
    record->payload_,
    log_entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

ErrorCode foedus::storage::array::ArrayStoragePimpl::increment_record_oneshot	(	thread::Thread *	context,
		ArrayOffset	offset,
		T	value,
		uint16_t	payload_offset
	)

Definition at line 512 of file array_storage_pimpl.cpp.

References foedus::xct::Xct::add_to_write_set(), ASSERT_ND, foedus::storage::array::ArrayIncrementLogType::calculate_log_length(), CHECK_ERROR_CODE, foedus::thread::Thread::get_current_xct(), get_id(), get_payload_size(), foedus::thread::Thread::get_thread_log_buffer(), locate_record_for_write(), foedus::storage::Record::owner_id_, foedus::storage::Record::payload_, foedus::storage::array::ArrayIncrementLogType::populate(), and foedus::log::ThreadLogBuffer::reserve_new_log().

Referenced by foedus::storage::array::ArrayStorage::increment_record_oneshot().

                           {
  ASSERT_ND(payload_offset + sizeof(T) <= get_payload_size());
  Record *record = nullptr;
  CHECK_ERROR_CODE(locate_record_for_write(context, offset, &record));
  // Only Array's increment can be the rare "write-set only" log.
  // other increments have to check deletion bit at least.
  // To make use of it, we do have array increment log with primitive type as parameter.
  ValueType type = to_value_type<T>();
  uint16_t log_length = ArrayIncrementLogType::calculate_log_length(type);
  ArrayIncrementLogType* log_entry = reinterpret_cast<ArrayIncrementLogType*>(
    context->get_thread_log_buffer().reserve_new_log(log_length));
  log_entry->populate<T>(get_id(), offset, value, payload_offset);
  return context->get_current_xct().add_to_write_set(
    get_id(),
    &record->owner_id_,
    record->payload_,
    log_entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::array::ArrayStoragePimpl::load

(

const StorageControlBlock &

snapshot_block

)

Definition at line 301 of file array_storage_pimpl.cpp.

References ASSERT_ND, foedus::storage::array::calculate_levels(), CHECK_ERROR, control_block_, engine_, foedus::Engine::get_memory_manager(), get_meta(), get_payload_size(), foedus::DefaultInitializable::initialize(), foedus::storage::kExists, foedus::kRetOk, foedus::UninitializeGuard::kWarnIfUninitializeError, foedus::storage::array::ArrayStorageControlBlock::levels_, load_empty(), foedus::memory::EngineMemory::load_one_volatile_page(), foedus::storage::array::ArrayStorageControlBlock::meta_, foedus::storage::StorageControlBlock::meta_, foedus::storage::array::ArrayStorageControlBlock::root_page_pointer_, foedus::storage::Metadata::root_snapshot_page_id_, foedus::storage::array::ArrayStorageControlBlock::route_finder_, foedus::storage::DualPagePointer::snapshot_pointer_, foedus::storage::array::ArrayStorageControlBlock::status_, foedus::DefaultInitializable::uninitialize(), foedus::storage::DualPagePointer::volatile_pointer_, and foedus::storage::VolatilePagePointer::word.

Referenced by foedus::storage::array::ArrayStorage::load().

                                                                            {
  control_block_->meta_ = static_cast<const ArrayMetadata&>(snapshot_block.meta_);
  const ArrayMetadata& meta = control_block_->meta_;
  ASSERT_ND(meta.root_snapshot_page_id_ != 0);
  const uint16_t levels = calculate_levels(meta);
  control_block_->levels_ = levels;
  control_block_->route_finder_ = LookupRouteFinder(levels, get_payload_size());
  control_block_->root_page_pointer_.snapshot_pointer_ = meta.root_snapshot_page_id_;
  control_block_->root_page_pointer_.volatile_pointer_.word = 0;

  // So far we assume the root page always has a volatile version.
  // Create it now.
  if (meta.root_snapshot_page_id_ != 0) {
    cache::SnapshotFileSet fileset(engine_);
    CHECK_ERROR(fileset.initialize());
    UninitializeGuard fileset_guard(&fileset, UninitializeGuard::kWarnIfUninitializeError);
    VolatilePagePointer volatile_pointer;
    Page* volatile_root;
    CHECK_ERROR(engine_->get_memory_manager()->load_one_volatile_page(
      &fileset,
      meta.root_snapshot_page_id_,
      &volatile_pointer,
      &volatile_root));
    control_block_->root_page_pointer_.volatile_pointer_ = volatile_pointer;
    CHECK_ERROR(fileset.uninitialize());
  } else {
    LOG(INFO) << "Loading an empty array-storage-" << get_meta();
    CHECK_ERROR(load_empty());
  }

  control_block_->status_ = kExists;
  LOG(INFO) << "Loaded an array-storage-" << get_meta();
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::array::ArrayStoragePimpl::load_empty

(

)

Definition at line 254 of file array_storage_pimpl.cpp.

References foedus::storage::array::ArrayMetadata::array_size_, foedus::storage::array::calculate_levels(), CHECK_ERROR, control_block_, engine_, ERROR_STACK, get_id(), foedus::savepoint::SavepointManager::get_initial_current_epoch(), foedus::Engine::get_memory_manager(), foedus::storage::array::LookupRouteFinder::get_records_in_leaf(), foedus::Engine::get_savepoint_manager(), foedus::memory::EngineMemory::grab_one_volatile_page(), foedus::storage::array::ArrayPage::initialize_volatile_page(), foedus::storage::array::ArrayStorageControlBlock::intervals_, foedus::kErrorCodeStrTooLargeArray, foedus::storage::array::kInteriorFanout, foedus::storage::array::kMaxArrayOffset, foedus::kRetOk, foedus::storage::array::ArrayStorageControlBlock::levels_, foedus::storage::array::ArrayStorageControlBlock::meta_, foedus::storage::array::ArrayMetadata::payload_size_, foedus::storage::array::ArrayStorageControlBlock::root_page_pointer_, foedus::storage::Metadata::root_snapshot_page_id_, foedus::storage::array::ArrayStorageControlBlock::route_finder_, foedus::storage::DualPagePointer::snapshot_pointer_, foedus::storage::DualPagePointer::volatile_pointer_, and foedus::storage::VolatilePagePointer::word.

Referenced by create(), and load().

                                         {
  const uint16_t levels = calculate_levels(control_block_->meta_);
  const uint32_t payload_size = control_block_->meta_.payload_size_;
  const ArrayOffset array_size = control_block_->meta_.array_size_;
  if (array_size > kMaxArrayOffset) {
    return ERROR_STACK(kErrorCodeStrTooLargeArray);
  }
  control_block_->levels_ = levels;
  control_block_->route_finder_ = LookupRouteFinder(levels, payload_size);
  control_block_->root_page_pointer_.snapshot_pointer_ = 0;
  control_block_->root_page_pointer_.volatile_pointer_.word = 0;
  control_block_->meta_.root_snapshot_page_id_ = 0;
  control_block_->intervals_[0] = control_block_->route_finder_.get_records_in_leaf();
  for (uint16_t level = 1; level < levels; ++level) {
    control_block_->intervals_[level] = control_block_->intervals_[level - 1U] * kInteriorFanout;
  }

  VolatilePagePointer volatile_pointer;
  ArrayPage* volatile_root;
  CHECK_ERROR(engine_->get_memory_manager()->grab_one_volatile_page(
    0,
    &volatile_pointer,
    reinterpret_cast<Page**>(&volatile_root)));
  volatile_root->initialize_volatile_page(
    engine_->get_savepoint_manager()->get_initial_current_epoch(),  // lowest epoch in the system
    get_id(),
    volatile_pointer,
    payload_size,
    levels - 1U,
    ArrayRange(0, array_size));
  control_block_->root_page_pointer_.volatile_pointer_ = volatile_pointer;
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::locate_record_for_read ( thread::Thread *  context, ArrayOffset  offset, Record **  out, bool *  snapshot_record  )

inline

Definition at line 337 of file array_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::storage::array::ArrayRange::contains(), exists(), foedus::storage::array::ArrayPage::get_array_range(), get_array_size(), foedus::storage::array::ArrayPage::get_leaf_record(), get_payload_size(), foedus::storage::array::ArrayPage::is_leaf(), foedus::xct::XctId::is_valid(), foedus::kErrorCodeOk, lookup_for_read(), foedus::storage::Record::owner_id_, and foedus::xct::RwLockableXctId::xct_id_.

Referenced by get_record(), get_record_payload(), and get_record_primitive().

                         {
  ASSERT_ND(exists());
  ASSERT_ND(offset < get_array_size());
  uint16_t index = 0;
  ArrayPage* page = nullptr;
  CHECK_ERROR_CODE(lookup_for_read(context, offset, &page, &index, snapshot_record));
  ASSERT_ND(page);
  ASSERT_ND(page->is_leaf());
  ASSERT_ND(page->get_array_range().contains(offset));
  ASSERT_ND(page->get_leaf_record(0, get_payload_size())->owner_id_.xct_id_.is_valid());
  *out = page->get_leaf_record(index, get_payload_size());
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::locate_record_for_read_batch ( thread::Thread *  context, uint16_t  batch_size, const ArrayOffset *  offset_batch, Record **  out_batch, bool *  snapshot_page_batch  )

inline

Definition at line 767 of file array_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::storage::array::ArrayPage::get_leaf_record(), get_payload_size(), kBatchMax, foedus::kErrorCodeOk, and lookup_for_read_batch().

Referenced by get_record_payload_batch(), and get_record_primitive_batch().

                             {
  ASSERT_ND(batch_size <= kBatchMax);
  ArrayPage* page_batch[kBatchMax];
  uint16_t index_batch[kBatchMax];
  CHECK_ERROR_CODE(lookup_for_read_batch(
    context,
    batch_size,
    offset_batch,
    page_batch,
    index_batch,
    snapshot_page_batch));
  const uint16_t payload_size = get_payload_size();
  for (uint8_t i = 0; i < batch_size; ++i) {
    ASSERT_ND(page_batch[i]);
    ASSERT_ND(page_batch[i]->is_leaf());
    ASSERT_ND(page_batch[i]->get_array_range().contains(offset_batch[i]));
    out_batch[i] = page_batch[i]->get_leaf_record(index_batch[i], payload_size);
    ASSERT_ND(out_batch[i]->owner_id_.xct_id_.is_valid());
  }
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::locate_record_for_write ( thread::Thread *  context, ArrayOffset  offset, Record **  out  )

inline

Definition at line 355 of file array_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::storage::array::ArrayRange::contains(), exists(), foedus::storage::array::ArrayPage::get_array_range(), get_array_size(), foedus::storage::array::ArrayPage::get_leaf_record(), get_payload_size(), foedus::storage::array::ArrayPage::is_leaf(), foedus::xct::XctId::is_valid(), foedus::kErrorCodeOk, lookup_for_write(), foedus::storage::Record::owner_id_, and foedus::xct::RwLockableXctId::xct_id_.

Referenced by get_record_for_write(), increment_record(), increment_record_oneshot(), overwrite_record(), and overwrite_record_primitive().

                {
  ASSERT_ND(exists());
  ASSERT_ND(offset < get_array_size());
  uint16_t index = 0;
  ArrayPage* page = nullptr;
  CHECK_ERROR_CODE(lookup_for_write(context, offset, &page, &index));
  ASSERT_ND(page);
  ASSERT_ND(page->is_leaf());
  ASSERT_ND(page->get_array_range().contains(offset));
  ASSERT_ND(page->get_leaf_record(0, get_payload_size())->owner_id_.xct_id_.is_valid());
  *out = page->get_leaf_record(index, get_payload_size());
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::lookup_for_read ( thread::Thread *  context, ArrayOffset  offset, ArrayPage **  out, uint16_t *  index, bool *  snapshot_page  )

inline

Definition at line 535 of file array_storage_pimpl.cpp.

References ASSERT_ND, foedus::storage::array::ArrayRange::begin_, CHECK_ERROR_CODE, foedus::storage::array::ArrayRange::contains(), control_block_, exists(), foedus::storage::array::LookupRouteFinder::find_route(), follow_pointer(), foedus::storage::array::ArrayPage::get_array_range(), get_array_size(), foedus::storage::array::ArrayPage::get_interior_record(), foedus::storage::array::ArrayPage::get_leaf_record(), get_levels(), get_payload_size(), get_root_page(), foedus::storage::array::ArrayPage::header(), foedus::storage::array::ArrayPage::is_leaf(), foedus::xct::XctId::is_valid(), foedus::kErrorCodeOk, foedus::storage::Record::owner_id_, foedus::storage::array::ArrayStorageControlBlock::route_finder_, foedus::storage::PageHeader::snapshot_, and foedus::xct::RwLockableXctId::xct_id_.

Referenced by locate_record_for_read().

                       {
  ASSERT_ND(exists());
  ASSERT_ND(offset < get_array_size());
  ASSERT_ND(out);
  ASSERT_ND(index);
  ArrayPage* current_page;
  CHECK_ERROR_CODE(get_root_page(context, false, &current_page));
  uint16_t levels = get_levels();
  ASSERT_ND(current_page->get_array_range().contains(offset));
  LookupRoute route = control_block_->route_finder_.find_route(offset);
  bool in_snapshot = current_page->header().snapshot_;
  for (uint8_t level = levels - 1; level > 0; --level) {
    ASSERT_ND(current_page->get_array_range().contains(offset));
    DualPagePointer& pointer = current_page->get_interior_record(route.route[level]);
    CHECK_ERROR_CODE(follow_pointer(
      context,
      in_snapshot,
      false,
      &pointer,
      &current_page,
      current_page,
      route.route[level]));
    in_snapshot = current_page->header().snapshot_;
  }
  ASSERT_ND(current_page->is_leaf());
  ASSERT_ND(current_page->get_array_range().contains(offset));
  ASSERT_ND(current_page->get_array_range().begin_ + route.route[0] == offset);
  ASSERT_ND(current_page->get_leaf_record(0, get_payload_size())->owner_id_.xct_id_.is_valid());
  *out = current_page;
  *index = route.route[0];
  *snapshot_page = (*out)->header().snapshot_;
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::lookup_for_read_batch ( thread::Thread *  context, uint16_t  batch_size, const ArrayOffset *  offset_batch, ArrayPage **  out_batch, uint16_t *  index_batch, bool *  snapshot_page_batch  )

inline

Definition at line 794 of file array_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::storage::construct_volatile_page_pointer(), control_block_, foedus::storage::extract_local_page_id_from_snapshot_pointer(), foedus::storage::array::LookupRouteFinder::find_route(), follow_pointers_for_read_batch(), get_array_size(), get_id(), foedus::storage::array::ArrayPage::get_interior_record(), foedus::storage::array::ArrayPage::get_leaf_record(), get_levels(), get_payload_size(), get_root_page(), foedus::storage::array::ArrayPage::header(), kBatchMax, foedus::kErrorCodeOk, foedus::assorted::prefetch_cacheline(), foedus::storage::array::LookupRoute::route, foedus::storage::array::ArrayStorageControlBlock::route_finder_, and foedus::storage::PageHeader::snapshot_.

Referenced by locate_record_for_read_batch().

                             {
  ASSERT_ND(batch_size <= kBatchMax);
  LookupRoute routes[kBatchMax];
  ArrayPage* root_page;
  CHECK_ERROR_CODE(get_root_page(context, false, &root_page));
  uint16_t levels = get_levels();
  bool root_snapshot = root_page->header().snapshot_;
  const uint16_t payload_size = get_payload_size();
  for (uint8_t i = 0; i < batch_size; ++i) {
    ASSERT_ND(offset_batch[i] < get_array_size());
    routes[i] = control_block_->route_finder_.find_route(offset_batch[i]);
    if (levels <= 1U) {
      assorted::prefetch_cacheline(root_page->get_leaf_record(
        routes[i].route[0],
        payload_size));
    } else {
      assorted::prefetch_cacheline(&root_page->get_interior_record(routes[i].route[levels - 1]));
    }
    out_batch[i] = root_page;
    snapshot_page_batch[i] = root_snapshot;
    ASSERT_ND(out_batch[i]->get_array_range().contains(offset_batch[i]));
    index_batch[i] = routes[i].route[levels - 1];
  }

  for (uint8_t level = levels - 1; level > 0; --level) {
    // note that we use out_batch as both input (parents) and output (the pages) here.
    // the method works in that case too.
    CHECK_ERROR_CODE(follow_pointers_for_read_batch(
      context,
      batch_size,
      snapshot_page_batch,
      out_batch,
      index_batch,
      out_batch));

    for (uint8_t i = 0; i < batch_size; ++i) {
      ASSERT_ND(snapshot_page_batch[i] == out_batch[i]->header().snapshot_);
      ASSERT_ND(out_batch[i]->get_storage_id() == get_id());
      ASSERT_ND(snapshot_page_batch[i]
        || !construct_volatile_page_pointer(out_batch[i]->header().page_id_).is_null());
      ASSERT_ND(!snapshot_page_batch[i]
        || extract_local_page_id_from_snapshot_pointer(out_batch[i]->header().page_id_));
      if (level == 1U) {
        assorted::prefetch_cacheline(out_batch[i]->get_leaf_record(
          routes[i].route[0],
          payload_size));
      } else {
        assorted::prefetch_cacheline(
          &out_batch[i]->get_interior_record(routes[i].route[levels - 1]));
      }
      index_batch[i] = routes[i].route[level - 1];
    }
  }
  for (uint8_t i = 0; i < batch_size; ++i) {
    ASSERT_ND(out_batch[i]->is_leaf());
    ASSERT_ND(out_batch[i]->get_array_range().contains(offset_batch[i]));
    ASSERT_ND(out_batch[i]->get_array_range().begin_ + routes[i].route[0] == offset_batch[i]);
    ASSERT_ND(index_batch[i] == routes[i].route[0]);
    ASSERT_ND(
      out_batch[i]->get_leaf_record(index_batch[i], payload_size)->owner_id_.xct_id_.is_valid());
  }
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::lookup_for_write ( thread::Thread *  context, ArrayOffset  offset, ArrayPage **  out, uint16_t *  index  )

inline

This version always returns a volatile page, installing a new one if needed.

Definition at line 574 of file array_storage_pimpl.cpp.

References ASSERT_ND, foedus::storage::array::ArrayRange::begin_, CHECK_ERROR_CODE, foedus::storage::array::ArrayRange::contains(), control_block_, exists(), foedus::storage::array::LookupRouteFinder::find_route(), follow_pointer(), foedus::storage::array::ArrayPage::get_array_range(), get_array_size(), foedus::storage::array::ArrayPage::get_interior_record(), foedus::storage::array::ArrayPage::get_leaf_record(), get_levels(), get_payload_size(), get_root_page(), foedus::storage::array::ArrayPage::header(), foedus::storage::array::ArrayPage::is_leaf(), foedus::xct::XctId::is_valid(), foedus::kErrorCodeOk, foedus::storage::Record::owner_id_, foedus::storage::array::ArrayStorageControlBlock::route_finder_, foedus::storage::PageHeader::snapshot_, and foedus::xct::RwLockableXctId::xct_id_.

Referenced by locate_record_for_write().

                   {
  ASSERT_ND(exists());
  ASSERT_ND(offset < get_array_size());
  ASSERT_ND(out);
  ASSERT_ND(index);
  ArrayPage* current_page;
  CHECK_ERROR_CODE(get_root_page(context, true, &current_page));
  ASSERT_ND(!current_page->header().snapshot_);
  uint16_t levels = get_levels();
  ASSERT_ND(current_page->get_array_range().contains(offset));
  LookupRoute route = control_block_->route_finder_.find_route(offset);
  for (uint8_t level = levels - 1; level > 0; --level) {
    ASSERT_ND(current_page->get_array_range().contains(offset));
    CHECK_ERROR_CODE(follow_pointer(
      context,
      false,
      true,
      &current_page->get_interior_record(route.route[level]),
      &current_page,
      current_page,
      route.route[level]));
  }
  ASSERT_ND(current_page->is_leaf());
  ASSERT_ND(current_page->get_array_range().contains(offset));
  ASSERT_ND(current_page->get_array_range().begin_ + route.route[0] == offset);
  ASSERT_ND(current_page->get_leaf_record(0, get_payload_size())->owner_id_.xct_id_.is_valid());
  *out = current_page;
  *index = route.route[0];
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::lookup_for_write_batch ( thread::Thread *  context, uint16_t  batch_size, const ArrayOffset *  offset_batch, Record **  record_batch  )

inline

Definition at line 864 of file array_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::storage::construct_volatile_page_pointer(), control_block_, foedus::storage::array::LookupRouteFinder::find_route(), follow_pointers_for_write_batch(), get_array_size(), get_id(), foedus::storage::array::ArrayPage::get_interior_record(), foedus::storage::array::ArrayPage::get_leaf_record(), get_levels(), get_payload_size(), get_root_page(), foedus::storage::array::ArrayPage::header(), kBatchMax, foedus::kErrorCodeOk, foedus::assorted::prefetch_cacheline(), foedus::storage::array::LookupRoute::route, foedus::storage::array::ArrayStorageControlBlock::route_finder_, and foedus::storage::PageHeader::snapshot_.

Referenced by get_record_for_write_batch().

                         {
  ASSERT_ND(batch_size <= kBatchMax);
  ArrayPage* pages[kBatchMax];
  LookupRoute routes[kBatchMax];
  uint16_t index_batch[kBatchMax];
  ArrayPage* root_page;
  CHECK_ERROR_CODE(get_root_page(context, true, &root_page));
  ASSERT_ND(!root_page->header().snapshot_);
  uint16_t levels = get_levels();
  const uint16_t payload_size = get_payload_size();

  for (uint8_t i = 0; i < batch_size; ++i) {
    ASSERT_ND(offset_batch[i] < get_array_size());
    routes[i] = control_block_->route_finder_.find_route(offset_batch[i]);
    if (levels <= 1U) {
      assorted::prefetch_cacheline(root_page->get_leaf_record(
        routes[i].route[0],
        payload_size));
    } else {
      assorted::prefetch_cacheline(&root_page->get_interior_record(routes[i].route[levels - 1]));
    }
    pages[i] = root_page;
    ASSERT_ND(pages[i]->get_array_range().contains(offset_batch[i]));
    index_batch[i] = routes[i].route[levels - 1];
  }

  for (uint8_t level = levels - 1; level > 0; --level) {
    // as noted above, in==out case.
    CHECK_ERROR_CODE(follow_pointers_for_write_batch(
      context,
      batch_size,
      pages,
      index_batch,
      pages));

    for (uint8_t i = 0; i < batch_size; ++i) {
      ASSERT_ND(!pages[i]->header().snapshot_);
      ASSERT_ND(pages[i]->get_storage_id() == get_id());
      ASSERT_ND(!construct_volatile_page_pointer(pages[i]->header().page_id_).is_null());
      if (level == 1U) {
        assorted::prefetch_cacheline(pages[i]->get_leaf_record(
          routes[i].route[0],
          payload_size));
      } else {
        assorted::prefetch_cacheline(
          &pages[i]->get_interior_record(routes[i].route[levels - 1]));
      }
      index_batch[i] = routes[i].route[level - 1];
    }
  }

  for (uint8_t i = 0; i < batch_size; ++i) {
    ASSERT_ND(pages[i]->is_leaf());
    ASSERT_ND(pages[i]->get_array_range().contains(offset_batch[i]));
    ASSERT_ND(pages[i]->get_array_range().begin_ + routes[i].route[0] == offset_batch[i]);
    ASSERT_ND(index_batch[i] == routes[i].route[0]);
    record_batch[i] = pages[i]->get_leaf_record(routes[i].route[0], payload_size);
  }
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::overwrite_record ( thread::Thread *  context, ArrayOffset  offset, const void *  payload, uint16_t  payload_offset, uint16_t  payload_count  )

inline

Definition at line 432 of file array_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, get_payload_size(), and locate_record_for_write().

Referenced by foedus::storage::array::ArrayStorage::overwrite_record().

                                                                            {
  ASSERT_ND(payload_offset + payload_count <= get_payload_size());
  Record *record = nullptr;
  CHECK_ERROR_CODE(locate_record_for_write(context, offset, &record));
  return overwrite_record(context, offset, record, payload, payload_offset, payload_count);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::overwrite_record ( thread::Thread *  context, ArrayOffset  offset, Record *  record, const void *  payload, uint16_t  payload_offset, uint16_t  payload_count  )

inline

Definition at line 449 of file array_storage_pimpl.cpp.

References foedus::xct::Xct::add_to_write_set(), foedus::storage::array::ArrayOverwriteLogType::calculate_log_length(), foedus::thread::Thread::get_current_xct(), get_id(), foedus::thread::Thread::get_thread_log_buffer(), foedus::storage::Record::owner_id_, foedus::storage::Record::payload_, foedus::storage::array::ArrayOverwriteLogType::populate(), and foedus::log::ThreadLogBuffer::reserve_new_log().

                          {
  uint16_t log_length = ArrayOverwriteLogType::calculate_log_length(payload_count);
  ArrayOverwriteLogType* log_entry = reinterpret_cast<ArrayOverwriteLogType*>(
    context->get_thread_log_buffer().reserve_new_log(log_length));
  log_entry->populate(get_id(), offset, payload, payload_offset, payload_count);
  return context->get_current_xct().add_to_write_set(
    get_id(),
    &record->owner_id_,
    record->payload_,
    log_entry);
}

Here is the call graph for this function:

template<typename T >

ErrorCode foedus::storage::array::ArrayStoragePimpl::overwrite_record_primitive	(	thread::Thread *	context,
		ArrayOffset	offset,
		T	payload,
		uint16_t	payload_offset
	)

Definition at line 441 of file array_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, get_payload_size(), and locate_record_for_write().

Referenced by foedus::storage::array::ArrayStorage::overwrite_record_primitive().

                                                                                     {
  ASSERT_ND(payload_offset + sizeof(T) <= get_payload_size());
  Record *record = nullptr;
  CHECK_ERROR_CODE(locate_record_for_write(context, offset, &record));
  return overwrite_record_primitive<T>(context, offset, record, payload, payload_offset);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

ErrorCode foedus::storage::array::ArrayStoragePimpl::overwrite_record_primitive ( thread::Thread *  context, ArrayOffset  offset, Record *  record, T  payload, uint16_t  payload_offset  )

inline

Definition at line 468 of file array_storage_pimpl.cpp.

References foedus::xct::Xct::add_to_write_set(), foedus::storage::array::ArrayOverwriteLogType::calculate_log_length(), foedus::thread::Thread::get_current_xct(), get_id(), foedus::thread::Thread::get_thread_log_buffer(), foedus::storage::Record::owner_id_, foedus::storage::Record::payload_, foedus::storage::array::ArrayOverwriteLogType::populate_primitive(), and foedus::log::ThreadLogBuffer::reserve_new_log().

                           {
  uint16_t log_length = ArrayOverwriteLogType::calculate_log_length(sizeof(T));
  ArrayOverwriteLogType* log_entry = reinterpret_cast<ArrayOverwriteLogType*>(
    context->get_thread_log_buffer().reserve_new_log(log_length));
  log_entry->populate_primitive<T>(get_id(), offset, payload, payload_offset);
  return context->get_current_xct().add_to_write_set(
    get_id(),
    &record->owner_id_,
    record->payload_,
    log_entry);
}

Here is the call graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::prefetch_pages	(	thread::Thread *	context,
		bool	install_volatile,
		bool	cache_snapshot,
		ArrayOffset	from,
		ArrayOffset	to
	)

defined in array_storage_prefetch.cpp

Definition at line 31 of file array_storage_prefetch.cpp.

References CHECK_ERROR_CODE, foedus::debugging::StopWatch::elapsed_us(), get_meta(), get_root_page(), foedus::thread::Thread::get_thread_id(), foedus::storage::array::ArrayPage::is_leaf(), foedus::kErrorCodeOk, foedus::storage::Metadata::name_, foedus::storage::prefetch_page_l2(), prefetch_pages_recurse(), and foedus::debugging::StopWatch::stop().

Referenced by foedus::storage::array::ArrayStorage::prefetch_pages().

                  {
  debugging::StopWatch watch;
  VLOG(0) << "Thread-" << context->get_thread_id()
    << " prefetching " << get_meta().name_ << " from=" << from << ", to=" << to;
  ArrayPage* root_page;
  CHECK_ERROR_CODE(get_root_page(context, vol_on, &root_page));
  prefetch_page_l2(root_page);
  if (!root_page->is_leaf()) {
    CHECK_ERROR_CODE(prefetch_pages_recurse(context, vol_on, snp_on, from, to, root_page));
  }

  watch.stop();
  VLOG(0) << "Thread-" << context->get_thread_id()
    << " prefetched " << get_meta().name_ << " in " << watch.elapsed_us() << "us";
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::array::ArrayStoragePimpl::prefetch_pages_recurse	(	thread::Thread *	context,
		bool	install_volatile,
		bool	cache_snapshot,
		ArrayOffset	from,
		ArrayOffset	to,
		ArrayPage *	page
	)

Definition at line 53 of file array_storage_prefetch.cpp.

References ASSERT_ND, foedus::storage::array::ArrayRange::begin_, CHECK_ERROR_CODE, control_block_, foedus::storage::array::ArrayRange::end_, foedus::thread::Thread::find_or_read_a_snapshot_page(), foedus::storage::array::ArrayPage::get_array_range(), foedus::storage::array::ArrayPage::get_interior_record(), foedus::storage::array::ArrayPage::get_level(), foedus::storage::array::LookupRouteFinder::get_records_in_leaf(), foedus::storage::array::ArrayPage::header(), foedus::thread::Thread::install_a_volatile_page(), foedus::storage::VolatilePagePointer::is_null(), foedus::kErrorCodeOk, foedus::storage::array::kInteriorFanout, foedus::storage::array::ArrayRange::overlaps(), foedus::storage::prefetch_page_l2(), foedus::thread::Thread::resolve_cast(), foedus::storage::array::ArrayStorageControlBlock::route_finder_, foedus::storage::PageHeader::snapshot_, foedus::storage::DualPagePointer::snapshot_pointer_, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by prefetch_pages().

                   {
  ASSERT_ND(!page->header().snapshot_ || !vol_on);
  uint8_t level = page->get_level();
  ASSERT_ND(level > 0);
  ArrayOffset interval = control_block_->route_finder_.get_records_in_leaf();
  for (uint8_t i = 1; i < level; ++i) {
    interval *= kInteriorFanout;
  }
  bool in_snapshot = page->header().snapshot_;
  ArrayRange page_range = page->get_array_range();
  ArrayRange range(from, to);
  ASSERT_ND(page_range.overlaps(range));  // otherwise why we came here...
  ASSERT_ND(page_range.begin_ + (interval * kInteriorFanout) >= page_range.end_);  // probably==
  for (uint16_t i = 0; i < kInteriorFanout; ++i) {
    ArrayRange child_range(
      page_range.begin_ + i * interval,
      page_range.begin_ + (i + 1U) * interval);
    if (!range.overlaps(child_range)) {
      continue;
    }

    DualPagePointer& pointer = page->get_interior_record(i);

    // first, do we have to cache snapshot page?
    if (pointer.snapshot_pointer_ != 0) {
      if (snp_on) {
        ArrayPage* child;
        CHECK_ERROR_CODE(context->find_or_read_a_snapshot_page(
          pointer.snapshot_pointer_,
          reinterpret_cast<Page**>(&child)));
        ASSERT_ND(child->get_array_range().begin_ == page_range.begin_ + i * interval);
        ASSERT_ND(range.overlaps(child->get_array_range()));
        prefetch_page_l2(child);
        if (level > 1U) {
          CHECK_ERROR_CODE(prefetch_pages_recurse(context, false, snp_on, from, to, child));
        }
      }
      // do we have to install volatile page based on it?
      if (pointer.volatile_pointer_.is_null() && vol_on && !in_snapshot) {
        ArrayPage* child;
        CHECK_ERROR_CODE(context->install_a_volatile_page(
          &pointer,
          reinterpret_cast<Page**>(&child)));
        ASSERT_ND(child->get_array_range().begin_ == page_range.begin_ + i * interval);
        ASSERT_ND(range.overlaps(child->get_array_range()));
      }
    }

    // then go down
    if (vol_on && !pointer.volatile_pointer_.is_null()) {
      ASSERT_ND(!in_snapshot);
      ArrayPage* child = context->resolve_cast<ArrayPage>(pointer.volatile_pointer_);
        ASSERT_ND(child->get_array_range().begin_ == page_range.begin_ + i * interval);
        ASSERT_ND(range.overlaps(child->get_array_range()));
      prefetch_page_l2(child);
      if (level > 1U) {
        CHECK_ERROR_CODE(prefetch_pages_recurse(context, vol_on, snp_on, from, to, child));
      }
    }
  }
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::array::ArrayStoragePimpl::release_pages_recursive ( const memory::GlobalVolatilePageResolver &  resolver, memory::PageReleaseBatch *  batch, VolatilePagePointer  volatile_page_id  )

static

Used only from drop()

Definition at line 207 of file array_storage_pimpl.cpp.

References ASSERT_ND, foedus::storage::VolatilePagePointer::is_null(), foedus::storage::array::kInteriorFanout, foedus::memory::PageReleaseBatch::release(), foedus::memory::GlobalVolatilePageResolver::resolve_offset(), foedus::storage::DualPagePointer::volatile_pointer_, and foedus::storage::VolatilePagePointer::word.

Referenced by foedus::storage::array::ArrayStorage::drop().

                                        {
  ASSERT_ND(!volatile_page_id.is_null());
  ArrayPage* page = reinterpret_cast<ArrayPage*>(resolver.resolve_offset(volatile_page_id));
  if (!page->is_leaf()) {
    for (uint16_t i = 0; i < kInteriorFanout; ++i) {
      DualPagePointer &child_pointer = page->get_interior_record(i);
      VolatilePagePointer child_page_id = child_pointer.volatile_pointer_;
      if (!child_page_id.is_null()) {
        // then recurse
        release_pages_recursive(resolver, batch, child_page_id);
        child_pointer.volatile_pointer_.word = 0;
      }
    }
  }
  batch->release(volatile_page_id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::array::ArrayStoragePimpl::report_page_distribution

(

)

ErrorStack foedus::storage::array::ArrayStoragePimpl::verify_single_thread

(

thread::Thread *

context

)

Definition at line 932 of file array_storage_pimpl.cpp.

References get_root_page(), and WRAP_ERROR_CODE.

Referenced by verify_single_thread(), and foedus::storage::array::ArrayStorage::verify_single_thread().

                                                                        {
  ArrayPage* root;
  WRAP_ERROR_CODE(get_root_page(context, false, &root));
  return verify_single_thread(context, root);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::array::ArrayStoragePimpl::verify_single_thread	(	thread::Thread *	context,
		ArrayPage *	page
	)

Definition at line 937 of file array_storage_pimpl.cpp.

References CHECK_AND_ASSERT, CHECK_ERROR, foedus::thread::Thread::get_global_volatile_page_resolver(), foedus::storage::array::ArrayPage::get_interior_record(), foedus::storage::array::ArrayPage::get_leaf_record(), foedus::storage::array::ArrayPage::get_leaf_record_count(), get_payload_size(), foedus::xct::McsRwLock::get_tail_waiter(), foedus::xct::McsRwLock::get_tail_waiter_block(), foedus::xct::RwLockableXctId::is_being_written(), foedus::xct::RwLockableXctId::is_deleted(), foedus::xct::RwLockableXctId::is_keylocked(), foedus::storage::array::ArrayPage::is_leaf(), foedus::xct::RwLockableXctId::is_moved(), foedus::storage::VolatilePagePointer::is_null(), foedus::storage::array::kInteriorFanout, foedus::kRetOk, foedus::xct::RwLockableXctId::lock_, foedus::storage::Record::owner_id_, foedus::memory::GlobalVolatilePageResolver::resolve_offset(), verify_single_thread(), and foedus::storage::DualPagePointer::volatile_pointer_.

                                                                                         {
  const memory::GlobalVolatilePageResolver& resolver = context->get_global_volatile_page_resolver();
  if (page->is_leaf()) {
    for (uint16_t i = 0; i < page->get_leaf_record_count(); ++i) {
      Record* record = page->get_leaf_record(i, get_payload_size());
      CHECK_AND_ASSERT(!record->owner_id_.is_being_written());
      CHECK_AND_ASSERT(!record->owner_id_.is_deleted());
      CHECK_AND_ASSERT(!record->owner_id_.is_keylocked());
      CHECK_AND_ASSERT(!record->owner_id_.is_moved());
      CHECK_AND_ASSERT(record->owner_id_.lock_.get_tail_waiter() == 0);
      CHECK_AND_ASSERT(record->owner_id_.lock_.get_tail_waiter_block() == 0);
    }
  } else {
    for (uint16_t i = 0; i < kInteriorFanout; ++i) {
      DualPagePointer &child_pointer = page->get_interior_record(i);
      VolatilePagePointer page_id = child_pointer.volatile_pointer_;
      if (!page_id.is_null()) {
        // then recurse
        ArrayPage* child_page = reinterpret_cast<ArrayPage*>(resolver.resolve_offset(page_id));
        CHECK_ERROR(verify_single_thread(context, child_page));
      }
    }
  }
  return kRetOk;
}

Here is the call graph for this function:

Member Data Documentation

ArrayStorageControlBlock* const foedus::storage::array::ArrayStoragePimpl::control_block_

Definition at line 301 of file array_storage_pimpl.hpp.

Referenced by create(), exists(), get_levels(), get_meta(), get_root_page(), hcc_reset_all_temperature_stat(), load(), load_empty(), lookup_for_read(), lookup_for_read_batch(), lookup_for_write(), lookup_for_write_batch(), and prefetch_pages_recurse().

Engine* const foedus::storage::array::ArrayStoragePimpl::engine_

Definition at line 300 of file array_storage_pimpl.hpp.

Referenced by hcc_reset_all_temperature_stat(), hcc_reset_all_temperature_stat_intermediate(), load(), and load_empty().

---

The documentation for this class was generated from the following files:

• /home/shino/foedus_code/foedus-core/include/foedus/storage/array/array_storage_pimpl.hpp
• /home/shino/foedus_code/foedus-core/src/foedus/storage/array/array_storage_pimpl.cpp
• /home/shino/foedus_code/foedus-core/src/foedus/storage/array/array_storage_prefetch.cpp