Represents a Masstree storage. More...

Detailed Description

Represents a Masstree storage.

Definition at line 43 of file masstree_storage.hpp.

#include <masstree_storage.hpp>

Inheritance diagram for foedus::storage::masstree::MasstreeStorage:

[legend]

Collaboration diagram for foedus::storage::masstree::MasstreeStorage:

[legend]

Classes
struct	PeekBoundariesArguments
	Arguments for peek_volatile_page_boundaries() More...

Public Types
typedef MasstreeStoragePimpl	ThisPimpl

typedef MasstreeCreateLogType	ThisCreateLogType

typedef MasstreeMetadata	ThisMetadata

Public Member Functions
	MasstreeStorage ()

	MasstreeStorage (Engine engine, MasstreeStorageControlBlock control_block)

	MasstreeStorage (Engine engine, StorageControlBlock control_block)

	MasstreeStorage (Engine *engine, StorageId id)

	MasstreeStorage (Engine *engine, const StorageName &name)

	MasstreeStorage (const MasstreeStorage &other)

MasstreeStorage &	operator= (const MasstreeStorage &other)

const MasstreeMetadata *	get_masstree_metadata () const

ErrorStack	create (const Metadata &metadata)

ErrorStack	load (const StorageControlBlock &snapshot_block)

ErrorStack	drop ()

ErrorCode	prefetch_pages_normalized (thread::Thread *context, bool install_volatile, bool cache_snapshot, KeySlice from=kInfimumSlice, KeySlice to=kSupremumSlice)
	Prefetch data pages in this storage. More...

xct::TrackMovedRecordResult	track_moved_record (xct::RwLockableXctId old_address, xct::WriteXctAccess write_set)
	Resolves a "moved" record. More...

ErrorCode	get_record (thread::Thread context, const void key, KeyLength key_length, void payload, PayloadLength payload_capacity, bool read_only)
	Retrieves an entire record of the given key in this Masstree. More...

ErrorCode	get_record_part (thread::Thread context, const void key, KeyLength key_length, void *payload, PayloadLength payload_offset, PayloadLength payload_count, bool read_only)
	Retrieves a part of the given key in this Masstree. More...

template<typename PAYLOAD >
ErrorCode	get_record_primitive (thread::Thread context, const void key, KeyLength key_length, PAYLOAD *payload, PayloadLength payload_offset, bool read_only)
	Retrieves a part of the given key in this Masstree as a primitive value. More...

ErrorCode	get_record_normalized (thread::Thread context, KeySlice key, void payload, PayloadLength *payload_capacity, bool read_only)
	Retrieves an entire record of the given primitive key in this Masstree. More...

ErrorCode	get_record_part_normalized (thread::Thread context, KeySlice key, void payload, PayloadLength payload_offset, PayloadLength payload_count, bool read_only)
	Retrieves a part of the given primitive key in this Masstree. More...

template<typename PAYLOAD >
ErrorCode	get_record_primitive_normalized (thread::Thread context, KeySlice key, PAYLOAD payload, PayloadLength payload_offset, bool read_only)
	Retrieves a part of the given primitive key in this Masstree as a primitive value. More...

ErrorCode	insert_record (thread::Thread context, const void key, KeyLength key_length, const void *payload, PayloadLength payload_count) __attribute__((always_inline))
	Inserts a new record of the given key in this Masstree. More...

ErrorCode	insert_record (thread::Thread context, const void key, KeyLength key_length, const void *payload, PayloadLength payload_count, PayloadLength physical_payload_hint)
	With this method, you can also specify physical_payload_hint, the physical size of the record's payload part. More...

ErrorCode	insert_record (thread::Thread context, const void key, KeyLength key_length) __attribute__((always_inline))
	Inserts a new record without payload of the given key in this Masstree. More...

ErrorCode	insert_record_normalized (thread::Thread context, KeySlice key, const void payload, PayloadLength payload_count) __attribute__((always_inline))
	Inserts a new record of the given primitive key in this Masstree. More...

ErrorCode	insert_record_normalized (thread::Thread context, KeySlice key, const void payload, PayloadLength payload_count, PayloadLength physical_payload_hint)
	With this method, you can also specify physical_payload_hint. More...

ErrorCode	insert_record_normalized (thread::Thread *context, KeySlice key) __attribute__((always_inline))
	Inserts a new record without payload of the given primitive key in this Masstree. More...

ErrorCode	delete_record (thread::Thread context, const void key, KeyLength key_length)
	Deletes a record of the given key from this Masstree. More...

ErrorCode	delete_record_normalized (thread::Thread *context, KeySlice key)
	Deletes a record of the given primitive key from this Masstree. More...

ErrorCode	upsert_record (thread::Thread context, const void key, KeyLength key_length, const void *payload, PayloadLength payload_count) __attribute__((always_inline))
	Inserts a new record of the given key or replaces the existing one, or so-called upsert. More...

ErrorCode	upsert_record (thread::Thread context, const void key, KeyLength key_length, const void *payload, PayloadLength payload_count, PayloadLength physical_payload_hint)
	With this method, you can also specify physical_payload_hint, the physical size of the record's payload part. More...

ErrorCode	upsert_record (thread::Thread context, const void key, KeyLength key_length) __attribute__((always_inline))
	Upserts a new record without payload of the given key in this Masstree. More...

ErrorCode	upsert_record_normalized (thread::Thread context, KeySlice key, const void payload, PayloadLength payload_count) __attribute__((always_inline))
	Upserts a new record of the given primitive key in this Masstree. More...

ErrorCode	upsert_record_normalized (thread::Thread context, KeySlice key, const void payload, PayloadLength payload_count, PayloadLength physical_payload_hint)
	With this method, you can also specify physical_payload_hint. More...

ErrorCode	upsert_record_normalized (thread::Thread *context, KeySlice key) __attribute__((always_inline))
	Upserts a new record without payload of the given primitive key in this Masstree. More...

ErrorCode	overwrite_record (thread::Thread context, const void key, KeyLength key_length, const void *payload, PayloadLength payload_offset, PayloadLength payload_count)
	Overwrites a part of one record of the given key in this Masstree. More...

template<typename PAYLOAD >
ErrorCode	overwrite_record_primitive (thread::Thread context, const void key, KeyLength key_length, PAYLOAD payload, PayloadLength payload_offset)
	Overwrites a part of one record of the given key in this Masstree as a primitive value. More...

ErrorCode	overwrite_record_normalized (thread::Thread context, KeySlice key, const void payload, PayloadLength payload_offset, PayloadLength payload_count)
	Overwrites a part of one record of the given primitive key in this Masstree. More...

template<typename PAYLOAD >
ErrorCode	overwrite_record_primitive_normalized (thread::Thread *context, KeySlice key, PAYLOAD payload, PayloadLength payload_offset)
	Overwrites a part of one record of the given primitive key in this Masstree as a primitive value. More...

template<typename PAYLOAD >
ErrorCode	increment_record (thread::Thread context, const void key, KeyLength key_length, PAYLOAD *value, PayloadLength payload_offset)
	This one further optimizes overwrite methods for the frequent use case of incrementing some data in primitive type. More...

template<typename PAYLOAD >
ErrorCode	increment_record_normalized (thread::Thread context, KeySlice key, PAYLOAD value, PayloadLength payload_offset)
	For primitive key. More...

ErrorStack	verify_single_thread (thread::Thread *context)

ErrorStack	debugout_single_thread (Engine *engine, bool volatile_only=false, uint32_t max_pages=1024U)
	A super-expensive and single-thread only debugging feature to write out gigantic human-readable texts to describe the Masstree in details. More...

ErrorStack	hcc_reset_all_temperature_stat ()
	Resets all volatile pages' temperature stat to be zero in this storage. More...

ErrorCode	peek_volatile_page_boundaries (Engine *engine, const PeekBoundariesArguments &args)
	Checks the volatile pages of this storage to give hints to decide page boundary keys. More...

ErrorStack	fatify_first_root (thread::Thread *context, uint32_t desired_count, bool disable_no_record_split=true)
	Deliberately causes splits under the volatile root of first layer, or "fatify" it. More...

Public Member Functions inherited from foedus::storage::Storage< MasstreeStorageControlBlock >
	Storage ()

	Storage (Engine engine, MasstreeStorageControlBlock control_block)

	Storage (Engine engine, StorageControlBlock control_block)

	Storage (Engine *engine, StorageId id)
	Shorthand for engine->get_storage_manager()->get_storage(id) More...

	Storage (Engine *engine, const StorageName &name)
	Shorthand for engine->get_storage_manager()->get_storage(name) More...

	Storage (const Storage &other)

Storage &	operator= (const Storage &other)

StorageId	get_id () const
	Returns the unique ID of this storage. More...

StorageType	get_type () const
	Returns the type of this storage. More...

const StorageName &	get_name () const
	Returns the unique name of this storage. More...

const Metadata *	get_metadata () const
	Returns the metadata of this storage. More...

bool	exists () const
	Returns whether this storage is already created. More...

Public Member Functions inherited from foedus::Attachable< MasstreeStorageControlBlock >
	Attachable ()

	Attachable (Engine *engine)

	Attachable (Engine engine, MasstreeStorageControlBlock control_block)

	Attachable (MasstreeStorageControlBlock *control_block)

	Attachable (const Attachable &other)

virtual	~Attachable ()

Attachable &	operator= (const Attachable &other)

virtual void	attach (MasstreeStorageControlBlock *control_block)
	Attaches to the given shared memory. More...

bool	is_attached () const
	Returns whether the object has been already attached to some shared memory. More...

MasstreeStorageControlBlock *	get_control_block () const

Engine *	get_engine () const

void	set_engine (Engine *engine)

Static Public Member Functions
static SlotIndex	estimate_records_per_page (Layer layer, KeyLength key_length, PayloadLength payload_length)

Friends
std::ostream &	operator<< (std::ostream &o, const MasstreeStorage &v)

Additional Inherited Members
Protected Attributes inherited from foedus::Attachable< MasstreeStorageControlBlock >
Engine *	engine_
	Most attachable object stores an engine pointer (local engine), so we define it here. More...

MasstreeStorageControlBlock *	control_block_
	The shared data on shared memory that has been initialized in some SOC or master engine. More...

Member Typedef Documentation

typedef MasstreeCreateLogType foedus::storage::masstree::MasstreeStorage::ThisCreateLogType

Definition at line 46 of file masstree_storage.hpp.

typedef MasstreeMetadata foedus::storage::masstree::MasstreeStorage::ThisMetadata

Definition at line 47 of file masstree_storage.hpp.

typedef MasstreeStoragePimpl foedus::storage::masstree::MasstreeStorage::ThisPimpl

Definition at line 45 of file masstree_storage.hpp.

Constructor & Destructor Documentation

foedus::storage::masstree::MasstreeStorage::MasstreeStorage ( )

Definition at line 37 of file masstree_storage.cpp.

37 : Storage<MasstreeStorageControlBlock>() {}

foedus::storage::masstree::MasstreeStorage::MasstreeStorage	(	Engine *	engine,
		MasstreeStorageControlBlock *	control_block
	)

Definition at line 38 of file masstree_storage.cpp.

References ASSERT_ND, foedus::storage::Storage< MasstreeStorageControlBlock >::exists(), foedus::storage::Storage< MasstreeStorageControlBlock >::get_type(), and foedus::storage::kMasstreeStorage.

   : Storage<MasstreeStorageControlBlock>(engine, control_block) {
   ASSERT_ND(get_type() == kMasstreeStorage || !exists());
 }

Here is the call graph for this function:

foedus::storage::masstree::MasstreeStorage::MasstreeStorage	(	Engine *	engine,
		StorageControlBlock *	control_block
	)

Definition at line 42 of file masstree_storage.cpp.

References ASSERT_ND, foedus::storage::Storage< MasstreeStorageControlBlock >::exists(), foedus::storage::Storage< MasstreeStorageControlBlock >::get_type(), and foedus::storage::kMasstreeStorage.

   : Storage<MasstreeStorageControlBlock>(engine, control_block) {
   ASSERT_ND(get_type() == kMasstreeStorage || !exists());
 }

Here is the call graph for this function:

foedus::storage::masstree::MasstreeStorage::MasstreeStorage	(	Engine *	engine,
		StorageId	id
	)

Definition at line 46 of file masstree_storage.cpp.

47 : Storage<MasstreeStorageControlBlock>(engine, id) {}

foedus::storage::masstree::MasstreeStorage::MasstreeStorage	(	Engine *	engine,
		const StorageName &	name
	)

Definition at line 48 of file masstree_storage.cpp.

49 : Storage<MasstreeStorageControlBlock>(engine, name) {}

foedus::storage::masstree::MasstreeStorage::MasstreeStorage ( const MasstreeStorage & other )

Definition at line 50 of file masstree_storage.cpp.

51 : Storage<MasstreeStorageControlBlock>(other.engine_, other.control_block_) {

52 }

Member Function Documentation

ErrorStack foedus::storage::masstree::MasstreeStorage::create ( const Metadata & metadata )

Definition at line 63 of file masstree_storage.cpp.

References foedus::storage::masstree::MasstreeStoragePimpl::create().

                                                             {
   return MasstreeStoragePimpl(this).create(static_cast<const MasstreeMetadata&>(metadata));
 }

Here is the call graph for this function:

ErrorStack foedus::storage::masstree::MasstreeStorage::debugout_single_thread	(	Engine *	engine,
		bool	volatile_only = `false`,
		uint32_t	max_pages = `1024U`
	)

A super-expensive and single-thread only debugging feature to write out gigantic human-readable texts to describe the Masstree in details.

Do not invoke this method for more than 100 pages, or in production use. This is for debugging.

Definition at line 579 of file masstree_storage.cpp.

References foedus::storage::masstree::MasstreeStoragePimpl::debugout_single_thread().

                       {
   return MasstreeStoragePimpl(this).debugout_single_thread(engine, volatile_only, max_pages);
 }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::delete_record	(	thread::Thread *	context,
		const void *	key,
		KeyLength	key_length
	)

Deletes a record of the given key from this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Arbitrary length of key that is lexicographically (big-endian) evaluated.
[in]	key_length	Byte size of key.

When the key does not exist, it returns kErrorCodeStrKeyNotFound and also adds an appropriate record to range-lock read set because it is part of transactional information.

Definition at line 312 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, foedus::storage::masstree::MasstreeStoragePimpl::delete_general(), delete_record_normalized(), foedus::storage::masstree::MasstreeStoragePimpl::locate_record(), and foedus::storage::masstree::normalize_be_bytes_full().

                         {
   // Automatically switch to faster implementation for 8-byte keys
   if (key_length == sizeof(KeySlice)) {
     KeySlice slice = normalize_be_bytes_full(key);
     return delete_record_normalized(context, slice);
   }
 
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record(
     context,
     key,
     key_length,
     true,
     &location));
   return pimpl.delete_general(context, location, key, key_length);
 }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::delete_record_normalized	(	thread::Thread *	context,
		KeySlice	key
	)

Deletes a record of the given primitive key from this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Primitive key that is evaluated in the primitive type's comparison rule.

Definition at line 333 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, foedus::storage::masstree::MasstreeStoragePimpl::delete_general(), foedus::assorted::htobe< uint64_t >(), and foedus::storage::masstree::MasstreeStoragePimpl::locate_record_normalized().

Referenced by delete_record().

                 {
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record_normalized(
     context,
     key,
     true,
     &location));
   uint64_t be_key = assorted::htobe<uint64_t>(key);
   return pimpl.delete_general(context, location, &be_key, sizeof(be_key));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::masstree::MasstreeStorage::drop ( )

Definition at line 69 of file masstree_storage.cpp.

References foedus::storage::masstree::MasstreeStoragePimpl::drop().

69 { return MasstreeStoragePimpl(this).drop(); }

Here is the call graph for this function:

SlotIndex foedus::storage::masstree::MasstreeStorage::estimate_records_per_page	(	Layer	layer,
		KeyLength	key_length,
		PayloadLength	payload_length
	)

static

Parameters

[in]	layer	B-trie layer most border pages would be in.
[in]	key_length	estimated byte size of each key
[in]	payload_length	estimated byte size of each payload

Returns: Estimated number of records that fit in one border page.

Definition at line 612 of file masstree_storage.cpp.

References foedus::assorted::align8(), ASSERT_ND, foedus::storage::masstree::kBorderPageDataPartSize, foedus::storage::masstree::kBorderPageMaxSlots, and foedus::storage::masstree::kBorderPageSlotSize.

                                 {
   PayloadLength aligned_payload = assorted::align8(payload_length);
   KeyLength aligned_suffix = 0;
   if (key_length > (layer + 1U) * sizeof(KeySlice)) {
     aligned_suffix = assorted::align8(key_length - (layer + 1U) * sizeof(KeySlice));
   }
   SlotIndex ret = kBorderPageDataPartSize
     / (aligned_suffix + aligned_payload + kBorderPageSlotSize);
   ASSERT_ND(ret <= kBorderPageMaxSlots);
   return ret;
 }

Here is the call graph for this function:

ErrorStack foedus::storage::masstree::MasstreeStorage::fatify_first_root	(	thread::Thread *	context,
		uint32_t	desired_count,
		bool	disable_no_record_split = `true`
	)

Deliberately causes splits under the volatile root of first layer, or "fatify" it.

Parameters

[in]	context	Thread context
[in]	desired_count	Does nothing if the root of first layer already has this many children.
[in]	disable_no_record_split	when this method triggers page splits, whether to always split pages in half, ignoring chance for no-record-split. usually you should just leave the default value.

This is a special-purpose, physical-only method that does nothing logically. It increases the number of direct children in first root, which is useful when we partition based on children in first root. Fatifying beforehand shouldn't have any significant drawback, but we so far restrict the use of this method to performance benchmarks.

Todo:: testcase for this method. TDD? shut up.

Definition at line 604 of file masstree_storage.cpp.

References foedus::storage::masstree::MasstreeStoragePimpl::fatify_first_root().

                                 {
   MasstreeStoragePimpl impl(this);
   return impl.fatify_first_root(context, desired_count, disable_no_record_split);
 }

Here is the call graph for this function:

const MasstreeMetadata * foedus::storage::masstree::MasstreeStorage::get_masstree_metadata ( ) const

Definition at line 59 of file masstree_storage.cpp.

References foedus::Attachable< MasstreeStorageControlBlock >::control_block_.

Referenced by foedus::storage::masstree::MasstreeComposer::drop_root_volatile(), and foedus::storage::masstree::MasstreeComposer::drop_volatiles().

                                                                       {
   return &control_block_->meta_;
 }

Here is the caller graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::get_record	(	thread::Thread *	context,
		const void *	key,
		KeyLength	key_length,
		void *	payload,
		PayloadLength *	payload_capacity,
		bool	read_only
	)

Retrieves an entire record of the given key in this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Arbitrary length of key that is lexicographically (big-endian) evaluated.
[in]	key_length	Byte size of key.
[out]	payload	Buffer to receive the payload of the record.
[in,out]	payload_capacity	[In] Byte size of the payload buffer, [Out] length of the payload. This is set whether the payload capacity was too small or not.
[in]	read_only	Whether this read will not be followed by writes. When MOCC triggers pessimistic lock, this guides us to take either read- or write-lock.

When payload_capacity is smaller than the actual payload, this method returns kErrorCodeStrTooSmallPayloadBuffer and payload_capacity is set to be the required length.

When the key is not found (kErrorCodeStrKeyNotFound), we also add an appropriate record to range-lock read set because it is part of a transactional information.

Definition at line 79 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, get_record_normalized(), foedus::storage::masstree::MasstreeStoragePimpl::locate_record(), foedus::storage::masstree::normalize_be_bytes_full(), and foedus::storage::masstree::MasstreeStoragePimpl::retrieve_general().

                   {
   // Automatically switch to faster implementation for 8-byte keys
   if (key_length == sizeof(KeySlice)) {
     KeySlice slice = normalize_be_bytes_full(key);
     return get_record_normalized(context, slice, payload, payload_capacity, read_only);
   }
 
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record(
     context,
     key,
     key_length,
     !read_only,
     &location));
   return pimpl.retrieve_general(
     context,
     location,
     payload,
     payload_capacity);
 }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::get_record_normalized	(	thread::Thread *	context,
		KeySlice	key,
		void *	payload,
		PayloadLength *	payload_capacity,
		bool	read_only
	)

Retrieves an entire record of the given primitive key in this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Primitive key that is evaluated in the primitive type's comparison rule.
[out]	payload	Buffer to receive the payload of the record.
[in,out]	payload_capacity	[In] Byte size of the payload buffer, [Out] length of the payload. This is set whether the payload capacity was too small or not.
[in]	read_only	Whether this read will not be followed by writes. When MOCC triggers pessimistic lock, this guides us to take either read- or write-lock.

Definition at line 169 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, foedus::storage::masstree::MasstreeStoragePimpl::locate_record_normalized(), and foedus::storage::masstree::MasstreeStoragePimpl::retrieve_general().

Referenced by get_record().

                   {
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record_normalized(
     context,
     key,
     !read_only,
     &location));
   return pimpl.retrieve_general(
     context,
     location,
     payload,
     payload_capacity);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::get_record_part	(	thread::Thread *	context,
		const void *	key,
		KeyLength	key_length,
		void *	payload,
		PayloadLength	payload_offset,
		PayloadLength	payload_count,
		bool	read_only
	)

Retrieves a part of the given key in this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Arbitrary length of key that is lexicographically (big-endian) evaluated.
[in]	key_length	Byte size of key.
[out]	payload	Buffer to receive the payload of the record.
[in]	payload_offset	We copy from this byte position of the record.
[in]	payload_count	How many bytes we copy.
[in]	read_only	Whether this read will not be followed by writes. When MOCC triggers pessimistic lock, this guides us to take either read- or write-lock.

Precondition: payload_offset + payload_count must be within the record's actual payload size (returns kErrorCodeStrTooShortPayload if not)

Definition at line 107 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, get_record_part_normalized(), foedus::storage::masstree::MasstreeStoragePimpl::locate_record(), foedus::storage::masstree::normalize_be_bytes_full(), and foedus::storage::masstree::MasstreeStoragePimpl::retrieve_part_general().

                   {
   // Automatically switch to faster implementation for 8-byte keys
   if (key_length == sizeof(KeySlice)) {
     KeySlice slice = normalize_be_bytes_full(key);
     return get_record_part_normalized(
       context, slice, payload, payload_offset, payload_count, read_only);
   }
 
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record(
     context,
     key,
     key_length,
     !read_only,
     &location));
   return pimpl.retrieve_part_general(
     context,
     location,
     payload,
     payload_offset,
     payload_count);
 }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::get_record_part_normalized	(	thread::Thread *	context,
		KeySlice	key,
		void *	payload,
		PayloadLength	payload_offset,
		PayloadLength	payload_count,
		bool	read_only
	)

Retrieves a part of the given primitive key in this Masstree.

See also: get_record_part(); get_record_normalized()

Definition at line 189 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, foedus::storage::masstree::MasstreeStoragePimpl::locate_record_normalized(), and foedus::storage::masstree::MasstreeStoragePimpl::retrieve_part_general().

Referenced by get_record_part().

                   {
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record_normalized(
     context,
     key,
     !read_only,
     &location));
   return pimpl.retrieve_part_general(
     context,
     location,
     payload,
     payload_offset,
     payload_count);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename PAYLOAD >

ErrorCode foedus::storage::masstree::MasstreeStorage::get_record_primitive	(	thread::Thread *	context,
		const void *	key,
		KeyLength	key_length,
		PAYLOAD *	payload,
		PayloadLength	payload_offset,
		bool	read_only
	)

Retrieves a part of the given key in this Masstree as a primitive value.

Parameters

[in]	context	Thread context
[in]	key	Arbitrary length of key that is lexicographically (big-endian) evaluated.
[in]	key_length	Byte size of key.
[out]	payload	Receive the payload of the record.
[in]	payload_offset	We copy from this byte position of the record.
[in]	read_only	Whether this read will not be followed by writes. When MOCC triggers pessimistic lock, this guides us to take either read- or write-lock.

Precondition: payload_offset + sizeof(PAYLOAD) must be within the record's actual payload size (returns kErrorCodeStrTooShortPayload if not)

Template Parameters

PAYLOAD primitive type of the payload. all integers and floats are allowed.

Definition at line 139 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, foedus::storage::masstree::MasstreeStoragePimpl::locate_record(), foedus::storage::masstree::normalize_be_bytes_full(), and foedus::storage::masstree::MasstreeStoragePimpl::retrieve_part_general().

                   {
   // Automatically switch to faster implementation for 8-byte keys
   if (key_length == sizeof(KeySlice)) {
     KeySlice slice = normalize_be_bytes_full(key);
     return get_record_primitive_normalized<PAYLOAD>(
       context, slice, payload, payload_offset, read_only);
   }
 
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record(
     context,
     key,
     key_length,
     !read_only,
     &location));
   return pimpl.retrieve_part_general(
     context,
     location,
     payload,
     payload_offset,
     sizeof(PAYLOAD));
 }

Here is the call graph for this function:

template<typename PAYLOAD >

ErrorCode foedus::storage::masstree::MasstreeStorage::get_record_primitive_normalized	(	thread::Thread *	context,
		KeySlice	key,
		PAYLOAD *	payload,
		PayloadLength	payload_offset,
		bool	read_only
	)

Retrieves a part of the given primitive key in this Masstree as a primitive value.

See also: get_record_normalized(); get_record_primitive()

Definition at line 212 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, foedus::storage::masstree::MasstreeStoragePimpl::locate_record_normalized(), and foedus::storage::masstree::MasstreeStoragePimpl::retrieve_part_general().

                   {
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record_normalized(
     context,
     key,
     !read_only,
     &location));
   return pimpl.retrieve_part_general(
     context,
     location,
     payload,
     payload_offset,
     sizeof(PAYLOAD));
 }

Here is the call graph for this function:

ErrorStack foedus::storage::masstree::MasstreeStorage::hcc_reset_all_temperature_stat ( )

Resets all volatile pages' temperature stat to be zero in this storage.

Used only in HCC-branch.

Definition at line 586 of file masstree_storage.cpp.

References foedus::storage::masstree::MasstreeStoragePimpl::hcc_reset_all_temperature_stat().

                                                            {
   return MasstreeStoragePimpl(this).hcc_reset_all_temperature_stat();
 }

Here is the call graph for this function:

template<typename PAYLOAD >

ErrorCode foedus::storage::masstree::MasstreeStorage::increment_record	(	thread::Thread *	context,
		const void *	key,
		KeyLength	key_length,
		PAYLOAD *	value,
		PayloadLength	payload_offset
	)

This one further optimizes overwrite methods for the frequent use case of incrementing some data in primitive type.

Parameters

[in]	context	Thread context
[in]	key	Arbitrary length of key that is lexicographically (big-endian) evaluated.
[in]	key_length	Byte size of key.
[in,out]	value	(in) addendum, (out) value after addition.
[in]	payload_offset	We overwrite to this byte position of the record.

Precondition: payload_offset + sizeof(PAYLOAD) must be within the record's actual payload size (returns kErrorCodeStrTooShortPayload if not)

Template Parameters

PAYLOAD primitive type of the payload. all integers and floats are allowed.

Definition at line 523 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, foedus::storage::masstree::MasstreeStoragePimpl::increment_general(), foedus::storage::masstree::MasstreeStoragePimpl::locate_record(), and foedus::storage::masstree::normalize_be_bytes_full().

                                 {
   // Automatically switch to faster implementation for 8-byte keys
   if (key_length == sizeof(KeySlice)) {
     KeySlice slice = normalize_be_bytes_full(key);
     return increment_record_normalized<PAYLOAD>(context, slice, value, payload_offset);
   }
 
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record(
     context,
     key,
     key_length,
     true,
     &location));
   return pimpl.increment_general<PAYLOAD>(
     context,
     location,
     key,
     key_length,
     value,
     payload_offset);
 }

Here is the call graph for this function:

template<typename PAYLOAD >

ErrorCode foedus::storage::masstree::MasstreeStorage::increment_record_normalized	(	thread::Thread *	context,
		KeySlice	key,
		PAYLOAD *	value,
		PayloadLength	payload_offset
	)

For primitive key.

See also: increment_record()

Definition at line 553 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, foedus::assorted::htobe< uint64_t >(), foedus::storage::masstree::MasstreeStoragePimpl::increment_general(), and foedus::storage::masstree::MasstreeStoragePimpl::locate_record_normalized().

                                 {
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record_normalized(
     context,
     key,
     true,
     &location));
   uint64_t be_key = assorted::htobe<uint64_t>(key);
   return pimpl.increment_general<PAYLOAD>(
     context,
     location,
     &be_key,
     sizeof(be_key),
     value,
     payload_offset);
 }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::insert_record	(	thread::Thread *	context,
		const void *	key,
		KeyLength	key_length,
		const void *	payload,
		PayloadLength	payload_count
	)

inline

Inserts a new record of the given key in this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Arbitrary length of key that is lexicographically (big-endian) evaluated.
[in]	key_length	Byte size of key.
[in]	payload	Value to insert.
[in]	payload_count	Length of payload.

If the key already exists, it returns kErrorCodeStrKeyAlreadyExists and also adds the found record to read set because it is part of transactional information.

Definition at line 252 of file masstree_storage.hpp.

Referenced by insert_record().

                                                {
     return insert_record(context, key, key_length, payload, payload_count, payload_count);
   }

Here is the caller graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::insert_record	(	thread::Thread *	context,
		const void *	key,
		KeyLength	key_length,
		const void *	payload,
		PayloadLength	payload_count,
		PayloadLength	physical_payload_hint
	)

With this method, you can also specify physical_payload_hint, the physical size of the record's payload part.

If you will later expand the payload of this record, giving a larger value will avoid record migration. Default value (and minimal value) is same as the initial payload_count.

Definition at line 247 of file masstree_storage.cpp.

References foedus::storage::masstree::adjust_payload_hint(), ASSERT_ND, CHECK_ERROR_CODE, foedus::storage::masstree::MasstreeStoragePimpl::insert_general(), insert_record_normalized(), foedus::storage::masstree::RecordLocation::is_found(), foedus::kErrorCodeStrTooLongPayload, foedus::storage::masstree::kMaxPayloadLength, foedus::storage::masstree::normalize_be_bytes_full(), foedus::storage::masstree::MasstreeStoragePimpl::reserve_record(), and UNLIKELY.

                                        {
   // Automatically switch to faster implementation for 8-byte keys
   if (key_length == sizeof(KeySlice)) {
     KeySlice slice = normalize_be_bytes_full(key);
     return insert_record_normalized(context, slice, payload, payload_count, physical_payload_hint);
   }
 
   if (UNLIKELY(payload_count > kMaxPayloadLength)) {
     return kErrorCodeStrTooLongPayload;
   }
   physical_payload_hint = adjust_payload_hint(payload_count, physical_payload_hint);
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.reserve_record(
     context,
     key,
     key_length,
     payload_count,
     physical_payload_hint,
     &location));
   ASSERT_ND(location.is_found());  // contract of reserve_record
   return pimpl.insert_general(
     context,
     location,
     key,
     key_length,
     payload,
     payload_count);
 }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::insert_record	(	thread::Thread *	context,
		const void *	key,
		KeyLength	key_length
	)

inline

Inserts a new record without payload of the given key in this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Arbitrary length of key that is lexicographically (big-endian) evaluated.
[in]	key_length	Byte size of key.

If the key already exists, it returns kErrorCodeStrKeyAlreadyExists and also adds the found record to read set because it is part of transactional information.

Definition at line 284 of file masstree_storage.hpp.

References CXX11_NULLPTR, and insert_record().

                                         {
       return insert_record(context, key, key_length, CXX11_NULLPTR, 0U);
   }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::insert_record_normalized	(	thread::Thread *	context,
		KeySlice	key,
		const void *	payload,
		PayloadLength	payload_count
	)

inline

Inserts a new record of the given primitive key in this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Primitive key that is evaluated in the primitive type's comparison rule.
[in]	payload	Value to insert.
[in]	payload_count	Length of payload.

Definition at line 298 of file masstree_storage.hpp.

Referenced by insert_record(), and insert_record_normalized().

                                                {
     return insert_record_normalized(context, key, payload, payload_count, payload_count);
   }

Here is the caller graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::insert_record_normalized	(	thread::Thread *	context,
		KeySlice	key,
		const void *	payload,
		PayloadLength	payload_count,
		PayloadLength	physical_payload_hint
	)

With this method, you can also specify physical_payload_hint.

Definition at line 283 of file masstree_storage.cpp.

References foedus::storage::masstree::adjust_payload_hint(), ASSERT_ND, CHECK_ERROR_CODE, foedus::assorted::htobe< uint64_t >(), foedus::storage::masstree::MasstreeStoragePimpl::insert_general(), foedus::storage::masstree::RecordLocation::is_found(), foedus::kErrorCodeStrTooLongPayload, foedus::storage::masstree::kMaxPayloadLength, foedus::storage::masstree::MasstreeStoragePimpl::reserve_record_normalized(), and UNLIKELY.

                                        {
   if (UNLIKELY(payload_count > kMaxPayloadLength)) {
     return kErrorCodeStrTooLongPayload;
   }
   physical_payload_hint = adjust_payload_hint(payload_count, physical_payload_hint);
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.reserve_record_normalized(
     context,
     key,
     payload_count,
     physical_payload_hint,
     &location));
   ASSERT_ND(location.is_found());  // contract of reserve_record
   uint64_t be_key = assorted::htobe<uint64_t>(key);
   return pimpl.insert_general(
     context,
     location,
     &be_key,
     sizeof(be_key),
     payload,
     payload_count);
 }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::insert_record_normalized	(	thread::Thread *	context,
		KeySlice	key
	)

inline

Inserts a new record without payload of the given primitive key in this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Primitive key that is evaluated in the primitive type's comparison rule.

Definition at line 321 of file masstree_storage.hpp.

References CXX11_NULLPTR, and insert_record_normalized().

                                                                                           {
     return insert_record_normalized(context, key, CXX11_NULLPTR, 0U);
   }

Here is the call graph for this function:

ErrorStack foedus::storage::masstree::MasstreeStorage::load ( const StorageControlBlock & snapshot_block )

Definition at line 66 of file masstree_storage.cpp.

References foedus::storage::masstree::MasstreeStoragePimpl::load().

                                                                           {
   return MasstreeStoragePimpl(this).load(snapshot_block);
 }

Here is the call graph for this function:

MasstreeStorage & foedus::storage::masstree::MasstreeStorage::operator= ( const MasstreeStorage & other )

Definition at line 53 of file masstree_storage.cpp.

References foedus::Attachable< MasstreeStorageControlBlock >::control_block_, foedus::Attachable< CONTROL_BLOCK >::control_block_, foedus::Attachable< MasstreeStorageControlBlock >::engine_, and foedus::Attachable< CONTROL_BLOCK >::engine_.

                                                                         {
   engine_ = other.engine_;
   control_block_ = other.control_block_;
   return *this;
 }

ErrorCode foedus::storage::masstree::MasstreeStorage::overwrite_record	(	thread::Thread *	context,
		const void *	key,
		KeyLength	key_length,
		const void *	payload,
		PayloadLength	payload_offset,
		PayloadLength	payload_count
	)

Overwrites a part of one record of the given key in this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Arbitrary length of key that is lexicographically (big-endian) evaluated.
[in]	key_length	Byte size of key.
[in]	payload	We copy from this buffer. Must be at least payload_count.
[in]	payload_offset	We overwrite to this byte position of the record.
[in]	payload_count	How many bytes we overwrite.

When payload_offset+payload_count is larger than the actual payload, this method returns kErrorCodeStrTooShortPayload. Just like get_record(), this adds to range-lock read set even when key is not found.

Definition at line 412 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, foedus::storage::masstree::MasstreeStoragePimpl::locate_record(), foedus::storage::masstree::normalize_be_bytes_full(), foedus::storage::masstree::MasstreeStoragePimpl::overwrite_general(), and overwrite_record_normalized().

                                {
   // Automatically switch to faster implementation for 8-byte keys
   if (key_length == sizeof(KeySlice)) {
     KeySlice slice = normalize_be_bytes_full(key);
     return overwrite_record_normalized(context, slice, payload, payload_offset, payload_count);
   }
 
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record(
     context,
     key,
     key_length,
     true,
     &location));
   return pimpl.overwrite_general(
     context,
     location,
     key,
     key_length,
     payload,
     payload_offset,
     payload_count);
 }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::overwrite_record_normalized	(	thread::Thread *	context,
		KeySlice	key,
		const void *	payload,
		PayloadLength	payload_offset,
		PayloadLength	payload_count
	)

Overwrites a part of one record of the given primitive key in this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Primitive key that is evaluated in the primitive type's comparison rule.
[in]	payload	We copy from this buffer. Must be at least payload_count.
[in]	payload_offset	We overwrite to this byte position of the record.
[in]	payload_count	How many bytes we overwrite.

See also: get_record_normalized()

Definition at line 474 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, foedus::assorted::htobe< uint64_t >(), foedus::storage::masstree::MasstreeStoragePimpl::locate_record_normalized(), and foedus::storage::masstree::MasstreeStoragePimpl::overwrite_general().

Referenced by overwrite_record().

                                {
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record_normalized(
     context,
     key,
     true,
     &location));
   uint64_t be_key = assorted::htobe<uint64_t>(key);
   return pimpl.overwrite_general(
     context,
     location,
     &be_key,
     sizeof(be_key),
     payload,
     payload_offset,
     payload_count);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename PAYLOAD >

ErrorCode foedus::storage::masstree::MasstreeStorage::overwrite_record_primitive	(	thread::Thread *	context,
		const void *	key,
		KeyLength	key_length,
		PAYLOAD	payload,
		PayloadLength	payload_offset
	)

Overwrites a part of one record of the given key in this Masstree as a primitive value.

Parameters

[in]	context	Thread context
[in]	key	Arbitrary length of key that is lexicographically (big-endian) evaluated.
[in]	key_length	Byte size of key.
[in]	payload	We copy this value.
[in]	payload_offset	We overwrite to this byte position of the record.

Precondition: payload_offset + sizeof(PAYLOAD) must be within the record's actual payload size (returns kErrorCodeStrTooShortPayload if not)

Template Parameters

PAYLOAD primitive type of the payload. all integers and floats are allowed.

Definition at line 444 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, foedus::storage::masstree::MasstreeStoragePimpl::locate_record(), foedus::storage::masstree::normalize_be_bytes_full(), and foedus::storage::masstree::MasstreeStoragePimpl::overwrite_general().

                                 {
   // Automatically switch to faster implementation for 8-byte keys
   if (key_length == sizeof(KeySlice)) {
     KeySlice slice = normalize_be_bytes_full(key);
     return overwrite_record_primitive_normalized<PAYLOAD>(context, slice, payload, payload_offset);
   }
 
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record(
     context,
     key,
     key_length,
     true,
     &location));
   return pimpl.overwrite_general(
     context,
     location,
     key,
     key_length,
     &payload,
     payload_offset,
     sizeof(payload));
 }

Here is the call graph for this function:

template<typename PAYLOAD >

ErrorCode foedus::storage::masstree::MasstreeStorage::overwrite_record_primitive_normalized	(	thread::Thread *	context,
		KeySlice	key,
		PAYLOAD	payload,
		PayloadLength	payload_offset
	)

Overwrites a part of one record of the given primitive key in this Masstree as a primitive value.

See also: overwrite_record_primitive(); overwrite_record_normalized()

Definition at line 499 of file masstree_storage.cpp.

References CHECK_ERROR_CODE, foedus::assorted::htobe< uint64_t >(), foedus::storage::masstree::MasstreeStoragePimpl::locate_record_normalized(), and foedus::storage::masstree::MasstreeStoragePimpl::overwrite_general().

                                 {
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.locate_record_normalized(
     context,
     key,
     true,
     &location));
   uint64_t be_key = assorted::htobe<uint64_t>(key);
   return pimpl.overwrite_general(
     context,
     location,
     &be_key,
     sizeof(be_key),
     &payload,
     payload_offset,
     sizeof(payload));
 }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::peek_volatile_page_boundaries	(	Engine *	engine,
		const PeekBoundariesArguments &	args
	)

Checks the volatile pages of this storage to give hints to decide page boundary keys.

This method is used from the composer to make page boundaries in snapshot pages better aligned with those of volatile pages so that we can drop more volatile pages at the end. This method is opportunistic, meaning the result is not guaranteed to be transactionally correct, but that's fine because these are just hints. If the page boundary is not aligned well with volatile pages, we just have to keep more volatile pages for a while. In fact, the composer might ignore these hints in some cases (eg. a page has too few tuples). Defined in masstree_storage_peek.cpp

Definition at line 31 of file masstree_storage_peek.cpp.

References foedus::storage::masstree::MasstreeStoragePimpl::peek_volatile_page_boundaries().

                                                                       {
   MasstreeStoragePimpl pimpl(this);
   return pimpl.peek_volatile_page_boundaries(engine, args);
 }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::prefetch_pages_normalized	(	thread::Thread *	context,
		bool	install_volatile,
		bool	cache_snapshot,
		KeySlice	from = `kInfimumSlice`,
		KeySlice	to = `kSupremumSlice`
	)

Prefetch data pages in this storage.

Key Slice version (from/to are 8 bytes or less).

Parameters

[in]	context	Thread context.
[in]	install_volatile	Whether to install/prefetch volatile pages based on the recent snapshot page if there is none.
[in]	cache_snapshot	Whether to cache/prefetch snapshot pages if exists.
[in]	from	inclusive begin slice of records that are specifically prefetched even in data pages.
[in]	to	inclusive end slice of records that are specifically prefetched even in data pages.

This is to warmup the storage for the current core. Data pages are prefetched within from/to. So far prefetches only volatile pages, but it will also cache and prefetch snapshot pages.

Definition at line 590 of file masstree_storage.cpp.

References foedus::storage::masstree::MasstreeStoragePimpl::prefetch_pages_normalized().

                {
   return MasstreeStoragePimpl(this).prefetch_pages_normalized(
     context,
     install_volatile,
     cache_snapshot,
     from,
     to);
 }

Here is the call graph for this function:

xct::TrackMovedRecordResult foedus::storage::masstree::MasstreeStorage::track_moved_record	(	xct::RwLockableXctId *	old_address,
		xct::WriteXctAccess *	write_set
	)

Resolves a "moved" record.

This is the core of the moved-bit protocol. Receiving a xct_id address that points to a moved record, track the physical record in another page. This method does not take lock, so it is possible that concurrent threads again move the record after this. The only case it fails to track is the record moved to deeper layers. If the write-set is supplied, we use the key information in it to track even in that case.

Note: Implementation note and limitation Master-tree (masstree) does use moved bit, so this storage implements this method to handle moved record. There are a few design choices worth noting.

In the new_mpage git branch, we significantly changed the page layout in this package. One purpose was to allow tracking the moved record in all circumstances.

When the record is moved within the same B-trie layer, it is anyway easy to track down the new location. When the record is moved to next layer, however, we have to know the entire key to track the record. Previous page layout didn't allow it unless we have the write_set. When there is a standalone read-access, we could not track to next layer.

The new page layout always leaves the original key of the record in page, thus the issue completely went away. This also simplified concurrency control in this package. See Remainder vs Remaining Key.

However, this came with the price of wasted space in page. To ameliorate it, we made a few improvements to reduce wasted space.

First, now we have a flag that says the record is initially a next-layer. When this is set, we do not put suffix, thus the price is gone.
Second, we also added a configuration to aggressively create next-layer to make most high-layer records as initially next-layer. See MasstreeMetadata::min_layer_hint_.
Third, we also overhauled the way we expand records in page.

Thanks to these improvements, we now allow more records, not less, in a page. Previously it was 64, but now kBorderPageMaxSlots is 100 for 4kb pages.

Definition at line 842 of file masstree_storage_pimpl.cpp.

References foedus::storage::masstree::MasstreeStoragePimpl::track_moved_record().

Referenced by foedus::storage::StorageManagerPimpl::track_moved_record().

                                 {
   return MasstreeStoragePimpl(this).track_moved_record(old_address, write_set);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::upsert_record	(	thread::Thread *	context,
		const void *	key,
		KeyLength	key_length,
		const void *	payload,
		PayloadLength	payload_count
	)

inline

Inserts a new record of the given key or replaces the existing one, or so-called upsert.

Parameters

[in]	context	Thread context
[in]	key	Arbitrary length of key that is lexicographically (big-endian) evaluated.
[in]	key_length	Byte size of key.
[in]	payload	Value to upsert.
[in]	payload_count	Length of payload.

This method puts the record whether the key already exists or not, which is handy in many usecases. Internally, the Implementation comes with a bit of complexity. If there is an existing record of the key (whether logically deleted or not) that is spacious enough, then we simply replace the record. If the key doesn't exist or the existing record is no big enough, we create/migrate the record in a system transaction then install the record.

Definition at line 363 of file masstree_storage.hpp.

Referenced by upsert_record().

                                                {
     return upsert_record(context, key, key_length, payload, payload_count, payload_count);
   }

Here is the caller graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::upsert_record	(	thread::Thread *	context,
		const void *	key,
		KeyLength	key_length,
		const void *	payload,
		PayloadLength	payload_count,
		PayloadLength	physical_payload_hint
	)

With this method, you can also specify physical_payload_hint, the physical size of the record's payload part.

If you will later expand the payload of this record, giving a larger value will avoid record migration. Default value (and minimal value) is same as the initial payload_count.

Definition at line 347 of file masstree_storage.cpp.

References foedus::storage::masstree::adjust_payload_hint(), ASSERT_ND, CHECK_ERROR_CODE, foedus::storage::masstree::RecordLocation::is_found(), foedus::kErrorCodeStrTooLongPayload, foedus::storage::masstree::kMaxPayloadLength, foedus::storage::masstree::normalize_be_bytes_full(), foedus::storage::masstree::MasstreeStoragePimpl::reserve_record(), UNLIKELY, foedus::storage::masstree::MasstreeStoragePimpl::upsert_general(), and upsert_record_normalized().

                                        {
   // Automatically switch to faster implementation for 8-byte keys
   if (key_length == sizeof(KeySlice)) {
     KeySlice slice = normalize_be_bytes_full(key);
     return upsert_record_normalized(context, slice, payload, payload_count, physical_payload_hint);
   }
 
   if (UNLIKELY(payload_count > kMaxPayloadLength)) {
     return kErrorCodeStrTooLongPayload;
   }
   physical_payload_hint = adjust_payload_hint(payload_count, physical_payload_hint);
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.reserve_record(
     context,
     key,
     key_length,
     payload_count,
     physical_payload_hint,
     &location));
   ASSERT_ND(location.is_found());  // contract of reserve_record
   return pimpl.upsert_general(
     context,
     location,
     key,
     key_length,
     payload,
     payload_count);
 }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::upsert_record	(	thread::Thread *	context,
		const void *	key,
		KeyLength	key_length
	)

inline

Upserts a new record without payload of the given key in this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Arbitrary length of key that is lexicographically (big-endian) evaluated.
[in]	key_length	Byte size of key.

Definition at line 392 of file masstree_storage.hpp.

References CXX11_NULLPTR, and upsert_record().

                                         {
       return upsert_record(context, key, key_length, CXX11_NULLPTR, 0U);
   }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::upsert_record_normalized	(	thread::Thread *	context,
		KeySlice	key,
		const void *	payload,
		PayloadLength	payload_count
	)

inline

Upserts a new record of the given primitive key in this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Primitive key that is evaluated in the primitive type's comparison rule.
[in]	payload	Value to upsert.
[in]	payload_count	Length of payload.

Definition at line 406 of file masstree_storage.hpp.

Referenced by upsert_record(), and upsert_record_normalized().

                                                {
     return upsert_record_normalized(context, key, payload, payload_count, payload_count);
   }

Here is the caller graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::upsert_record_normalized	(	thread::Thread *	context,
		KeySlice	key,
		const void *	payload,
		PayloadLength	payload_count,
		PayloadLength	physical_payload_hint
	)

With this method, you can also specify physical_payload_hint.

Definition at line 383 of file masstree_storage.cpp.

References foedus::storage::masstree::adjust_payload_hint(), ASSERT_ND, CHECK_ERROR_CODE, foedus::assorted::htobe< uint64_t >(), foedus::storage::masstree::RecordLocation::is_found(), foedus::kErrorCodeStrTooLongPayload, foedus::storage::masstree::kMaxPayloadLength, foedus::storage::masstree::MasstreeStoragePimpl::reserve_record_normalized(), UNLIKELY, and foedus::storage::masstree::MasstreeStoragePimpl::upsert_general().

                                        {
   if (UNLIKELY(payload_count > kMaxPayloadLength)) {
     return kErrorCodeStrTooLongPayload;
   }
   physical_payload_hint = adjust_payload_hint(payload_count, physical_payload_hint);
   MasstreeStoragePimpl pimpl(this);
   RecordLocation location;
   CHECK_ERROR_CODE(pimpl.reserve_record_normalized(
     context,
     key,
     payload_count,
     physical_payload_hint,
     &location));
   ASSERT_ND(location.is_found());  // contract of reserve_record
   uint64_t be_key = assorted::htobe<uint64_t>(key);
   return pimpl.upsert_general(
     context,
     location,
     &be_key,
     sizeof(be_key),
     payload,
     payload_count);
 }

Here is the call graph for this function:

ErrorCode foedus::storage::masstree::MasstreeStorage::upsert_record_normalized	(	thread::Thread *	context,
		KeySlice	key
	)

inline

Upserts a new record without payload of the given primitive key in this Masstree.

Parameters

[in]	context	Thread context
[in]	key	Primitive key that is evaluated in the primitive type's comparison rule.

Definition at line 429 of file masstree_storage.hpp.

References CXX11_NULLPTR, and upsert_record_normalized().

                                                                                           {
     return upsert_record_normalized(context, key, CXX11_NULLPTR, 0U);
   }

Here is the call graph for this function:

ErrorStack foedus::storage::masstree::MasstreeStorage::verify_single_thread ( thread::Thread * context )

Definition at line 575 of file masstree_storage.cpp.

References foedus::storage::masstree::MasstreeStoragePimpl::verify_single_thread().

                                                                       {
   return MasstreeStoragePimpl(this).verify_single_thread(context);
 }

Here is the call graph for this function:

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	o,
		const MasstreeStorage &	v
	)

friend

Definition at line 71 of file masstree_storage.cpp.

                                                                 {
   o << "<MasstreeStorage>"
     << "<id>" << v.get_id() << "</id>"
     << "<name>" << v.get_name() << "</name>"
     << "</MasstreeStorage>";
   return o;
 }

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

/home/shino/foedus_code/foedus-core/include/foedus/storage/masstree/masstree_storage.hpp
/home/shino/foedus_code/foedus-core/src/foedus/storage/masstree/masstree_storage.cpp
/home/shino/foedus_code/foedus-core/src/foedus/storage/masstree/masstree_storage_peek.cpp
/home/shino/foedus_code/foedus-core/src/foedus/storage/masstree/masstree_storage_pimpl.cpp

Detailed Description

Classes

Public Types

Public Member Functions

Static Public Member Functions

Friends

Additional Inherited Members

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation