Current status of each input. More...

Detailed Description

Current status of each input.

"Current" means the first log that is not yet processed. "Chunk" means the last log in the current chunk to be batch-processed. "Previous chunk" is the previous chunk of this input in the same batch, thus all logs in the previous chunk are guaranteed to be smaller than the batch-threshold. "End" means the end of input.

Definition at line 167 of file merge_sort.hpp.

#include <merge_sort.hpp>

Public Member Functions
void	assert_consistent () const __attribute__((always_inline))

const log::RecordLogType *	get_cur_log () const __attribute__((always_inline))

const log::RecordLogType *	get_chunk_log () const __attribute__((always_inline))

const log::RecordLogType *	from_byte_pos (uint64_t pos) const __attribute__((always_inline))

const log::RecordLogType *	from_compact_pos (BufferPosition pos) const __attribute__((always_inline))

uint64_t	to_absolute_pos (uint64_t relative_pos) const __attribute__((always_inline))

bool	is_last_window () const __attribute__((always_inline))

bool	is_ended () const __attribute__((always_inline))

bool	is_last_chunk_in_window () const __attribute__((always_inline))

bool	is_last_chunk_overall () const __attribute__((always_inline))

Public Attributes
const char *	window_

uint64_t	cur_relative_pos_

uint64_t	chunk_relative_pos_

char	padding_ [6]

uint64_t	previous_chunk_relative_pos_

uint64_t	window_offset_
	relative pos counts from this offset More...

uint64_t	window_size_

uint64_t	end_absolute_pos_

Member Function Documentation

void foedus::snapshot::MergeSort::InputStatus::assert_consistent ( ) const

inline

Definition at line 181 of file merge_sort.hpp.

References ASSERT_ND, chunk_relative_pos_, foedus::log::BaseLogType::header_, and foedus::log::LogHeader::log_length_.

Referenced by from_byte_pos(), from_compact_pos(), get_chunk_log(), get_cur_log(), foedus::snapshot::MergeSort::initialize_once(), is_ended(), is_last_window(), and to_absolute_pos().

                                                         {
 #ifndef NDEBUG
       // be careful on infinite loop! don't call any function here
       ASSERT_ND(window_);
       ASSERT_ND(cur_relative_pos_ <= window_size_);
       ASSERT_ND(chunk_relative_pos_ <= window_size_);
       ASSERT_ND(previous_chunk_relative_pos_ <= window_size_);
       ASSERT_ND(window_offset_ <= end_absolute_pos_);
       ASSERT_ND(cur_relative_pos_ + window_offset_ <= end_absolute_pos_);
       ASSERT_ND(chunk_relative_pos_ + window_offset_ <= end_absolute_pos_);
       ASSERT_ND(previous_chunk_relative_pos_ + window_offset_ <= end_absolute_pos_);
       ASSERT_ND(cur_relative_pos_ <= chunk_relative_pos_);
       ASSERT_ND(previous_chunk_relative_pos_ <= chunk_relative_pos_);
       if (window_offset_ + cur_relative_pos_ != end_absolute_pos_) {
         const log::RecordLogType* l
           = reinterpret_cast<const log::RecordLogType*>(window_ + chunk_relative_pos_);
         ASSERT_ND(chunk_relative_pos_ + l->header_.log_length_ <= window_size_);
       }
 #endif  // NDEBUG
     }

Here is the caller graph for this function:

const log::RecordLogType* foedus::snapshot::MergeSort::InputStatus::from_byte_pos ( uint64_t pos ) const

inline

Definition at line 209 of file merge_sort.hpp.

References assert_consistent(), and ASSERT_ND.

                                                                                    {
       assert_consistent();
       ASSERT_ND(pos < window_size_);
       return reinterpret_cast<const log::RecordLogType*>(window_ + pos);
     }

Here is the call graph for this function:

const log::RecordLogType* foedus::snapshot::MergeSort::InputStatus::from_compact_pos ( BufferPosition pos ) const

inline

Definition at line 214 of file merge_sort.hpp.

References assert_consistent(), and ASSERT_ND.

Referenced by foedus::snapshot::MergeSort::fetch_logs(), foedus::snapshot::MergeSort::AdjustComparatorMasstree::operator()(), and foedus::snapshot::MergeSort::resolve_merged_position().

                                                                                             {
       assert_consistent();
       ASSERT_ND(pos * 8ULL < window_size_);
       return reinterpret_cast<const log::RecordLogType*>(window_ + pos * 8ULL);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

const log::RecordLogType* foedus::snapshot::MergeSort::InputStatus::get_chunk_log ( ) const

inline

Definition at line 205 of file merge_sort.hpp.

References assert_consistent(), and chunk_relative_pos_.

Referenced by is_last_chunk_in_window().

                                                                        {
       assert_consistent();
       return reinterpret_cast<const log::RecordLogType*>(window_ + chunk_relative_pos_);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

const log::RecordLogType* foedus::snapshot::MergeSort::InputStatus::get_cur_log ( ) const

inline

Definition at line 201 of file merge_sort.hpp.

References assert_consistent(), and cur_relative_pos_.

                                                                      {
       assert_consistent();
       return reinterpret_cast<const log::RecordLogType*>(window_ + cur_relative_pos_);
     }

Here is the call graph for this function:

bool foedus::snapshot::MergeSort::InputStatus::is_ended ( ) const

inline

Definition at line 227 of file merge_sort.hpp.

References assert_consistent(), end_absolute_pos_, and to_absolute_pos().

                                                {
       assert_consistent();
       return to_absolute_pos(cur_relative_pos_) == end_absolute_pos_;
     }

Here is the call graph for this function:

bool foedus::snapshot::MergeSort::InputStatus::is_last_chunk_in_window ( ) const

inline

Definition at line 231 of file merge_sort.hpp.

References ASSERT_ND, end_absolute_pos_, get_chunk_log(), foedus::log::BaseLogType::header_, is_last_window(), foedus::snapshot::MergeSort::kWindowChunkReserveBytes, foedus::log::LogHeader::log_length_, to_absolute_pos(), and window_size_.

Referenced by is_last_chunk_overall().

                                                               {
       if (is_last_window()) {
         // in last window, we accurately determines the last chunk
         uint64_t chunk_abs_pos = to_absolute_pos(chunk_relative_pos_);
         ASSERT_ND(chunk_abs_pos <= end_absolute_pos_);
         if (chunk_abs_pos >= end_absolute_pos_) {
           return true;
         }
         uint16_t length = get_chunk_log()->header_.log_length_;
         ASSERT_ND(length > 0);
         ASSERT_ND(chunk_abs_pos + length <= end_absolute_pos_);
         return chunk_abs_pos + length >= end_absolute_pos_;
       } else {
         // in this case, we conservatively determines the last chunk
         return chunk_relative_pos_ + kWindowChunkReserveBytes >= window_size_;
       }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::snapshot::MergeSort::InputStatus::is_last_chunk_overall ( ) const

inline

Definition at line 248 of file merge_sort.hpp.

References is_last_chunk_in_window(), and is_last_window().

                                                             {
       return is_last_window() && is_last_chunk_in_window();
     }

Here is the call graph for this function:

bool foedus::snapshot::MergeSort::InputStatus::is_last_window ( ) const

inline

Definition at line 223 of file merge_sort.hpp.

References assert_consistent(), end_absolute_pos_, and to_absolute_pos().

Referenced by is_last_chunk_in_window(), and is_last_chunk_overall().

                                                      {
       assert_consistent();
       return to_absolute_pos(window_size_) >= end_absolute_pos_;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

uint64_t foedus::snapshot::MergeSort::InputStatus::to_absolute_pos ( uint64_t relative_pos ) const

inline

Definition at line 219 of file merge_sort.hpp.

References assert_consistent().

Referenced by is_ended(), is_last_chunk_in_window(), and is_last_window().

                                                                                {
       assert_consistent();
       return window_offset_ + relative_pos;
     }