Storage Manager, which implements a couple of key/value stores. More...

Detailed Description

Storage Manager, which implements a couple of key/value stores.

This package contains core classes that store key/value pairs. This layer has no idea about what is stored, thus no notion of columns either.

Types of Storage

So far we provide four types of storages; Array Storage, Hashtable Storage, Sequential Storage, and Masstree Storage. Choose the type of storage based on the data to store and access patterns.

Array Storage is extremely simple, fast, and compact (doesn't even store keys), but it only works for arrays that are fix-sized, dense, and regular.
Hashtable Storage is also simple, fast, and yet general except it can't process range accesses.
Sequential Storage is very simple and fast, but it can do only appends and full scans.
Masstree Storage is the most general, addressing all the issues above. But, it's not as simple/fast as others (though optimized as much as possible for many-cores).

General Recommendation: In general, you should use Hashtable Storage or Masstree Storage for most tables/indexes. If the access pattern contains no range accesses, equality on prefix, nor non-equality, then pick Hashtable Storage. Otherwise, Masstree Storage. Use Array Storage and Sequential Storage where they shine; when you literally needs arrays and append-only data.

Namespaces
	array
	Array Storage, a dense and regular array.

	hash
	Hashtable Storage, a concurrent hashtable.

	masstree
	Masstree Storage, 64-bit B-tries with internal B-trees.

	sequential
	Sequential Storage, an append/scan only data structure.

Classes
class	Composer
	Represents a logic to compose a new version of data pages for one storage. More...

struct	CreateLogType
	Base type for CREATE STORAGE operation. More...

struct	DropLogType
	Log type of DROP STORAGE operation. More...

struct	DualPagePointer
	Represents a pointer to another page (usually a child page). More...

struct	Metadata
	Metadata of one storage. More...

struct	MetadataSerializer

struct	Page
	Just a marker to denote that the memory region represents a data page. More...

struct	PageHeader
	Just a marker to denote that a memory region represents a data page. More...

struct	PageVersion
	Just a synonym of XctId to be used as a page lock mechanism. More...

struct	PageVersionStatus

class	Partitioner
	Partitioning and sorting logic for one storage. More...

struct	PartitionerMetadata
	Tiny metadata of partitioner for every storage used while log gleaning. More...

struct	Record
	Represents one record in our key-value store. More...

class	Storage
	Represents one key-value store. More...

struct	StorageControlBlock
	A base layout of shared data for all storage types. More...

class	StorageManager
	Storage Manager class that provides API to create/open/close/drop key-value stores. More...

struct	StorageManagerControlBlock
	Shared data in StorageManagerPimpl. More...

class	StorageManagerPimpl
	Pimpl object of StorageManager. More...

struct	StorageOptions
	Set of options for storage manager. More...

struct	VolatilePageInitArguments
	Set of arguments, both inputs and outputs, given to each volatile page initializer. More...

struct	VolatilePagePointer
	Represents a pointer to a volatile page with modification count for preventing ABA. More...

Typedefs
typedef void(*	VolatilePageInit) (const VolatilePageInitArguments &args)
	A function pointer to initialize a volatile page. More...

typedef uint32_t	StorageId
	Unique ID for storage. More...

typedef assorted::FixedString< 60 >	StorageName
	Represents a unique name of a storage. More...

typedef thread::ThreadGroupId	PartitionId
	As partition=NUMA node, this is just a synonym of foedus::thread::ThreadGroupId. More...

typedef uint64_t	SnapshotPagePointer
	Page ID of a snapshot page. More...

typedef uint64_t	SnapshotLocalPageId
	Represents a local page ID in each one snapshot file in some NUMA node. More...

typedef uint32_t	Checksum
	Checksum of a snapshot page. More...

Enumerations
enum	PageType { kUnknownPageType = 0, kArrayPageType = 1, kMasstreeIntermediatePageType = 2, kMasstreeBorderPageType = 3, kSequentialPageType = 4, kSequentialRootPageType = 5, kHashIntermediatePageType = 6, kHashDataPageType = 7, kHashComposedBinsPageType = 8, kDummyLastPageType }
	The following 1-byte value is stored in the common page header. More...

enum	StorageType { kInvalidStorage = 0, kArrayStorage, kHashStorage, kMasstreeStorage, kSequentialStorage }
	Type of the storage, such as hash. More...

enum	StorageStatus { kNotExists = 0, kExists, kMarkedForDeath }
	Status of a storage. More...

Functions
Page *	to_page (const void *address)
	super-dirty way to obtain Page the address belongs to. More...

void	assert_aligned_page (const void *page)

void	assert_valid_volatile_page (const Page *page, uint32_t offset)

void	assert_within_valid_volatile_page_impl (const memory::GlobalVolatilePageResolver &resolver, const void *address)

void	assert_within_valid_volatile_page (const memory::GlobalVolatilePageResolver &resolver, const void *address)

void	_dummy_static_size_check__COUNTER__ ()

void	prefetch_page_l2 (const void *page)
	Prefetch a page to L2/L3 cache. More...

StorageControlBlock *	get_storage_control_block (Engine *engine, StorageId id)

StorageControlBlock *	get_storage_control_block (Engine *engine, const StorageName &name)

SnapshotLocalPageId	extract_local_page_id_from_snapshot_pointer (SnapshotPagePointer pointer)

uint8_t	extract_numa_node_from_snapshot_pointer (SnapshotPagePointer pointer)

uint16_t	extract_snapshot_id_from_snapshot_pointer (SnapshotPagePointer pointer)

void	assert_valid_snapshot_local_page_id (SnapshotLocalPageId page_id)

SnapshotPagePointer	to_snapshot_page_pointer (uint16_t snapshot_id, uint8_t node, SnapshotLocalPageId local_page_id)

void	describe_snapshot_pointer (std::ostream *o, SnapshotPagePointer pointer)

const char *	to_storage_type_name (StorageType type)
	Gives a string representation of StorageType. More...

void	describe_volatile_pointer (std::ostream *o, VolatilePagePointer pointer)

VolatilePagePointer	construct_volatile_page_pointer (uint64_t word)

VolatilePagePointer	combine_volatile_page_pointer (uint8_t numa_node, memory::PagePoolOffset offset)

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

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

ErrorStack	load_from_xml_array (tinyxml2::XMLElement element, Metadata data)

ErrorStack	load_from_xml_hash (tinyxml2::XMLElement element, Metadata data)

ErrorStack	load_from_xml_masstree (tinyxml2::XMLElement element, Metadata data)

ErrorStack	load_from_xml_sequential (tinyxml2::XMLElement element, Metadata data)

ErrorStack	save_to_xml_array (tinyxml2::XMLElement parent, Metadata data)

ErrorStack	save_to_xml_hash (tinyxml2::XMLElement parent, Metadata data)

ErrorStack	save_to_xml_masstree (tinyxml2::XMLElement parent, Metadata data)

ErrorStack	save_to_xml_sequential (tinyxml2::XMLElement parent, Metadata data)

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

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

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

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

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

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

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

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

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

Variables
const uint16_t	kRecordOverhead = sizeof(xct::RwLockableXctId)
	Byte size of system-managed region per each record. More...

const uint16_t	kPageSize = 1 << 12
	A constant defining the page size (in bytes) of both snapshot pages and volatile pages. More...

const uint8_t	kVolatilePointerFlagSwappable = 0x02

const char *	kChildTagName = "storage"

const StorageName	kEmptyString

Typedef Documentation

typedef assorted::FixedString<60> foedus::storage::StorageName

Represents a unique name of a storage.

Upto 60 characters so far.

Definition at line 58 of file storage_id.hpp.

Function Documentation

void foedus::storage::_dummy_static_size_check__COUNTER__ ( )

inline

Definition at line 440 of file page.hpp.

void foedus::storage::assert_aligned_page ( const void * page )

inline

Definition at line 402 of file page.hpp.

References ASSERT_ND, and kPageSize.

Referenced by assert_valid_volatile_page(), foedus::storage::masstree::MasstreeStoragePimpl::find_border_physical(), foedus::storage::masstree::MasstreeStoragePimpl::get_first_root(), and foedus::memory::GlobalVolatilePageResolver::resolve_offset_newpage().

                                                   {
   ASSERT_ND(page);
   ASSERT_ND(reinterpret_cast<uintptr_t>(page) % kPageSize == 0);
 }

Here is the caller graph for this function:

void foedus::storage::assert_valid_snapshot_local_page_id ( SnapshotLocalPageId page_id )

inline

Definition at line 102 of file storage_id.hpp.

References ASSERT_ND.

Referenced by to_snapshot_page_pointer().

                                                                              {
   ASSERT_ND(page_id < (1ULL << 40));
 }

Here is the caller graph for this function:

void foedus::storage::assert_valid_volatile_page	(	const Page *	page,
		uint32_t	offset
	)

inline

Definition at line 407 of file page.hpp.

References assert_aligned_page(), ASSERT_ND, foedus::storage::Page::get_header(), foedus::storage::VolatilePagePointer::get_offset(), foedus::storage::PageHeader::get_page_type(), kArrayPageType, kDummyLastPageType, foedus::storage::PageHeader::page_id_, and foedus::storage::VolatilePagePointer::word.

Referenced by foedus::thread::ThreadPimpl::follow_page_pointer(), foedus::thread::ThreadPimpl::follow_page_pointers_for_read_batch(), foedus::thread::ThreadPimpl::follow_page_pointers_for_write_batch(), foedus::memory::LocalPageResolver::resolve_offset(), and foedus::memory::GlobalVolatilePageResolver::resolve_offset().

                                                                           {
   ASSERT_ND(page);
   ASSERT_ND(offset);
 #ifndef NDEBUG
   assert_aligned_page(page);
   PageType type = page->get_header().get_page_type();
   ASSERT_ND(type >= kArrayPageType);
   ASSERT_ND(type < kDummyLastPageType);
   VolatilePagePointer pointer;
   pointer.word = page->get_header().page_id_;
   ASSERT_ND(pointer.get_offset() == offset);
 #endif  // NDEBUG
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::assert_within_valid_volatile_page	(	const memory::GlobalVolatilePageResolver &	resolver,
		const void *	address
	)

inline

Definition at line 428 of file page.hpp.

References assert_within_valid_volatile_page_impl().

Referenced by foedus::xct::Xct::add_to_read_set(), foedus::xct::Xct::add_to_write_set(), foedus::xct::Xct::on_record_read(), foedus::xct::Xct::on_record_read_take_locks_if_needed(), and foedus::xct::to_universal_lock_id().

                        {
   assert_within_valid_volatile_page_impl(resolver, address);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::assert_within_valid_volatile_page_impl	(	const memory::GlobalVolatilePageResolver &	resolver,
		const void *	address
	)

Ah, oh, finally realized why I occasionally hit assertions here. When we have multiple VA mappings (eg emulated fork mode), it is possible that base + offset becomes a different address even if pointing to the same physical page. Unfortunately we can't do this check.. but only page-ID check.

Definition at line 85 of file page.cpp.

References ASSERT_ND, foedus::memory::GlobalVolatilePageResolver::begin_, construct_volatile_page_pointer(), foedus::memory::GlobalVolatilePageResolver::end_, foedus::storage::Page::get_header(), foedus::memory::GlobalVolatilePageResolver::numa_node_count_, foedus::storage::PageHeader::page_id_, foedus::memory::GlobalVolatilePageResolver::resolve_offset(), foedus::storage::PageHeader::snapshot_, and to_page().

Referenced by assert_within_valid_volatile_page().

                        {
   const Page* page = to_page(reinterpret_cast<const void*>(address));
   ASSERT_ND(!page->get_header().snapshot_);
 
   VolatilePagePointer vpp = construct_volatile_page_pointer(page->get_header().page_id_);
   ASSERT_ND(vpp.get_numa_node() < resolver.numa_node_count_);
   ASSERT_ND(vpp.get_offset() >= resolver.begin_);
   ASSERT_ND(vpp.get_offset() < resolver.end_);
 
   const Page* same_page = resolver.resolve_offset(vpp);
   ASSERT_ND(same_page->get_header().page_id_ == page->get_header().page_id_);
   ASSERT_ND(!same_page->get_header().snapshot_);
   // const uintptr_t int_address = reinterpret_cast<uintptr_t>(address);
   // ASSERT_ND(int_address >= base + vpp.components.offset * kPageSize);
   // ASSERT_ND(int_address < base + (vpp.components.offset + 1U) * kPageSize);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

VolatilePagePointer foedus::storage::combine_volatile_page_pointer	(	uint8_t	numa_node,
		memory::PagePoolOffset	offset
	)

inline

Definition at line 235 of file storage_id.hpp.

References foedus::storage::VolatilePagePointer::set().

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

                                {
   VolatilePagePointer ret;
   ret.set(numa_node, offset);
   return ret;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

VolatilePagePointer foedus::storage::construct_volatile_page_pointer ( uint64_t word )

inline

Definition at line 230 of file storage_id.hpp.

References foedus::storage::VolatilePagePointer::word.

Referenced by assert_within_valid_volatile_page_impl(), foedus::storage::hash::HashStoragePimpl::follow_page_bin_head(), foedus::storage::array::ArrayStoragePimpl::lookup_for_read_batch(), foedus::storage::array::ArrayStoragePimpl::lookup_for_write_batch(), foedus::xct::Xct::on_record_read(), foedus::storage::hash::resolve_data_impl(), foedus::storage::hash::resolve_intermediate_impl(), foedus::memory::GlobalVolatilePageResolver::resolve_offset(), and foedus::xct::to_universal_lock_id().

                                                                           {
   VolatilePagePointer pointer;
   pointer.word = word;
   return pointer;
 }

Here is the caller graph for this function:

void foedus::storage::describe_snapshot_pointer	(	std::ostream *	o,
		SnapshotPagePointer	pointer
	)

Definition at line 27 of file storage_id.cpp.

References extract_local_page_id_from_snapshot_pointer(), extract_numa_node_from_snapshot_pointer(), and extract_snapshot_id_from_snapshot_pointer().

Referenced by operator<<().

                                                                                {
   std::ostream& o = *o_ptr;
   if (pointer == 0) {
     o << "<SnapshotPointer is_null=\"true\"/>";
     return;
   }
   o << "<SnapshotPointer"
     << " snapshot_id=\"" << extract_snapshot_id_from_snapshot_pointer(pointer)
     << "\" node=\"" << static_cast<int>(extract_numa_node_from_snapshot_pointer(pointer))
     << "\" offset=\"" << extract_local_page_id_from_snapshot_pointer(pointer)
     << "\" />";
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::describe_volatile_pointer	(	std::ostream *	o,
		VolatilePagePointer	pointer
	)

Definition at line 44 of file storage_id.cpp.

References foedus::storage::VolatilePagePointer::get_numa_node(), foedus::storage::VolatilePagePointer::get_offset(), and foedus::storage::VolatilePagePointer::is_null().

Referenced by foedus::storage::masstree::describe_masstree_page_common(), and operator<<().

                                                                                {
   std::ostream& o = *o_ptr;
   if (pointer.is_null()) {
     o << "<VolatilePointer is_null=\"true\"/>";
     return;
   }
   o << "<VolatilePointer"
     << " node=\"" << static_cast<int>(pointer.get_numa_node())
     << "\" offset=\"" << pointer.get_offset()
     << "\" />";
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SnapshotLocalPageId foedus::storage::extract_local_page_id_from_snapshot_pointer ( SnapshotPagePointer pointer )

inline

Definition at line 91 of file storage_id.hpp.

Referenced by describe_snapshot_pointer(), foedus::cache::HashFunc::get_hash(), foedus::storage::array::ArrayStoragePimpl::lookup_for_read_batch(), foedus::cache::SnapshotFileSet::read_page(), and foedus::cache::SnapshotFileSet::read_pages().

                                {
   return pointer & 0x000000FFFFFFFFFFULL;
 }

Here is the caller graph for this function:

uint8_t foedus::storage::extract_numa_node_from_snapshot_pointer ( SnapshotPagePointer pointer )

inline

Definition at line 95 of file storage_id.hpp.

Referenced by foedus::storage::sequential::SequentialComposer::compose(), foedus::storage::sequential::SequentialComposer::construct_root(), describe_snapshot_pointer(), foedus::storage::array::ArrayPartitioner::design_partition(), foedus::storage::masstree::MasstreePartitioner::design_partition(), foedus::storage::array::ArrayComposer::drop_volatiles(), foedus::storage::hash::HashComposer::drop_volatiles(), foedus::cache::HashFunc::get_hash(), foedus::cache::SnapshotFileSet::get_or_open_file(), foedus::storage::PageHeader::init_snapshot(), and foedus::memory::EngineMemory::load_one_volatile_page().

                                                                                     {
   return static_cast<uint8_t>(pointer >> 40);
 }

Here is the caller graph for this function:

uint16_t foedus::storage::extract_snapshot_id_from_snapshot_pointer ( SnapshotPagePointer pointer )

inline

Definition at line 98 of file storage_id.hpp.

Referenced by foedus::storage::masstree::MasstreeIntermediatePage::append_pointer_snapshot(), foedus::storage::sequential::SequentialComposer::compose(), foedus::storage::array::ArrayComposer::construct_root(), foedus::storage::sequential::SequentialComposer::construct_root(), describe_snapshot_pointer(), foedus::storage::masstree::from_this_snapshot(), foedus::cache::HashFunc::get_hash(), foedus::cache::SnapshotFileSet::get_or_open_file(), foedus::storage::hash::ComposedBinsMergedStream::open_path(), and foedus::storage::hash::ComposedBinsMergedStream::process_a_bin().

                                                                                        {
   return static_cast<uint16_t>(pointer >> 48);
 }

Here is the caller graph for this function:

StorageControlBlock * foedus::storage::get_storage_control_block	(	Engine *	engine,
		StorageId	id
	)

Definition at line 26 of file storage.cpp.

References foedus::storage::StorageManager::get_storage(), and foedus::Engine::get_storage_manager().

                                                                              {
   return engine->get_storage_manager()->get_storage(id);
 }

Here is the call graph for this function:

StorageControlBlock * foedus::storage::get_storage_control_block	(	Engine *	engine,
		const StorageName &	name
	)

Definition at line 29 of file storage.cpp.

References foedus::storage::StorageManager::get_storage(), and foedus::Engine::get_storage_manager().

                                                                                         {
   return engine->get_storage_manager()->get_storage(name);
 }

Here is the call graph for this function:

ErrorStack foedus::storage::load_from_xml_array	(	tinyxml2::XMLElement *	element,
		Metadata *	data
	)

Definition at line 85 of file metadata.cpp.

References foedus::storage::array::ArrayMetadataSerializer::load().

Referenced by foedus::storage::MetadataSerializer::load_all_storages_from_xml().

                                                                             {
   array::ArrayMetadataSerializer serializer(reinterpret_cast<array::ArrayMetadata*>(data));
   return serializer.load(element);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::load_from_xml_hash	(	tinyxml2::XMLElement *	element,
		Metadata *	data
	)

Definition at line 89 of file metadata.cpp.

References foedus::storage::hash::HashMetadataSerializer::load().

Referenced by foedus::storage::MetadataSerializer::load_all_storages_from_xml().

                                                                            {
   hash::HashMetadataSerializer serializer(reinterpret_cast<hash::HashMetadata*>(data));
   return serializer.load(element);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::load_from_xml_masstree	(	tinyxml2::XMLElement *	element,
		Metadata *	data
	)

Definition at line 93 of file metadata.cpp.

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

Referenced by foedus::storage::MetadataSerializer::load_all_storages_from_xml().

                                                                                {
   masstree::MasstreeMetadataSerializer serializer(
     reinterpret_cast<masstree::MasstreeMetadata*>(data));
   return serializer.load(element);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::load_from_xml_sequential	(	tinyxml2::XMLElement *	element,
		Metadata *	data
	)

Definition at line 98 of file metadata.cpp.

References foedus::storage::sequential::SequentialMetadataSerializer::load().

Referenced by foedus::storage::MetadataSerializer::load_all_storages_from_xml().

                                                                                  {
   sequential::SequentialMetadataSerializer serializer(
     reinterpret_cast<sequential::SequentialMetadata*>(data));
   return serializer.load(element);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::ostream& foedus::storage::operator<<	(	std::ostream &	o,
		const PageVersionStatus &	v
	)

Definition at line 33 of file page.cpp.

References foedus::storage::PageVersionStatus::get_version_counter(), foedus::storage::PageVersionStatus::is_moved(), and foedus::storage::PageVersionStatus::is_retired().

                                                                   {
   o << "<PageVersionStatus><flags>"
     << (v.is_moved() ? "M" : " ")
     << (v.is_retired() ? "R" : " ")
     << "</flags><ver>" << v.get_version_counter() << "</ver>"
     << "</PageVersionStatus>";
   return o;
 }

Here is the call graph for this function:

std::ostream& foedus::storage::operator<<	(	std::ostream &	o,
		const Composer &	v
	)

Definition at line 39 of file composer.cpp.

References foedus::storage::Composer::get_storage_id(), foedus::storage::Composer::get_storage_type(), and to_storage_type_name().

                                                          {
   o << "<Composer>"
     << "<storage_id_>" << v.get_storage_id() << "</storage_id_>"
     << "<storage_type>" << to_storage_type_name(v.get_storage_type()) << "</storage_type>"
     << "</Composer>";
   return o;
 }

Here is the call graph for this function:

std::ostream& foedus::storage::operator<<	(	std::ostream &	o,
		const VolatilePagePointer &	v
	)

Definition at line 40 of file storage_id.cpp.

References describe_volatile_pointer().

                                                                     {
   describe_volatile_pointer(&o, v);
   return o;
 }

Here is the call graph for this function:

std::ostream& foedus::storage::operator<<	(	std::ostream &	o,
		const PageVersion &	v
	)

Definition at line 42 of file page.cpp.

References foedus::storage::PageVersion::is_locked(), foedus::storage::PageVersion::is_moved(), foedus::storage::PageVersion::is_retired(), and foedus::storage::PageVersion::status_.

                                                             {
   o << "<PageVersion><locked>"
     << (v.is_locked() ? "L" : " ")
     << (v.is_moved() ? "M" : " ")
     << (v.is_retired() ? "R" : " ")
     << "</locked>" << v.status_
     << "</PageVersion>";
   return o;
 }

Here is the call graph for this function:

std::ostream& foedus::storage::operator<<	(	std::ostream &	o,
		const Composer::DropResult &	v
	)

Definition at line 46 of file composer.cpp.

References foedus::storage::Composer::DropResult::dropped_all_, and foedus::storage::Composer::DropResult::max_observed_.

                                                                    {
   o << "<DropResult>"
     << "<max_observed_>" << v.max_observed_ << "</max_observed_>"
     << "<dropped_all_>" << v.dropped_all_ << "</dropped_all_>"
     << "</DropResult>";
   return o;
 }

std::ostream& foedus::storage::operator<<	(	std::ostream &	o,
		const PageHeader &	v
	)

Definition at line 52 of file page.cpp.

                                                            {
   o << "<PageHeader>";
   o << std::endl << "<page_id>"
     << "<raw>" << assorted::Hex(v.page_id_, 16) << "</raw>";
   // Also write out interpreted version
   if (v.snapshot_) {
     describe_snapshot_pointer(&o, v.page_id_);
   } else {
     VolatilePagePointer pointer;
     pointer.word = v.page_id_;
     describe_volatile_pointer(&o, pointer);
   }
   o << "</page_id>";
   o << std::endl << "<storage_id_>" << v.storage_id_ << "</storage_id_>";
   o << "<checksum_>" << v.checksum_ << "</checksum_>";
   o << "<page_type_>" << static_cast<int>(v.page_type_) << "</page_type_>";
   o << std::endl << "<snapshot_>" << v.snapshot_ << "</snapshot_>";
   o << "<key_count_>" << v.key_count_ << "</key_count_>";
   o << "<masstree_layer_>" << static_cast<int>(v.masstree_layer_) << "</masstree_layer_>";
   o << "<masstree_in_layer_level_>" << static_cast<int>(v.masstree_in_layer_level_)
     << "</masstree_in_layer_level_>";
   o << "<hotness_>" << static_cast<int>(v.hotness_.value_) << "</hotness_>";
   o << std::endl << "<stat_last_updater_node_>" << static_cast<int>(v.stat_last_updater_node_)
     << "</stat_last_updater_node_>";
   o << v.page_version_;
   o << "</PageHeader>";
   return o;
 }

Here is the call graph for this function:

std::ostream& foedus::storage::operator<<	(	std::ostream &	o,
		const DualPagePointer &	v
	)

Definition at line 56 of file storage_id.cpp.

References describe_snapshot_pointer(), describe_volatile_pointer(), foedus::storage::DualPagePointer::snapshot_pointer_, and foedus::storage::DualPagePointer::volatile_pointer_.

                                                                 {
   o << "<DualPagePointer>";
   describe_snapshot_pointer(&o, v.snapshot_pointer_);
   describe_volatile_pointer(&o, v.volatile_pointer_);
   o << "</DualPagePointer>";
   return o;
 }

Here is the call graph for this function:

std::ostream& foedus::storage::operator<<	(	std::ostream &	o,
		const DropLogType &	v
	)

Definition at line 56 of file storage_log_types.cpp.

References foedus::log::BaseLogType::header_, and foedus::log::LogHeader::storage_id_.

                                                             {
   o << "<StorageDropLog>"
     << "<storage_id_>" << v.header_.storage_id_ << "</storage_id_>"
     << "</StorageDropLog>";
   return o;
 }

std::ostream& foedus::storage::operator<<	(	std::ostream &	o,
		const CreateLogType &	v
	)

Definition at line 75 of file storage_log_types.cpp.

References kArrayStorage, kHashStorage, kMasstreeStorage, kSequentialStorage, foedus::storage::CreateLogType::metadata_, and foedus::storage::Metadata::type_.

                                                               {
   switch (v.metadata_.type_) {
     case kArrayStorage:
       o << reinterpret_cast<const array::ArrayCreateLogType&>(v);
       break;
     case kHashStorage:
       o << reinterpret_cast<const hash::HashCreateLogType&>(v);
       break;
     case kMasstreeStorage:
       o << reinterpret_cast<const masstree::MasstreeCreateLogType&>(v);
       break;
     case kSequentialStorage:
       o << reinterpret_cast<const sequential::SequentialCreateLogType&>(v);
       break;
     default:
       o << "Unexpected metadata type:" << v.metadata_.type_;
   }
   return o;
 }

std::ostream& foedus::storage::operator<<	(	std::ostream &	o,
		const Partitioner &	v
	)

Definition at line 140 of file partitioner.cpp.

References foedus::Attachable< CONTROL_BLOCK >::control_block_, and to_storage_type_name().

                                                             {
   o << "<Partitioner>"
     << "<id>" << v.id_ << "</id>"
     << "<type>" << to_storage_type_name(v.type_) << "</type>"
     << *v.control_block_;
   o << "</Partitioner>";
   return o;
 }

Here is the call graph for this function:

std::ostream& foedus::storage::operator<<	(	std::ostream &	o,
		const PartitionerMetadata &	v
	)

Definition at line 148 of file partitioner.cpp.

References foedus::storage::PartitionerMetadata::data_offset_, foedus::storage::PartitionerMetadata::data_size_, and foedus::storage::PartitionerMetadata::valid_.

                                                                     {
   o << "<PartitionerMetadata>"
     << "<valid>" << v.valid_ << "</valid>"
     << "<data_offset_>" << assorted::Hex(v.data_offset_) << "</data_offset_>"
     << "<data_size_>" << assorted::Hex(v.data_size_) << "</data_size_>"
     << "</PartitionerMetadata>";
   return o;
 }

ErrorStack foedus::storage::save_to_xml_array	(	tinyxml2::XMLElement *	parent,
		Metadata *	data
	)

Definition at line 106 of file metadata.cpp.

References foedus::externalize::Externalizable::add_child_element().

Referenced by foedus::storage::MetadataSerializer::save_all_storages_to_xml().

                                                                          {
   array::ArrayMetadataSerializer serializer(reinterpret_cast<array::ArrayMetadata*>(data));
   return externalize::Externalizable::add_child_element(parent, kChildTagName, "", serializer);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::save_to_xml_hash	(	tinyxml2::XMLElement *	parent,
		Metadata *	data
	)

Definition at line 110 of file metadata.cpp.

References foedus::externalize::Externalizable::add_child_element().

Referenced by foedus::storage::MetadataSerializer::save_all_storages_to_xml().

                                                                         {
   hash::HashMetadataSerializer serializer(reinterpret_cast<hash::HashMetadata*>(data));
   return externalize::Externalizable::add_child_element(parent, kChildTagName, "", serializer);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::save_to_xml_masstree	(	tinyxml2::XMLElement *	parent,
		Metadata *	data
	)

Definition at line 114 of file metadata.cpp.

References foedus::externalize::Externalizable::add_child_element().

Referenced by foedus::storage::MetadataSerializer::save_all_storages_to_xml().

                                                                             {
   masstree::MasstreeMetadataSerializer serializer(
     reinterpret_cast<masstree::MasstreeMetadata*>(data));
   return externalize::Externalizable::add_child_element(parent, kChildTagName, "", serializer);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::save_to_xml_sequential	(	tinyxml2::XMLElement *	parent,
		Metadata *	data
	)

Definition at line 119 of file metadata.cpp.

References foedus::externalize::Externalizable::add_child_element().

Referenced by foedus::storage::MetadataSerializer::save_all_storages_to_xml().

                                                                               {
   sequential::SequentialMetadataSerializer serializer(
     reinterpret_cast<sequential::SequentialMetadata*>(data));
   return externalize::Externalizable::add_child_element(parent, kChildTagName, "", serializer);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

SnapshotPagePointer foedus::storage::to_snapshot_page_pointer	(	uint16_t	snapshot_id,
		uint8_t	node,
		SnapshotLocalPageId	local_page_id
	)

inline

Definition at line 106 of file storage_id.hpp.

References assert_valid_snapshot_local_page_id().

Referenced by foedus::snapshot::SnapshotWriter::open().

                                      {
   assert_valid_snapshot_local_page_id(local_page_id);
   return static_cast<uint64_t>(snapshot_id) << 48
       | static_cast<uint64_t>(node) << 40
       | local_page_id;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

const char* foedus::storage::kChildTagName = "storage"

Definition at line 104 of file metadata.cpp.

const StorageName foedus::storage::kEmptyString

Definition at line 59 of file storage_manager.cpp.

Referenced by foedus::storage::StorageManager::get_name().

const uint8_t foedus::storage::kVolatilePointerFlagSwappable = 0x02

Definition at line 176 of file storage_id.hpp.

Detailed Description

Types of Storage

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation