Represents one data page in Sequential Storage. More...

Detailed Description

Represents one data page in Sequential Storage.

In Sequential Storage, every data page is a leaf page that forms a singly linked list. So simple.

Page Layout: See Page Layout

This is a private implementation-details of Sequential Storage, thus file name ends with _impl. Do not include this header from a client program unless you know what you are doing.

Attention: Do NOT instantiate this object or derive from this class. A page is always reinterpret-ed from a pooled memory region. No meaningful RTTI.

Definition at line 53 of file sequential_page_impl.hpp.

#include <sequential_page_impl.hpp>

Public Member Functions
	SequentialPage ()=delete

	SequentialPage (const SequentialPage &other)=delete

SequentialPage &	operator= (const SequentialPage &other)=delete

PageHeader &	header ()

const PageHeader &	header () const

uint16_t	get_record_count () const
	Returns how many records in this page placed so far. More...

uint16_t	get_used_data_bytes () const
	How many data bytes in this page consumed so far. More...

void	assert_consistent () const

uint16_t	get_payload_length (uint16_t record) const
	Returns byte length of payload of the specified record in this page. More...

void	set_payload_length (uint16_t record, uint16_t length)
	Sets byte length of payload of the specified record in this page. More...

uint16_t	get_record_length (uint16_t record) const
	Returns byte length of the specified record in this page. More...

void	get_all_records_nosync (uint16_t record_count, const char record_pointers, uint16_t payload_lengthes) const
	Retrieve positions and lengthes of all records in one batch. More...

uint16_t	get_record_offset (uint16_t record) const
	Returns beginning offset of the specified record. More...

DualPagePointer &	next_page ()

const DualPagePointer &	next_page () const

void	initialize_volatile_page (StorageId storage_id, VolatilePagePointer page_id)
	Called only when this page is initialized. More...

void	initialize_snapshot_page (StorageId storage_id, SnapshotPagePointer page_id)

void	append_record_nosync (xct::XctId owner_id, uint16_t payload_length, const void *payload)
	Appends a record to this page. More...

bool	can_insert_record (uint16_t payload_length) const
	Returns if this page has enough room to insert a record with the given payload length. More...

Epoch	get_first_record_epoch () const
	Returns the epoch of the fist record in this page (undefined behavior if no record). More...

xct::RwLockableXctId *	owner_id_from_offset (uint16_t offset)

const xct::RwLockableXctId *	owner_id_from_offset (uint16_t offset) const

uint32_t	unused_dummy_func_filler () const

Constructor & Destructor Documentation

foedus::storage::sequential::SequentialPage::SequentialPage ( )

delete

foedus::storage::sequential::SequentialPage::SequentialPage ( const SequentialPage & other )

delete

Member Function Documentation

void foedus::storage::sequential::SequentialPage::append_record_nosync	(	xct::XctId	owner_id,
		uint16_t	payload_length,
		const void *	payload
	)

inline

Appends a record to this page.

This method assumes that there is no concurrent thread modifying this page (that's how we write both volatile and snapshot pages) and that the page has enough space.

Definition at line 155 of file sequential_page_impl.hpp.

References foedus::assorted::align8(), assert_consistent(), ASSERT_ND, get_record_count(), foedus::storage::PageVersionStatus::increment_version_counter(), foedus::storage::sequential::kDataSize, foedus::storage::PageHeader::key_count_, foedus::storage::sequential::kMaxSlots, foedus::storage::kRecordOverhead, foedus::xct::RwLockableXctId::lock_, foedus::assorted::memory_fence_release(), owner_id_from_offset(), foedus::storage::PageHeader::page_version_, foedus::xct::McsRwLock::reset(), set_payload_length(), foedus::storage::PageHeader::snapshot_, foedus::storage::PageVersion::status_, and foedus::xct::RwLockableXctId::xct_id_.

Referenced by foedus::storage::sequential::SequentialStoragePimpl::append_record(), and foedus::storage::sequential::SequentialComposer::compose().

                          {
     uint16_t record = get_record_count();
     ASSERT_ND(record < kMaxSlots);
     ASSERT_ND(used_data_bytes_ + assorted::align8(payload_length) + kRecordOverhead <= kDataSize);
     set_payload_length(record, payload_length);
     xct::RwLockableXctId* owner_id_addr = owner_id_from_offset(used_data_bytes_);
     owner_id_addr->xct_id_ = owner_id;
     owner_id_addr->lock_.reset();  // not used...
     std::memcpy(data_ + used_data_bytes_ + kRecordOverhead, payload, payload_length);
     ++record_count_;
     used_data_bytes_ += assorted::align8(payload_length) + kRecordOverhead;
     header_.key_count_ = record_count_;
     if (!header_.snapshot_) {
       // to protect concurrent cursor, version counter must be written at last
       assorted::memory_fence_release();
     }
     // no need for lock to increment, just a barrier suffices. directly call status_.increment.
     header_.page_version_.status_.increment_version_counter();
     assert_consistent();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::sequential::SequentialPage::assert_consistent ( ) const

inline

Definition at line 81 of file sequential_page_impl.hpp.

References ASSERT_ND, get_record_count(), get_used_data_bytes(), and foedus::storage::sequential::kDataSize.

Referenced by append_record_nosync(), get_all_records_nosync(), get_payload_length(), get_record_offset(), and set_payload_length().

                                                 {
     ASSERT_ND(get_used_data_bytes() + get_record_count() * sizeof(PayloadLength) <= kDataSize);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::storage::sequential::SequentialPage::can_insert_record ( uint16_t payload_length ) const

inline

Returns if this page has enough room to insert a record with the given payload length.

This method does not guarantee if you can really insert it due to concurrent appends. Thus, this method should be followed by append_record, which does real check and insert.

Definition at line 184 of file sequential_page_impl.hpp.

References foedus::assorted::align8(), foedus::storage::sequential::kDataSize, foedus::storage::sequential::kMaxSlots, and foedus::storage::kRecordOverhead.

Referenced by foedus::storage::sequential::SequentialStoragePimpl::append_record(), and foedus::storage::sequential::SequentialComposer::compose().

                                                                        {
     uint16_t record_length = assorted::align8(payload_length) + kRecordOverhead;
     return used_data_bytes_ + record_length
       + sizeof(PayloadLength) * (record_count_ + 1) <= kDataSize && record_count_ < kMaxSlots;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::sequential::SequentialPage::get_all_records_nosync	(	uint16_t *	record_count,
		const char **	record_pointers,
		uint16_t *	payload_lengthes
	)		const

inline

Retrieve positions and lengthes of all records in one batch.

Definition at line 105 of file sequential_page_impl.hpp.

References foedus::assorted::align8(), assert_consistent(), get_payload_length(), get_record_count(), and foedus::storage::kRecordOverhead.

                                       {
     assert_consistent();
     *record_count = get_record_count();
     uint16_t position = 0;
     for (uint16_t i = 0; i < *record_count; ++i) {
       record_pointers[i] = data_ + position;
       payload_lengthes[i] = get_payload_length(i);
       position += assorted::align8(payload_lengthes[i]) + foedus::storage::kRecordOverhead;
     }
   }

Here is the call graph for this function:

Epoch foedus::storage::sequential::SequentialPage::get_first_record_epoch ( ) const

inline

Returns the epoch of the fist record in this page (undefined behavior if no record).

Precondition: get_record_count()

Definition at line 193 of file sequential_page_impl.hpp.

References ASSERT_ND, foedus::xct::XctId::get_epoch(), get_record_count(), owner_id_from_offset(), and foedus::xct::RwLockableXctId::xct_id_.

Referenced by foedus::storage::sequential::SequentialStoragePimpl::append_record(), and foedus::storage::sequential::SequentialComposer::drop_volatiles().

                                                      {
     ASSERT_ND(get_record_count() > 0);
     const xct::RwLockableXctId* first_owner_id = owner_id_from_offset(0);
     return first_owner_id->xct_id_.get_epoch();
   }

Here is the call graph for this function:

Here is the caller graph for this function:

uint16_t foedus::storage::sequential::SequentialPage::get_payload_length ( uint16_t record ) const

inline

Returns byte length of payload of the specified record in this page.

Definition at line 86 of file sequential_page_impl.hpp.

References assert_consistent(), ASSERT_ND, get_record_count(), and foedus::storage::sequential::kDataSize.

Referenced by get_all_records_nosync(), get_record_length(), and get_record_offset().

                                                                  {
     ASSERT_ND(record < get_record_count());
     assert_consistent();
     const PayloadLength* lengthes = reinterpret_cast<const PayloadLength*>(data_ + kDataSize);
     PayloadLength length = *(lengthes - 1 - record);
     return length;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

uint16_t foedus::storage::sequential::SequentialPage::get_record_count ( ) const

inline

Returns how many records in this page placed so far.

Monotonically increasing. When the page becomes full, we go on to next page.

Invariant: 0 <= record count <= kMaxSlots

Note: this method might return a stale information on volatile page. Use barrier or atomic CAS when needed.

Definition at line 71 of file sequential_page_impl.hpp.

Referenced by foedus::storage::sequential::SequentialStoragePimpl::append_record(), append_record_nosync(), assert_consistent(), foedus::storage::sequential::SequentialComposer::drop_volatiles(), get_all_records_nosync(), get_first_record_epoch(), get_payload_length(), get_record_offset(), and foedus::storage::sequential::operator<<().

71 { return record_count_; }

Here is the caller graph for this function:

uint16_t foedus::storage::sequential::SequentialPage::get_record_length ( uint16_t record ) const

inline

Returns byte length of the specified record in this page.

Definition at line 100 of file sequential_page_impl.hpp.

References get_payload_length(), and foedus::storage::kRecordOverhead.

                                                                 {
     return get_payload_length(record) + foedus::storage::kRecordOverhead;
   }

Here is the call graph for this function:

uint16_t foedus::storage::sequential::SequentialPage::get_record_offset ( uint16_t record ) const

inline

Returns beginning offset of the specified record.

Definition at line 119 of file sequential_page_impl.hpp.

References foedus::assorted::align8(), assert_consistent(), ASSERT_ND, get_payload_length(), get_record_count(), and foedus::storage::kRecordOverhead.

                                                                {
     assert_consistent();
     ASSERT_ND(record < get_record_count());
     uint16_t offset = 0;
     for (uint16_t i = 0; i < record; ++i) {
       uint16_t payload_length = get_payload_length(i);
       offset += assorted::align8(payload_length) + foedus::storage::kRecordOverhead;
     }
     return offset;
   }

Here is the call graph for this function:

uint16_t foedus::storage::sequential::SequentialPage::get_used_data_bytes ( ) const

inline

How many data bytes in this page consumed so far.

Monotonically increasing. When the page becomes full, we go on to next page.

Invariant: 0 <= used data bytes <= kDataSize

Note: this method might return a stale information on volatile page. Use barrier or atomic CAS when needed.

Definition at line 79 of file sequential_page_impl.hpp.

Referenced by assert_consistent().

79 { return used_data_bytes_; }

Here is the caller graph for this function:

PageHeader& foedus::storage::sequential::SequentialPage::header ( )

inline

Definition at line 61 of file sequential_page_impl.hpp.

Referenced by foedus::storage::sequential::SequentialComposer::compose().

61 { return header_; }

Here is the caller graph for this function:

const PageHeader& foedus::storage::sequential::SequentialPage::header ( ) const

inline

Definition at line 62 of file sequential_page_impl.hpp.

62 { return header_; }

void foedus::storage::sequential::SequentialPage::initialize_snapshot_page	(	StorageId	storage_id,
		SnapshotPagePointer	page_id
	)

inline

Definition at line 141 of file sequential_page_impl.hpp.

References foedus::storage::PageHeader::init_snapshot(), foedus::storage::kSequentialPageType, foedus::storage::DualPagePointer::snapshot_pointer_, foedus::storage::DualPagePointer::volatile_pointer_, and foedus::storage::VolatilePagePointer::word.

Referenced by foedus::storage::sequential::SequentialComposer::compose().

                                                                                                   {
     header_.init_snapshot(page_id, storage_id, kSequentialPageType);
     record_count_ = 0;
     used_data_bytes_ = 0;
     next_page_.snapshot_pointer_ = 0;
     next_page_.volatile_pointer_.word = 0;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::sequential::SequentialPage::initialize_volatile_page	(	StorageId	storage_id,
		VolatilePagePointer	page_id
	)

inline

Called only when this page is initialized.

Definition at line 134 of file sequential_page_impl.hpp.

References foedus::storage::PageHeader::init_volatile(), foedus::storage::kSequentialPageType, foedus::storage::DualPagePointer::snapshot_pointer_, foedus::storage::DualPagePointer::volatile_pointer_, and foedus::storage::VolatilePagePointer::word.

Referenced by foedus::storage::sequential::SequentialStoragePimpl::append_record().

                                                                                                   {
     header_.init_volatile(page_id, storage_id, kSequentialPageType);
     record_count_ = 0;
     used_data_bytes_ = 0;
     next_page_.snapshot_pointer_ = 0;
     next_page_.volatile_pointer_.word = 0;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

DualPagePointer& foedus::storage::sequential::SequentialPage::next_page ( )

inline

Definition at line 130 of file sequential_page_impl.hpp.

Referenced by foedus::storage::sequential::SequentialStoragePimpl::append_record(), foedus::storage::sequential::SequentialComposer::compose(), and foedus::storage::sequential::SequentialComposer::drop_volatiles().

130 { return next_page_; }

Here is the caller graph for this function:

const DualPagePointer& foedus::storage::sequential::SequentialPage::next_page ( ) const

inline

Definition at line 131 of file sequential_page_impl.hpp.

131 { return next_page_; }

SequentialPage& foedus::storage::sequential::SequentialPage::operator= ( const SequentialPage & other )

delete

xct::RwLockableXctId* foedus::storage::sequential::SequentialPage::owner_id_from_offset ( uint16_t offset )

inline

Definition at line 199 of file sequential_page_impl.hpp.

Referenced by append_record_nosync(), and get_first_record_epoch().

                                                             {
     return reinterpret_cast<xct::RwLockableXctId*>(data_ + offset);
   }

Here is the caller graph for this function:

const xct::RwLockableXctId* foedus::storage::sequential::SequentialPage::owner_id_from_offset ( uint16_t offset ) const

inline

Definition at line 202 of file sequential_page_impl.hpp.

                                                                         {
     return reinterpret_cast<const xct::RwLockableXctId*>(data_ + offset);
   }

void foedus::storage::sequential::SequentialPage::set_payload_length	(	uint16_t	record,
		uint16_t	length
	)

inline

Sets byte length of payload of the specified record in this page.

Definition at line 94 of file sequential_page_impl.hpp.

References assert_consistent(), and foedus::storage::sequential::kDataSize.

Referenced by append_record_nosync().

                                                                            {
     assert_consistent();
     PayloadLength* lengthes = reinterpret_cast<PayloadLength*>(data_ + kDataSize);
     *(lengthes - 1 - record) = length;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32_t foedus::storage::sequential::SequentialPage::unused_dummy_func_filler ( ) const

inline

Definition at line 206 of file sequential_page_impl.hpp.

206 { return filler_; }

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

/home/shino/foedus_code/foedus-core/include/foedus/storage/sequential/sequential_page_impl.hpp

Detailed Description

Public Member Functions

Constructor & Destructor Documentation

Member Function Documentation