Composer for an array storage. More...

Detailed Description

Composer for an array storage.

Note: This is a private implementation-details of Array Storage, thus file name ends with _impl. Do not include this header from a client program. There is no case client program needs to access this internal class.

Definition at line 51 of file array_composer_impl.hpp.

#include <array_composer_impl.hpp>

Public Member Functions
	ArrayComposer (Composer *parent)
	ArrayComposer methods. More...

std::string	to_string () const

ErrorStack	compose (const Composer::ComposeArguments &args)

ErrorStack	construct_root (const Composer::ConstructRootArguments &args)

Composer::DropResult	drop_volatiles (const Composer::DropVolatilesArguments &args)
	drop_volatiles and related methods More...

void	drop_root_volatile (const Composer::DropVolatilesArguments &args)

Constructor & Destructor Documentation

foedus::storage::array::ArrayComposer::ArrayComposer ( Composer * parent )

explicit

ArrayComposer methods.

Definition at line 59 of file array_composer_impl.cpp.

References ASSERT_ND, and foedus::storage::Storage< CONTROL_BLOCK >::exists().

   : engine_(parent->get_engine()),
     storage_id_(parent->get_storage_id()),
     storage_(engine_, storage_id_) {
   ASSERT_ND(storage_.exists());
 }

Here is the call graph for this function:

Member Function Documentation

ErrorStack foedus::storage::array::ArrayComposer::compose ( const Composer::ComposeArguments & args )

Definition at line 66 of file array_composer_impl.cpp.

References foedus::storage::Composer::ComposeArguments::base_epoch_, CHECK_ERROR, foedus::debugging::StopWatch::elapsed_ms(), foedus::DefaultInitializable::initialize(), foedus::storage::kArrayStorage, foedus::storage::array::kMaxLevels, foedus::kRetOk, foedus::storage::Composer::ComposeArguments::log_streams_, foedus::storage::Composer::ComposeArguments::log_streams_count_, foedus::storage::Composer::ComposeArguments::previous_snapshot_files_, foedus::storage::Composer::ComposeArguments::root_info_page_, foedus::storage::Composer::ComposeArguments::snapshot_writer_, foedus::debugging::StopWatch::stop(), to_string(), foedus::DefaultInitializable::uninitialize(), and foedus::storage::Composer::ComposeArguments::work_memory_.

Referenced by foedus::storage::Composer::compose().

                                                                       {
   VLOG(0) << to_string() << " composing with " << args.log_streams_count_ << " streams.";
   debugging::StopWatch stop_watch;
 
   snapshot::MergeSort merge_sort(
     storage_id_,
     kArrayStorage,
     args.base_epoch_,
     args.log_streams_,
     args.log_streams_count_,
     kMaxLevels,
     args.work_memory_);
   CHECK_ERROR(merge_sort.initialize());
 
   ArrayComposeContext context(
     engine_,
     &merge_sort,
     args.snapshot_writer_,
     args.previous_snapshot_files_,
     args.root_info_page_);
   CHECK_ERROR(context.execute());
 
   CHECK_ERROR(merge_sort.uninitialize());  // no need for scoped release. its destructor is safe.
 
   stop_watch.stop();
   LOG(INFO) << to_string() << " done in " << stop_watch.elapsed_ms() << "ms.";
   return kRetOk;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::array::ArrayComposer::construct_root ( const Composer::ConstructRootArguments & args )

Definition at line 95 of file array_composer_impl.cpp.

Referenced by foedus::storage::Composer::construct_root().

                                                                                    {
   // compose() created root_info_pages that contain pointers to fill in the root page,
   // so we just find non-zero entry and copy it to root page.
   uint8_t levels = storage_.get_levels();
   uint16_t payload_size = storage_.get_payload_size();
   snapshot::SnapshotId new_snapshot_id = args.snapshot_writer_->get_snapshot_id();
   Epoch system_initial_epoch = engine_->get_savepoint_manager()->get_initial_durable_epoch();
   if (levels == 1U) {
     // if it's single-page array, we have already created the root page in compose().
     ASSERT_ND(args.root_info_pages_count_ == 1U);
     const ArrayRootInfoPage* casted
       = reinterpret_cast<const ArrayRootInfoPage*>(args.root_info_pages_[0]);
     ASSERT_ND(casted->pointers_[0] != 0);
     *args.new_root_page_pointer_ = casted->pointers_[0];
 
     // and we have already installed it, right?
     ASSERT_ND(storage_.get_control_block()->meta_.root_snapshot_page_id_
       == casted->pointers_[0]);
     ASSERT_ND(storage_.get_control_block()->root_page_pointer_.snapshot_pointer_
       == casted->pointers_[0]);
   } else {
     ArrayPage* root_page = reinterpret_cast<ArrayPage*>(args.snapshot_writer_->get_page_base());
     SnapshotPagePointer page_id = storage_.get_metadata()->root_snapshot_page_id_;
     SnapshotPagePointer new_page_id = args.snapshot_writer_->get_next_page_id();
     *args.new_root_page_pointer_ = new_page_id;
 
     uint64_t root_interval = LookupRouteFinder(levels, payload_size).get_records_in_leaf();
     for (uint8_t level = 1; level < levels; ++level) {
       root_interval *= kInteriorFanout;
     }
     ArrayRange range(0, root_interval, storage_.get_array_size());
     if (page_id != 0) {
       WRAP_ERROR_CODE(args.previous_snapshot_files_->read_page(page_id, root_page));
       ASSERT_ND(root_page->header().storage_id_ == storage_id_);
       ASSERT_ND(root_page->header().page_id_ == page_id);
       ASSERT_ND(root_page->get_array_range() == range);
       root_page->header().page_id_ = new_page_id;
     } else {
       root_page->initialize_snapshot_page(
         system_initial_epoch,
         storage_id_,
         new_page_id,
         payload_size,
         levels - 1,
         range);
     }
 
     uint64_t child_interval = root_interval / kInteriorFanout;
     uint16_t root_children = assorted::int_div_ceil(storage_.get_array_size(), child_interval);
 
     // overwrite pointers with root_info_pages.
     for (uint32_t i = 0; i < args.root_info_pages_count_; ++i) {
       const ArrayRootInfoPage* casted
         = reinterpret_cast<const ArrayRootInfoPage*>(args.root_info_pages_[i]);
       for (uint16_t j = 0; j < root_children; ++j) {
         SnapshotPagePointer pointer = casted->pointers_[j];
         if (pointer != 0) {
           ASSERT_ND(extract_snapshot_id_from_snapshot_pointer(pointer) == new_snapshot_id);
           DualPagePointer& record = root_page->get_interior_record(j);
           // partitioning has no overlap, so this must be the only overwriting pointer
           ASSERT_ND(record.snapshot_pointer_ == 0 ||
             extract_snapshot_id_from_snapshot_pointer(record.snapshot_pointer_)
               != new_snapshot_id);
           record.snapshot_pointer_ = pointer;
         }
       }
       for (uint16_t j = root_children; j < kInteriorFanout; ++j) {
         ASSERT_ND(casted->pointers_[j] == 0);
       }
     }
 
     // even in initial snapshot, all pointers must be set because we create empty pages
     // even if some sub-tree receives no logs.
     for (uint16_t j = 0; j < root_children; ++j) {
       ASSERT_ND(root_page->get_interior_record(j).snapshot_pointer_ != 0);
     }
 
     WRAP_ERROR_CODE(args.snapshot_writer_->dump_pages(0, 1));
     ASSERT_ND(args.snapshot_writer_->get_next_page_id() == new_page_id + 1ULL);
     // AFTER writing out the root page, install the pointer to new root page
     storage_.get_control_block()->root_page_pointer_.snapshot_pointer_ = new_page_id;
     storage_.get_control_block()->meta_.root_snapshot_page_id_ = new_page_id;
   }
   return kRetOk;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::array::ArrayComposer::drop_root_volatile ( const Composer::DropVolatilesArguments & args )

Definition at line 971 of file array_composer_impl.cpp.

Referenced by foedus::storage::Composer::drop_root_volatile().

                                                                                  {
   if (storage_.get_array_metadata()->keeps_all_volatile_pages()) {
     LOG(INFO) << "Oh, but keep-all-volatile is on. Storage-" << storage_.get_name()
       << " is configured to keep all volatile pages.";
     return;
   }
   if (is_to_keep_volatile(storage_.get_levels() - 1U)) {
     LOG(INFO) << "Oh, but Storage-" << storage_.get_name() << " is configured to keep"
       << " the root page.";
     return;
   }
   DualPagePointer* root_pointer = &storage_.get_control_block()->root_page_pointer_;
   ArrayPage* volatile_page = resolve_volatile(root_pointer->volatile_pointer_);
   if (volatile_page == nullptr) {
     LOG(INFO) << "Oh, but root volatile page already null";
     return;
   }
 
   if (volatile_page->is_leaf()) {
     // if this is a single-level array. we now have to check epochs of records in the root page.
     uint16_t records = storage_.get_array_size();
     for (uint16_t i = 0; i < records; ++i) {
       Record* record = volatile_page->get_leaf_record(i, storage_.get_payload_size());
       Epoch epoch = record->owner_id_.xct_id_.get_epoch();
       ASSERT_ND(epoch.is_valid());
       if (epoch > args.snapshot_.valid_until_epoch_) {
         LOG(INFO) << "Oh, but the root volatile page in single-level array contains a new rec";
         return;
       }
     }
   } else {
     // otherwise, all verifications already done. go drop everything!
   }
   LOG(INFO) << "Okay, drop em all!!";
   drop_all_recurse(args, root_pointer);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Composer::DropResult foedus::storage::array::ArrayComposer::drop_volatiles ( const Composer::DropVolatilesArguments & args )

drop_volatiles and related methods

Definition at line 929 of file array_composer_impl.cpp.

References ASSERT_ND, foedus::storage::Composer::DropResult::combine(), foedus::storage::Composer::DropResult::dropped_all_, foedus::storage::extract_numa_node_from_snapshot_pointer(), foedus::storage::array::ArrayStorage::get_array_metadata(), foedus::Attachable< CONTROL_BLOCK >::get_control_block(), foedus::storage::array::ArrayPage::get_interior_record(), foedus::storage::Storage< CONTROL_BLOCK >::get_name(), foedus::storage::array::ArrayPage::is_leaf(), foedus::storage::VolatilePagePointer::is_null(), foedus::storage::Metadata::keeps_all_volatile_pages(), foedus::storage::array::kInteriorFanout, foedus::storage::Composer::DropVolatilesArguments::my_partition_, foedus::storage::Composer::DropVolatilesArguments::partitioned_drop_, foedus::storage::DualPagePointer::snapshot_pointer_, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by foedus::storage::Composer::drop_volatiles().

                                                                                            {
   Composer::DropResult result(args);
   if (storage_.get_array_metadata()->keeps_all_volatile_pages()) {
     LOG(INFO) << "Keep-all-volatile: Storage-" << storage_.get_name()
       << " is configured to keep all volatile pages.";
     result.dropped_all_ = false;
     return result;
   }
 
   DualPagePointer* root_pointer = &storage_.get_control_block()->root_page_pointer_;
   ArrayPage* volatile_page = resolve_volatile(root_pointer->volatile_pointer_);
   if (volatile_page == nullptr) {
     LOG(INFO) << "No volatile root page. Probably while restart";
     return result;
   }
 
   // single-page array has only the root page. nothing to do here.
   // we might drop the root page later, just like non-single-page cases.
   if (volatile_page->is_leaf()) {
     LOG(INFO) << "Single-page array skipped by .";
     return result;
   }
 
   // We iterate through all existing volatile pages to drop volatile pages of
   // level-3 or deeper (if the storage has only 2 levels, keeps all).
   // this "level-3 or deeper" is a configuration per storage.
   // Even if the volatile page is deeper than that, we keep them if it contains newer modification,
   // including descendants (so, probably we will keep higher levels anyways).
   for (uint16_t i = 0; i < kInteriorFanout; ++i) {
     DualPagePointer& child_pointer = volatile_page->get_interior_record(i);
     if (!child_pointer.volatile_pointer_.is_null()) {
       ASSERT_ND(child_pointer.snapshot_pointer_ != 0);
       uint16_t partition = extract_numa_node_from_snapshot_pointer(child_pointer.snapshot_pointer_);
       if (!args.partitioned_drop_ || partition == args.my_partition_) {
         result.combine(drop_volatiles_recurse(args, &child_pointer));
       }
     }
   }
   // root page is kept at this point in this case. we need to check with other threads
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string foedus::storage::array::ArrayComposer::to_string ( ) const

Definition at line 182 of file array_composer_impl.cpp.

Referenced by compose().

                                          {
   return std::string("ArrayComposer-") + std::to_string(storage_id_);
 }

Here is the caller graph for this function:

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

/home/shino/foedus_code/foedus-core/include/foedus/storage/array/array_composer_impl.hpp
/home/shino/foedus_code/foedus-core/src/foedus/storage/array/array_composer_impl.cpp

Detailed Description

Public Member Functions

Constructor & Destructor Documentation

Member Function Documentation