foedus::storage::array Namespace Reference

Array Storage, a dense and regular array. More...

Detailed Description

Array Storage, a dense and regular array.

Basic Structure

Our array-storage is an extremely simple data structure at the cost of limited applicability (fix-sized, regular, dense arrays). The page layout has little per-page information that is dynamic, meaning that most data never changes after the array storage is created. Further, as everything is pre-allocated, no phantoms, no insertion/splits, nor anything complex. Thus, little synchronization hassles.

Supported Operations

Array storage allows very few data operations.

• Reads a record or a range of records.
• Overwrites a record.
• Reads a range of records in batched fashion. (Not implemented so far, just loop over it. This might be useful for a big array of really small records to avoid function call overheads.)

In other words, the following operations are NOT supported.

• Inserts or Deletes a record because all records always exist in an array storage (dense array). Client programs can achieve the same thing by storing one-bit in payload as a deletion-flag and overwrites it.
• Resize individual records or the entire array. All records are fix-sized and pre-allocated when the array storage is initialized.

If these limitations do not cause an issue, array storage is a best choice as it's extremely efficient and scalable thanks to the simplicity.

Page Hierarchy

Despite the name of this storage type, we do have a page hierarchy, which is required to handle switches between volatile/snapshot pages. Hence, a more precise description of this storage type is a fix-sized pre-allocated tree that has only integer-keys from 0 to array_size-1.

All data (payload) are stored in leaf pages and interior pages contain only pointers to its children. There is only one root page per array, which may or may not be a leaf page. Just like B-trees in many sense.

Page Layout

Header and Data

Fix-Sized HEADER (kHeaderSize bytes)	DATA

Interior Node Data

InteriorRecord	InteriorRecord	...

See foedus::storage::array::ArrayPage::InteriorRecord.

Leaf Node Data

Record	Padding	Record	Padding	...

We simply puts foedus::storage::Record contiguously, but with a padding (0-7 bytes). to make sure Record are 8-byte aligned because we do atomic operations on Record's owner_id_.

Concurrency Control

We do a bit special concurrency control for this storage type. Because everything is pre-allocated and no split/physical-delete/merge whatsoever, we can do the ModCount concurrency control per Record, not per page. We store ModCount for each record, instead stores no ModCount in page header. Thus, individual transactions that update records in same page have no contention except they update the exact same record. We even don't track node-set; only record-set is checked at commit.

This simplifies and increases concurrency for most data accesses, but we have to be careful when the page eviction thread drops the volatile page. We need to know the largest Epoch of records in the page at the point, but concurrent transactions might be modifying records at the same time. Thus, we do two-path optimistic concurrency control similar to our commit protocol for Masstree Storage.

• The eviction thread takes a look at all Epoch in the page, remembering the largest one.
• Fence
• Then, it puts a mark on the pointer from the parent page to the evicted page to announce that the volatile page is about to be evicted.
• Fence
• Finally, it takes a look at all Epoch in the page again and completes the eviction only if it sees the same largest Epoch. If not, gives up (because the volatile page is now newer, no chance to drop it with the latest snapshot version).

References

• [SCIDB] Cudre-Mauroux, P. and Kimura, H. and Lim, K.-T. and Rogers, J. and Simakov, R. and Soroush, E. and Velikhov, P. and Wang, D. L. and Balazinska, M. and Becla, J. and DeWitt, D. and Heath, B. and Maier, D. and Madden, S. and Patel, J. and Stonebraker, M. and Zdonik, S. "A demonstration of SciDB: a science-oriented DBMS.", VLDB, 2009.

Classes
struct	ArrayCommonUpdateLogType
	A base class for ArrayOverwriteLogType/ArrayIncrementLogType. More...
class	ArrayComposeContext
	ArrayComposer's compose() implementation separated from the class itself. More...
class	ArrayComposer
	Composer for an array storage. More...
struct	ArrayCreateLogType
	Log type of CREATE ARRAY STORAGE operation. More...
struct	ArrayIncrementLogType
	Log type of array-storage's increment operation. More...
struct	ArrayMetadata
	Metadata of an array storage. More...
struct	ArrayMetadataSerializer
struct	ArrayOverwriteLogType
	Log type of array-storage's overwrite operation. More...
class	ArrayPage
	Represents one data page in Array Storage. More...
class	ArrayPartitioner
	Partitioner for an array storage. More...
struct	ArrayPartitionerData
struct	ArrayRange
	Represents an offset range in an array storage. More...
struct	ArrayRootInfoPage
	Output of one compose() call, which are then combined in construct_root(). More...
class	ArrayStorage
	Represents a key-value store based on a dense and regular array. More...
struct	ArrayStorageControlBlock
	Shared data of this storage type. More...
class	ArrayStoragePimpl
	Pimpl object of ArrayStorage. More...
union	LookupRoute
	Compactly represents the route to reach the given offset. More...
class	LookupRouteFinder
	Packages logic and required properties to calculate LookupRoute in array storage from offset. More...
struct	SortEntry
	Used in sort_batch(). More...

Typedefs
typedef uint64_t	ArrayOffset
	The only key type in array storage. More...

Enumerations
enum	ValueType {   kUnknown = 0, kI8 = 1, kI16, kI32,   kU8, kU16, kU32, kFloat,   kBool, kI64, kU64, kDouble }
	Used in ArrayIncrementLogType. More...

Functions
template<typename T >
ValueType	to_value_type ()
template<>
ValueType	to_value_type< bool > ()
template<>
ValueType	to_value_type< int8_t > ()
template<>
ValueType	to_value_type< int16_t > ()
template<>
ValueType	to_value_type< int32_t > ()
template<>
ValueType	to_value_type< int64_t > ()
template<>
ValueType	to_value_type< uint8_t > ()
template<>
ValueType	to_value_type< uint16_t > ()
template<>
ValueType	to_value_type< uint32_t > ()
template<>
ValueType	to_value_type< uint64_t > ()
template<>
ValueType	to_value_type< float > ()
template<>
ValueType	to_value_type< double > ()
template<typename T >
void	increment (T *payload, const T *addendum)
template<typename T >
void	add_to (void *destination, const void *added)
void	array_volatile_page_init (const VolatilePageInitArguments &args)
	volatile page initialize callback for ArrayPage. More...
uint16_t	to_records_in_leaf (uint16_t payload_size)
std::ostream &	operator<< (std::ostream &o, const ArrayCreateLogType &v)
std::ostream &	operator<< (std::ostream &o, const ArrayOverwriteLogType &v)
template<typename T >
T	as (const void *address)
std::ostream &	operator<< (std::ostream &o, const ArrayIncrementLogType &v)
std::ostream &	operator<< (std::ostream &o, const ArrayMetadata &v)
void	prepare_sort_entries (const Partitioner::SortBatchArguments &args, SortEntry *entries)
	subroutine of sort_batch More...
uint32_t	compact_logs (const Partitioner::SortBatchArguments &args, SortEntry *entries)
	subroutine of sort_batch More...
std::ostream &	operator<< (std::ostream &o, const ArrayPartitioner &v)
std::ostream &	operator<< (std::ostream &o, const ArrayStorage &v)
uint8_t	calculate_levels (const ArrayMetadata &metadata)

Variables
const ArrayOffset	kMaxArrayOffset = (1ULL << 48) - 1ULL
	The maximum value allowed for ArrayOffset. More...
const uint16_t	kHeaderSize = 64
	Byte size of header in each page of array storage. More...
const uint16_t	kDataSize = foedus::storage::kPageSize - kHeaderSize
	Byte size of data region in each page of array storage. More...
const uint16_t	kInteriorSize = 16
	Byte size of an entry in interior page of array storage. More...
const uint16_t	kInteriorFanout = (foedus::storage::kPageSize - kHeaderSize) / kInteriorSize
	Max number of entries in an interior page of array storage. More...
const uint8_t	kMaxLevels = 8
	Code in array storage assumes this number as the maximum number of levels. More...

---

Class Documentation

struct foedus::storage::array::ArrayRootInfoPage

Output of one compose() call, which are then combined in construct_root().

If the root page is leaf page (single-page array), this contains just one pointer to the root. If not, this contains pointers to direct children of root.

Definition at line 92 of file array_composer_impl.hpp.

Collaboration diagram for foedus::storage::array::ArrayRootInfoPage:

Class Members
char	filler_[ kPageSize -sizeof(PageHeader) -kInteriorFanout *sizeof(SnapshotPagePointer)]
PageHeader	header_
SnapshotPagePointer	pointers_[kInteriorFanout]	Pointers to direct children of root. 0 if not set in this compose()

Enumeration Type Documentation

enum foedus::storage::array::ValueType

Used in ArrayIncrementLogType.

Enumerator
kUnknown
kI8
kI16
kI32
kU8
kU16
kU32
kFloat
kBool
kI64
kU64
kDouble

Definition at line 147 of file array_log_types.hpp.

               {
  kUnknown = 0,
  kI8 = 1,
  kI16,
  kI32,
  kU8,
  kU16,
  kU32,
  kFloat,
  kBool,
  // above are 32bits or less, below are 64 bits
  kI64,
  kU64,
  kDouble,
};

Function Documentation

template<typename T >

void foedus::storage::array::add_to ( void *  destination, const void *  added  )

inline

Definition at line 370 of file array_log_types.hpp.

                                                         {
  *(reinterpret_cast< T* >(destination)) += *(reinterpret_cast< const T* >(added));
}

template<typename T >

T foedus::storage::array::as ( const void *  address )

inline

Definition at line 70 of file array_log_types.cpp.

                                 {
  const T* casted = reinterpret_cast<const T*>(address);
  return *casted;
}

uint8_t foedus::storage::array::calculate_levels

(

const ArrayMetadata &

metadata

)

Definition at line 194 of file array_storage_pimpl.cpp.

References foedus::assorted::align8(), foedus::storage::array::ArrayMetadata::array_size_, foedus::assorted::int_div_ceil(), kDataSize, kInteriorFanout, foedus::storage::kRecordOverhead, and foedus::storage::array::ArrayMetadata::payload_size_.

Referenced by foedus::storage::array::ArrayStoragePimpl::load(), and foedus::storage::array::ArrayStoragePimpl::load_empty().

                                                        {
  uint64_t array_size = metadata.array_size_;
  uint16_t payload = assorted::align8(metadata.payload_size_);
  uint64_t records_per_page = kDataSize / (payload + kRecordOverhead);
  uint8_t levels = 1;
  for (uint64_t pages = assorted::int_div_ceil(array_size, records_per_page);
        pages != 1;
        pages = assorted::int_div_ceil(pages, kInteriorFanout)) {
    ++levels;
  }
  return levels;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint32_t foedus::storage::array::compact_logs	(	const Partitioner::SortBatchArguments &	args,
		SortEntry *	entries
	)

subroutine of sort_batch

Definition at line 249 of file array_partitioner_impl.cpp.

References ASSERT_ND, foedus::storage::array::SortEntry::get_offset(), foedus::storage::array::SortEntry::get_position(), foedus::log::LogHeader::get_type(), foedus::log::BaseLogType::header_, foedus::log::kLogCodeArrayIncrement, foedus::log::kLogCodeArrayOverwrite, foedus::storage::Partitioner::SortBatchArguments::log_buffer_, foedus::log::LogHeader::log_type_code_, foedus::storage::Partitioner::SortBatchArguments::logs_count_, foedus::storage::array::ArrayIncrementLogType::merge(), foedus::storage::Partitioner::SortBatchArguments::output_buffer_, foedus::storage::array::ArrayOverwriteLogType::payload_count_, foedus::storage::array::ArrayOverwriteLogType::payload_offset_, foedus::storage::array::ArrayIncrementLogType::payload_offset_, foedus::snapshot::LogBuffer::resolve(), UNLIKELY, and foedus::storage::array::ArrayIncrementLogType::value_type_.

Referenced by foedus::storage::array::ArrayPartitioner::sort_batch().

                                                                                     {
  // CPU profile of partition_array_perf: 30-35%.
  // Yeah, this is not cheap... but it can dramatically compact the logs.
  uint32_t result_count = 1;
  args.output_buffer_[0] = entries[0].get_position();
  ArrayOffset prev_offset = entries[0].get_offset();
  for (uint32_t i = 1; i < args.logs_count_; ++i) {
    // compact the logs if the same offset appears in a row, and covers the same data region.
    // because we sorted it by offset and then ordinal, later logs can overwrite the earlier one.
    ArrayOffset cur_offset = entries[i].get_offset();
    // wow, adding this UNLIKELY changed the CPU cost of this function from 35% to 13%,
    // throughput of entire partition_array_perf 5M to 8.5M. because in this experiment
    // there are few entries with same offset. I haven't seen this much difference with
    // gcc's unlikely hint before! umm, compiler is not that smart, after all.
    // this will penalize the case where we have many compaction, but in that case
    // the following code has more cost anyways.
    if (UNLIKELY(cur_offset == prev_offset)) {
      const log::RecordLogType* prev_p = args.log_buffer_.resolve(entries[i - 1].get_position());
      log::RecordLogType* next_p = args.log_buffer_.resolve(entries[i].get_position());
      if (prev_p->header_.log_type_code_ != next_p->header_.log_type_code_) {
        // increment log can be superseded by overwrite log,
        // overwrite log can be merged with increment log.
        // however, these usecases are probably much less frequent than the following.
        // so, we don't compact this case so far.
      } else if (prev_p->header_.get_type() == log::kLogCodeArrayOverwrite) {
        // two overwrite logs might be compacted
        const ArrayOverwriteLogType* prev = reinterpret_cast<const ArrayOverwriteLogType*>(prev_p);
        const ArrayOverwriteLogType* next = reinterpret_cast<const ArrayOverwriteLogType*>(next_p);
        // is the data region same or superseded?
        uint16_t prev_begin = prev->payload_offset_;
        uint16_t prev_end = prev_begin + prev->payload_count_;
        uint16_t next_begin = next->payload_offset_;
        uint16_t next_end = next_begin + next->payload_count_;
        if (next_begin <= prev_begin && next_end >= prev_end) {
          --result_count;
        }

        // the logic checks data range against only the previous entry.
        // we might have a situation where 3 or more log entries have the same array offset
        // and the data regions are like following
        // Log 1: [4, 8) bytes, Log 2: [8, 12) bytes, Log 3: [4, 8) bytes
        // If we check further, Log 3 can eliminate Log 1. However, the check is expensive..
      } else {
        // two increment logs of same type/offset can be merged into one.
        ASSERT_ND(prev_p->header_.get_type() == log::kLogCodeArrayIncrement);
        const ArrayIncrementLogType* prev = reinterpret_cast<const ArrayIncrementLogType*>(prev_p);
        ArrayIncrementLogType* next = reinterpret_cast<ArrayIncrementLogType*>(next_p);
        if (prev->value_type_ == next->value_type_
          && prev->payload_offset_ == next->payload_offset_) {
          // add up the prev's addendum to next, then delete prev.
          next->merge(*prev);
          --result_count;
        }
      }
    } else {
      prev_offset = cur_offset;
    }
    args.output_buffer_[result_count] = entries[i].get_position();
    ++result_count;
  }
  return result_count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

void foedus::storage::array::increment ( T *  payload, const T *  addendum  )

inline

Definition at line 299 of file array_log_types.hpp.

                                                     {
  *payload += *addendum;
}

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

Definition at line 33 of file array_metadata.cpp.

                                                              {
  o << ArrayMetadataSerializer(const_cast<ArrayMetadata*>(&v));
  return o;
}

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

Definition at line 48 of file array_log_types.cpp.

References foedus::storage::array::ArrayCreateLogType::metadata_.

                                                                   {
  o << "<ArrayCreateLog>" << v.metadata_ << "</ArrayCreateLog>";
  return o;
}

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

Definition at line 53 of file array_log_types.cpp.

References foedus::storage::array::ArrayCommonUpdateLogType::offset_, foedus::storage::array::ArrayOverwriteLogType::payload_, foedus::storage::array::ArrayOverwriteLogType::payload_count_, and foedus::storage::array::ArrayOverwriteLogType::payload_offset_.

                                                                      {
  o << "<ArrayOverwriteLog>"
    << "<offset_>" << v.offset_ << "</offset_>"
    << "<payload_offset_>" << v.payload_offset_ << "</payload_offset_>"
    << "<payload_count_>" << v.payload_count_ << "</payload_count_>";
  // show first few bytes
  o << "<data_>";
  for (uint16_t i = 0; i < std::min<uint16_t>(8, v.payload_count_); ++i) {
    o << i << ":" << static_cast<int>(v.payload_[i]) << " ";
  }
  o << "...</data_>";
  o << "</ArrayOverwriteLog>";
  return o;
}

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

Definition at line 60 of file array_storage.cpp.

References foedus::storage::array::ArrayStorage::get_array_size(), foedus::storage::Storage< CONTROL_BLOCK >::get_id(), foedus::storage::Storage< CONTROL_BLOCK >::get_name(), and foedus::storage::array::ArrayStorage::get_payload_size().

                                                             {
  o << "<ArrayStorage>"
    << "<id>" << v.get_id() << "</id>"
    << "<name>" << v.get_name() << "</name>"
    << "<payload_size>" << v.get_payload_size() << "</payload_size>"
    << "<array_size>" << v.get_array_size() << "</array_size>"
    << "</ArrayStorage>";
  return o;
}

Here is the call graph for this function:

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

Definition at line 75 of file array_log_types.cpp.

References foedus::storage::array::ArrayIncrementLogType::addendum_, ASSERT_ND, foedus::storage::array::ArrayIncrementLogType::get_value_type(), kBool, kDouble, kFloat, kI16, kI32, kI64, kI8, kU16, kU32, kU64, kU8, foedus::storage::array::ArrayCommonUpdateLogType::offset_, and foedus::storage::array::ArrayIncrementLogType::payload_offset_.

                                                                      {
  o << "<ArrayIncrementLog>"
    << "<offset_>" << v.offset_ << "</offset_>"
    << "<payload_offset_>" << v.payload_offset_ << "</payload_offset_>"
    << "<type_>";
  switch (v.get_value_type()) {
    // 32 bit data types
    case kI8:
      o << "int8_t</type><addendum_>" << static_cast<int16_t>(as<int8_t>(v.addendum_));
      break;
    case kI16:
      o << "int16_t</type><addendum_>" << as<int16_t>(v.addendum_);
      break;
    case kI32:
      o << "int32_t</type><addendum_>" << as<int32_t>(v.addendum_);
      break;
    case kBool:
    case kU8:
      o << "uint8_t</type><addendum_>" << static_cast<uint16_t>(as<uint8_t>(v.addendum_));
      break;
    case kU16:
      o << "uint16_t</type><addendum_>" << as<uint16_t>(v.addendum_);
      break;
    case kU32:
      o << "uint32_t</type><addendum_>" << as<uint32_t>(v.addendum_);
      break;
    case kFloat:
      o << "float</type><addendum_>" << as<float>(v.addendum_);
      break;

    // 64 bit data types
    case kI64:
      o << "int64_t</type><addendum_>" << as<int64_t>(v.addendum_ + 4);
      break;
    case kU64:
      o << "uint64_t</type><addendum_>" << as<uint64_t>(v.addendum_ + 4);
      break;
    case kDouble:
      o << "double</type><addendum_>" << as<double>(v.addendum_ + 4);
      break;
    default:
      o << "UNKNOWN(" << v.get_value_type() << ")</type><addendum_>";
      ASSERT_ND(false);
      break;
  }
  o << "</addendum_>";
  o << "</ArrayIncrementLog>";
  return o;
}

Here is the call graph for this function:

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

Definition at line 347 of file array_partitioner_impl.cpp.

References foedus::storage::array::ArrayPartitionerData::array_size_, foedus::storage::array::ArrayPartitionerData::bucket_owners_, foedus::storage::array::ArrayPartitionerData::bucket_size_, and kInteriorFanout.

                                                                 {
  o << "<ArrayPartitioner>";
  if (v.data_) {
    o << "<array_size_>" << v.data_->array_size_ << "</array_size_>"
      << "<bucket_size_>" << v.data_->bucket_size_ << "</bucket_size_>";
    for (uint16_t i = 0; i < kInteriorFanout; ++i) {
      o << "<range bucket=\"" << i << "\" partition=\"" << v.data_->bucket_owners_[i] << "\" />";
    }
  } else {
    o << "Not yet designed";
  }
  o << "</ArrayPartitioner>";
  return o;
}

void foedus::storage::array::prepare_sort_entries	(	const Partitioner::SortBatchArguments &	args,
		SortEntry *	entries
	)

subroutine of sort_batch

Definition at line 228 of file array_partitioner_impl.cpp.

References ASSERT_ND, foedus::storage::Partitioner::SortBatchArguments::base_epoch_, foedus::xct::XctId::get_epoch(), foedus::xct::XctId::get_ordinal(), foedus::log::BaseLogType::header_, foedus::log::kLogCodeArrayIncrement, foedus::log::kLogCodeArrayOverwrite, foedus::storage::Partitioner::SortBatchArguments::log_buffer_, foedus::storage::Partitioner::SortBatchArguments::log_positions_, foedus::log::LogHeader::log_type_code_, foedus::storage::Partitioner::SortBatchArguments::logs_count_, foedus::storage::array::ArrayCommonUpdateLogType::offset_, foedus::snapshot::LogBuffer::resolve(), foedus::storage::array::SortEntry::set(), foedus::Epoch::subtract(), and foedus::log::LogHeader::xct_id_.

Referenced by foedus::storage::array::ArrayPartitioner::sort_batch().

                                                                                         {
  // CPU profile of partition_array_perf: 6-10%.
  const Epoch base_epoch = args.base_epoch_;
  for (uint32_t i = 0; i < args.logs_count_; ++i) {
    const ArrayCommonUpdateLogType* log_entry = reinterpret_cast<const ArrayCommonUpdateLogType*>(
      args.log_buffer_.resolve(args.log_positions_[i]));
    ASSERT_ND(log_entry->header_.log_type_code_ == log::kLogCodeArrayOverwrite
      || log_entry->header_.log_type_code_ == log::kLogCodeArrayIncrement);
    Epoch epoch = log_entry->header_.xct_id_.get_epoch();
    ASSERT_ND(epoch.subtract(base_epoch) < (1U << 16));
    uint16_t compressed_epoch = epoch.subtract(base_epoch);
    entries[i].set(
      log_entry->offset_,
      compressed_epoch,
      log_entry->header_.xct_id_.get_ordinal(),
      args.log_positions_[i]);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint16_t foedus::storage::array::to_records_in_leaf ( uint16_t  payload_size )

inline

Definition at line 71 of file array_route.hpp.

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

Referenced by foedus::storage::array::LookupRoute::calculate_page_range().

                                                          {
  return kDataSize / (assorted::align8(payload_size) + kRecordOverhead);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

ValueType foedus::storage::array::to_value_type

(

)

template<>

ValueType foedus::storage::array::to_value_type< bool > ( )

inline

Definition at line 163 of file array_log_types.hpp.

References kBool.

{ return kBool; }

template<>

ValueType foedus::storage::array::to_value_type< double > ( )

inline

Definition at line 173 of file array_log_types.hpp.

References kDouble.

{ return kDouble ; }

template<>

ValueType foedus::storage::array::to_value_type< float > ( )

inline

Definition at line 172 of file array_log_types.hpp.

References kFloat.

{ return kFloat; }

template<>

ValueType foedus::storage::array::to_value_type< int16_t > ( )

inline

Definition at line 165 of file array_log_types.hpp.

References kI16.

{ return kI16; }

template<>

ValueType foedus::storage::array::to_value_type< int32_t > ( )

inline

Definition at line 166 of file array_log_types.hpp.

References kI32.

{ return kI32; }

template<>

ValueType foedus::storage::array::to_value_type< int64_t > ( )

inline

Definition at line 167 of file array_log_types.hpp.

References kI64.

{ return kI64; }

template<>

ValueType foedus::storage::array::to_value_type< int8_t > ( )

inline

Definition at line 164 of file array_log_types.hpp.

References kI8.

{ return kI8; }

template<>

ValueType foedus::storage::array::to_value_type< uint16_t > ( )

inline

Definition at line 169 of file array_log_types.hpp.

References kU16.

{ return kU16; }

template<>

ValueType foedus::storage::array::to_value_type< uint32_t > ( )

inline

Definition at line 170 of file array_log_types.hpp.

References kU32.

{ return kU32; }

template<>

ValueType foedus::storage::array::to_value_type< uint64_t > ( )

inline

Definition at line 171 of file array_log_types.hpp.

References kU64.

{ return kU64; }

template<>

ValueType foedus::storage::array::to_value_type< uint8_t > ( )

inline

Definition at line 168 of file array_log_types.hpp.

References kU8.

{ return kU8; }