Assorted Methods/Classes that are too subtle to have their own packages. More...

Detailed Description

Assorted Methods/Classes that are too subtle to have their own packages.

Do NOT use this package to hold hundleds of classes/methods. That's a class design failure. This package should contain really only a few methods and classes, each of which should be extremely simple and unrelated each other. Otherwise, make a package for them. Learn from the stupid history of java.util.

Collaboration diagram for Assorted Methods/Classes:

Files
file	atomic_fences.hpp
	Atomic fence methods and load/store with fences that work for both C++11/non-C++11 code.

file	cacheline.hpp
	Constants and methods related to CPU cacheline and its prefetching.

file	endianness.hpp
	A few macros and helper methods related to byte endian-ness.

file	raw_atomics.hpp
	Raw atomic operations that work for both C++11 and non-C++11 code.

Classes
struct	foedus::assorted::Hex
	Convenient way of writing hex integers to stream. More...

struct	foedus::assorted::HexString
	Equivalent to std::hex in case the stream doesn't support it. More...

struct	foedus::assorted::Top
	Write only first few bytes to stream. More...

struct	foedus::assorted::ConstDiv
	The pre-calculated p-m pair for optimized integer division by constant. More...

class	foedus::assorted::DumbSpinlock
	A simple spinlock using a boolean field. More...

class	foedus::assorted::FixedString< MAXLEN, CHAR >
	An embedded string object of fixed max-length, which uses no external memory. More...

struct	foedus::assorted::ProbCounter
	Implements a probabilistic counter [Morris 1978]. More...

struct	foedus::assorted::ProtectedBoundary
	A 4kb dummy data placed between separate memory regions so that we can check if/where a bogus memory access happens. More...

class	foedus::assorted::UniformRandom
	A very simple and deterministic random generator that is more aligned with standard benchmark such as TPC-C. More...

class	foedus::assorted::ZipfianRandom
	A simple zipfian generator based off of YCSB's Java implementation. More...

Macros
#define	SPINLOCK_WHILE(x) for (foedus::assorted::SpinlockStat __spins; (x); __spins.yield_backoff())
	A macro to busy-wait (spinlock) with occasional pause. More...

#define	INSTANTIATE_ALL_TYPES(M)
	A macro to explicitly instantiate the given template for all types we care. More...

#define	INSTANTIATE_ALL_NUMERIC_TYPES(M)
	INSTANTIATE_ALL_TYPES minus std::string. More...

#define	INSTANTIATE_ALL_INTEGER_PLUS_BOOL_TYPES(M)
	INSTANTIATE_ALL_TYPES minus std::string/float/double. More...

#define	INSTANTIATE_ALL_INTEGER_TYPES(M)
	INSTANTIATE_ALL_NUMERIC_TYPES minus bool/double/float. More...

Functions
template<typename T , uint64_t ALIGNMENT>
T	foedus::assorted::align (T value)
	Returns the smallest multiply of ALIGNMENT that is equal or larger than the given number. More...

template<typename T >
T	foedus::assorted::align8 (T value)
	8-alignment. More...

template<typename T >
T	foedus::assorted::align16 (T value)
	16-alignment. More...

template<typename T >
T	foedus::assorted::align64 (T value)
	64-alignment. More...

int64_t	foedus::assorted::int_div_ceil (int64_t dividee, int64_t dividor)
	Efficient ceil(dividee/dividor) for integer. More...

std::string	foedus::assorted::replace_all (const std::string &target, const std::string &search, const std::string &replacement)
	target.replaceAll(search, replacement). More...

std::string	foedus::assorted::replace_all (const std::string &target, const std::string &search, int replacement)
	target.replaceAll(search, String.valueOf(replacement)). More...

std::string	foedus::assorted::os_error ()
	Thread-safe strerror(errno). More...

std::string	foedus::assorted::os_error (int error_number)
	This version receives errno. More...

std::string	foedus::assorted::get_current_executable_path ()
	Returns the full path of current executable. More...

void	foedus::assorted::spinlock_yield ()
	Invoke _mm_pause(), x86 PAUSE instruction, or something equivalent in the env. More...

template<uint64_t SIZE1, uint64_t SIZE2>
int	foedus::assorted::static_size_check ()
	Alternative for static_assert(sizeof(foo) == sizeof(bar), "oh crap") to display sizeof(foo). More...

std::string	foedus::assorted::demangle_type_name (const char *mangled_name)
	Demangle the given C++ type name if possible (otherwise the original string). More...

template<typename T >
std::string	foedus::assorted::get_pretty_type_name ()
	Returns the name of the C++ type as readable as possible. More...

uint64_t	foedus::assorted::generate_almost_prime_below (uint64_t threshold)
	Generate a prime or some number that is almost prime less than the given number. More...

void	foedus::assorted::memory_fence_acquire ()
	Equivalent to std::atomic_thread_fence(std::memory_order_acquire). More...

void	foedus::assorted::memory_fence_release ()
	Equivalent to std::atomic_thread_fence(std::memory_order_release). More...

void	foedus::assorted::memory_fence_acq_rel ()
	Equivalent to std::atomic_thread_fence(std::memory_order_acq_rel). More...

void	foedus::assorted::memory_fence_consume ()
	Equivalent to std::atomic_thread_fence(std::memory_order_consume). More...

void	foedus::assorted::memory_fence_seq_cst ()
	Equivalent to std::atomic_thread_fence(std::memory_order_seq_cst). More...

template<typename T >
T	foedus::assorted::atomic_load_seq_cst (const T *target)
	Atomic load with a seq_cst barrier for raw primitive types rather than std::atomic<T>. More...

template<typename T >
T	foedus::assorted::atomic_load_acquire (const T *target)
	Atomic load with an acquire barrier for raw primitive types rather than std::atomic<T>. More...

template<typename T >
T	foedus::assorted::atomic_load_consume (const T *target)
	Atomic load with a consume barrier for raw primitive types rather than std::atomic<T>. More...

template<typename T >
void	foedus::assorted::atomic_store_seq_cst (T *target, T value)
	Atomic store with a seq_cst barrier for raw primitive types rather than std::atomic<T>. More...

template<typename T >
void	foedus::assorted::atomic_store_release (T *target, T value)
	Atomic store with a release barrier for raw primitive types rather than std::atomic<T>. More...

void	foedus::assorted::prefetch_cacheline (const void *address)
	Prefetch one cacheline to L1 cache. More...

void	foedus::assorted::prefetch_cachelines (const void *address, int cacheline_count)
	Prefetch multiple contiguous cachelines to L1 cache. More...

void	foedus::assorted::prefetch_l2 (const void *address, int cacheline_count)
	Prefetch multiple contiguous cachelines to L2/L3 cache. More...

template<typename T >
T	foedus::assorted::read_bigendian (const void *be_bytes)
	Convert a big-endian byte array to a native integer. More...

template<typename T >
void	foedus::assorted::write_bigendian (T host_value, void *be_bytes)
	Convert a native integer to big-endian bytes and write them to the given address. More...

int	foedus::assorted::mod_numa_node (int numa_node)
	In order to run even on a non-numa machine or a machine with fewer sockets, we allow specifying arbitrary numa_node. More...

template<typename T >
bool	foedus::assorted::raw_atomic_compare_exchange_strong (T target, T expected, T desired)
	Atomic CAS. More...

template<typename T >
bool	foedus::assorted::raw_atomic_compare_exchange_weak (T target, T expected, T desired)
	Weak version of raw_atomic_compare_exchange_strong(). More...

bool	foedus::assorted::raw_atomic_compare_exchange_strong_uint128 (uint64_t ptr, const uint64_t old_value, const uint64_t *new_value)
	Atomic 128-bit CAS, which is not in the standard yet. More...

bool	foedus::assorted::raw_atomic_compare_exchange_weak_uint128 (uint64_t ptr, const uint64_t old_value, const uint64_t *new_value)
	Weak version of raw_atomic_compare_exchange_strong_uint128(). More...

template<typename T >
T	foedus::assorted::raw_atomic_exchange (T *target, T desired)
	Atomic Swap for raw primitive types rather than std::atomic<T>. More...

template<typename T >
T	foedus::assorted::raw_atomic_fetch_add (T *target, T addendum)
	Atomic fetch-add for raw primitive types rather than std::atomic<T>. More...

template<typename T >
T	foedus::assorted::raw_atomic_fetch_and_bitwise_and (T *target, T operand)
	Atomic fetch-bitwise-and for raw primitive types rather than std::atomic<T>. More...

template<typename T >
T	foedus::assorted::raw_atomic_fetch_and_bitwise_or (T *target, T operand)
	Atomic fetch-bitwise-or for raw primitive types rather than std::atomic<T>. More...

template<typename T >
T	foedus::assorted::raw_atomic_fetch_and_bitwise_xor (T *target, T operand)
	Atomic fetch-bitwise-xor for raw primitive types rather than std::atomic<T> More...

Variables
const uint16_t	foedus::assorted::kCachelineSize = 64
	Byte count of one cache line. More...

const bool	foedus::assorted::kIsLittleEndian = false
	A handy const boolean to tell if it's little endina. More...

Macro Definition Documentation

#define INSTANTIATE_ALL_INTEGER_PLUS_BOOL_TYPES ( M )

Value:

INSTANTIATE_ALL_INTEGER_TYPES(M);\

M(bool);

INSTANTIATE_ALL_INTEGER_TYPES

#define INSTANTIATE_ALL_INTEGER_TYPES(M)

INSTANTIATE_ALL_NUMERIC_TYPES minus bool/double/float.

Definition: assorted_func.hpp:313

INSTANTIATE_ALL_TYPES minus std::string/float/double.

Definition at line 317 of file assorted_func.hpp.

#define INSTANTIATE_ALL_INTEGER_TYPES ( M )

Value:

M(int64_t);  \
  M(int32_t); M(int16_t); M(int8_t); M(uint64_t);  \
  M(uint32_t); M(uint16_t); M(uint8_t); 

INSTANTIATE_ALL_NUMERIC_TYPES minus bool/double/float.

Definition at line 313 of file assorted_func.hpp.

#define INSTANTIATE_ALL_NUMERIC_TYPES ( M )

Value:

INSTANTIATE_ALL_INTEGER_TYPES(M);\

M(bool); M(float); M(double);

INSTANTIATE_ALL_INTEGER_TYPES

#define INSTANTIATE_ALL_INTEGER_TYPES(M)

INSTANTIATE_ALL_NUMERIC_TYPES minus bool/double/float.

Definition: assorted_func.hpp:313

INSTANTIATE_ALL_TYPES minus std::string.

Definition at line 320 of file assorted_func.hpp.

#define INSTANTIATE_ALL_TYPES ( M )

Value:

INSTANTIATE_ALL_NUMERIC_TYPES(M);\

M(std::string);

INSTANTIATE_ALL_NUMERIC_TYPES

#define INSTANTIATE_ALL_NUMERIC_TYPES(M)

INSTANTIATE_ALL_TYPES minus std::string.

Definition: assorted_func.hpp:320

A macro to explicitly instantiate the given template for all types we care.

M is the macro to explicitly instantiate a template for the given type. This macro explicitly instantiates the template for bool, float, double, all integers (signed/unsigned), and std::string. This is useful when definition of the template class/method involve too many details and you rather want to just give declaration of them in header.

Use this as follows. In header file.

template <typename T> void cool_func(T arg);

Then, in cpp file.

template <typename T> void cool_func(T arg) {
  ... (implementation code)
}
#define EXPLICIT_INSTANTIATION_COOL_FUNC(x) template void cool_func< x > (x arg);
INSTANTIATE_ALL_TYPES(EXPLICIT_INSTANTIATION_COOL_FUNC);

Remember, you should invoke this macro in cpp, not header, otherwise you will get multiple-definition errors.

Note: Doxygen doesn't understand template explicit instantiation, giving warnings. Not a big issue, but you should shut up the Doxygen warnings by putting cond/endcond. See externalizable.cpp for example.

Definition at line 323 of file assorted_func.hpp.

#define SPINLOCK_WHILE ( x ) for (foedus::assorted::SpinlockStat __spins; (x); __spins.yield_backoff())

A macro to busy-wait (spinlock) with occasional pause.

Use this as follows.

SPINLOCK_WHILE(my_variable == 0) {
  do_something();
}

Definition at line 256 of file assorted_func.hpp.

Referenced by foedus::snapshot::LogGleaner::execute(), foedus::xct::XctManagerPimpl::handle_epoch_chime(), foedus::xct::XctManagerPimpl::handle_epoch_chime_wait_grace_period(), foedus::snapshot::SnapshotManagerPimpl::handle_snapshot(), foedus::assorted::DumbSpinlock::lock(), foedus::thread::ThreadPimpl::set_thread_schedule(), and foedus::log::LogManagerPimpl::wait_until_durable().

Function Documentation

template<typename T , uint64_t ALIGNMENT>

T foedus::assorted::align ( T value )

inline

Returns the smallest multiply of ALIGNMENT that is equal or larger than the given number.

Template Parameters

T	integer type
ALIGNMENT	alignment size. must be power of two

In other words, round-up. For example of 8-alignment, 7 becomes 8, 8 becomes 8, 9 becomes 16.

See also: https://en.wikipedia.org/wiki/Data_structure_alignment; Hacker's Delight 2nd Ed. Chap 3-1.

Definition at line 44 of file assorted_func.hpp.

References ASSERT_ND.

                         {
   uint64_t left = (value + ALIGNMENT - 1);
   uint64_t right = -ALIGNMENT;
   uint64_t result = left & right;
   ASSERT_ND(result >= static_cast<uint64_t>(value));
   ASSERT_ND(result % ALIGNMENT == 0);
   ASSERT_ND(result < static_cast<uint64_t>(value) + ALIGNMENT);
   return static_cast<T>(result);
 }

template<typename T >

T foedus::assorted::align16 ( T value )

inline

16-alignment.

Definition at line 64 of file assorted_func.hpp.

64 { return align<T, 16>(value); }

template<typename T >

T foedus::assorted::align64 ( T value )

inline

64-alignment.

Definition at line 70 of file assorted_func.hpp.

70 { return align<T, 64>(value); }

template<typename T >

T foedus::assorted::align8 ( T value )

inline

8-alignment.

Definition at line 58 of file assorted_func.hpp.

58 { return align<T, 8>(value); }

Here is the caller graph for this function:

template<typename T >

T foedus::assorted::atomic_load_acquire ( const T * target )

inline

Atomic load with an acquire barrier for raw primitive types rather than std::atomic<T>.

Template Parameters

T	integer type

Returns: result of load

Definition at line 114 of file atomic_fences.hpp.

                                               {
   return ::__atomic_load_n(target, __ATOMIC_ACQUIRE);
 }

template<typename T >

T foedus::assorted::atomic_load_consume ( const T * target )

inline

Atomic load with a consume barrier for raw primitive types rather than std::atomic<T>.

Template Parameters

T	integer type

Returns: result of load

Definition at line 125 of file atomic_fences.hpp.

                                               {
   return ::__atomic_load_n(target, __ATOMIC_CONSUME);
 }

template<typename T >

T foedus::assorted::atomic_load_seq_cst ( const T * target )

inline

Atomic load with a seq_cst barrier for raw primitive types rather than std::atomic<T>.

Template Parameters

T	integer type

Returns: result of load

Definition at line 103 of file atomic_fences.hpp.

                                               {
   return ::__atomic_load_n(target, __ATOMIC_SEQ_CST);
 }

template<typename T >

void foedus::assorted::atomic_store_release	(	T *	target,
		T	value
	)

inline

Atomic store with a release barrier for raw primitive types rather than std::atomic<T>.

Template Parameters

T	integer type

Definition at line 145 of file atomic_fences.hpp.

                                                      {
   ::__atomic_store_n(target, value, __ATOMIC_RELEASE);
 }

template<typename T >

void foedus::assorted::atomic_store_seq_cst	(	T *	target,
		T	value
	)

inline

Atomic store with a seq_cst barrier for raw primitive types rather than std::atomic<T>.

Template Parameters

T	integer type

Definition at line 135 of file atomic_fences.hpp.

                                                      {
   ::__atomic_store_n(target, value, __ATOMIC_SEQ_CST);
 }

std::string foedus::assorted::demangle_type_name ( const char * mangled_name )

Demangle the given C++ type name if possible (otherwise the original string).

Definition at line 151 of file assorted_func.cpp.

References foedus::fs::status().

Referenced by foedus::assorted::get_pretty_type_name(), foedus::assorted::BacktraceContext::get_results(), and foedus::assorted::BacktraceContext::GlibcBacktraceInfo::parse_symbol().

                                                        {
 #ifdef __GNUC__
   int status;
   char* demangled = abi::__cxa_demangle(mangled_name, nullptr, nullptr, &status);
   if (demangled) {
     std::string ret(demangled);
     ::free(demangled);
     return ret;
   }
 #endif  // __GNUC__
   return mangled_name;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint64_t foedus::assorted::generate_almost_prime_below ( uint64_t threshold )

Generate a prime or some number that is almost prime less than the given number.

Parameters

[in] threshold Returns a number less than this number

In a few places, we need a number that is a prime or at least not divided by many numbers. For example in hashing. It doesn't have to be a real prime. Instead, we want to cheaply calculate such number. This method uses a complex polynomial to generate that looks-like a prime.

See also: http://mathworld.wolfram.com/Prime-GeneratingPolynomial.html

Definition at line 164 of file assorted_func.cpp.

Referenced by foedus::cache::determine_logical_buckets().

                                                          {
   if (threshold <= 2) {
     return 1;  // almost an invalid input...
   } else if (threshold < 5000) {
     // for a small number, we just use a (very) sparse prime list
     uint16_t small_primes[] = {3677, 2347, 1361, 773, 449, 263, 151, 89, 41, 17, 2};
     for (int i = 0;; ++i) {
       if (threshold > small_primes[i]) {
         return small_primes[i];
       }
     }
   } else {
     // the following formula is monotonically increasing for i>=22 (which gives 3923).
     uint64_t prev = 3677;
     for (uint64_t i = 22;; ++i) {
       uint64_t cur = (i * i * i * i * i - 133 * i * i * i * i + 6729 * i * i * i
         - 158379 * i * i + 1720294 * i - 6823316) >> 2;
       if (cur >= threshold) {
         return prev;
       } else if (cur <= prev) {
         // sanity checking.
         return prev;
       } else {
         prev = cur;
       }
     }
   }
 }

Here is the caller graph for this function:

std::string foedus::assorted::get_current_executable_path ( )

Returns the full path of current executable.

This relies on linux /proc/self/exe. Not sure how to port it to Windows..

Definition at line 81 of file assorted_func.cpp.

References foedus::assorted::os_error().

Referenced by foedus::soc::SocOptions::convert_spawn_executable_pattern().

                                         {
   char buf[1024];
   ssize_t len = ::readlink("/proc/self/exe", buf, sizeof(buf));
   if (len == -1) {
     std::cerr << "Failed to get the path of current executable. error=" << os_error() << std::endl;
     return "";
   }
   return std::string(buf, len);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

std::string foedus::assorted::get_pretty_type_name ( )

Returns the name of the C++ type as readable as possible.

Template Parameters

T the type

Definition at line 215 of file assorted_func.hpp.

References foedus::assorted::demangle_type_name().

Referenced by foedus::externalize::Externalizable::add_element().

                                  {
   return demangle_type_name(typeid(T).name());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int64_t foedus::assorted::int_div_ceil	(	int64_t	dividee,
		int64_t	dividor
	)

Efficient ceil(dividee/dividor) for integer.

Definition at line 40 of file assorted_func.cpp.

Referenced by foedus::memory::PagePoolPimpl::attach(), foedus::storage::array::calculate_levels(), foedus::storage::array::ArrayStoragePimpl::calculate_required_pages(), foedus::storage::array::ArrayComposer::construct_root(), foedus::storage::hash::HashStorageControlBlock::get_root_children(), and foedus::EngineOptions::prescreen().

                                                        {
   std::ldiv_t result = std::div(dividee, dividor);
   return result.rem != 0 ? (result.quot + 1) : result.quot;
 }

Here is the caller graph for this function:

void foedus::assorted::memory_fence_acq_rel ( )

inline

Equivalent to std::atomic_thread_fence(std::memory_order_acq_rel).

A load operation with this memory order performs the acquire operation on the affected memory location and a store operation with this memory order performs the release operation.

Definition at line 69 of file atomic_fences.hpp.

Referenced by foedus::soc::SharedPolling::acquire_ticket(), foedus::soc::SharedCond::broadcast(), foedus::soc::MasterEngineStatus::change_init_atomic(), foedus::soc::ChildEngineStatus::change_init_atomic(), foedus::soc::MasterEngineStatus::change_status_atomic(), foedus::soc::ChildEngineStatus::change_status_atomic(), foedus::soc::MasterEngineStatus::change_uninit_atomic(), foedus::soc::ChildEngineStatus::change_uninit_atomic(), foedus::storage::StorageManagerPimpl::clone_all_storage_metadata(), foedus::log::ThreadLogBuffer::get_logs_to_write(), foedus::soc::SharedPolling::initialize(), foedus::EnginePimpl::initialize_once(), foedus::xct::XctManagerPimpl::precommit_xct_readwrite(), foedus::soc::MasterEngineStatus::read_status_atomic(), foedus::soc::ChildEngineStatus::read_status_atomic(), foedus::soc::SharedPolling::signal(), foedus::storage::sequential::SequentialStoragePimpl::truncate(), foedus::assorted::DumbSpinlock::unlock(), foedus::soc::SocManagerPimpl::wait_for_children_module(), and foedus::soc::SocManagerPimpl::wait_for_master_module().

                                    {
   ::__atomic_thread_fence(__ATOMIC_ACQ_REL);
 }

Here is the caller graph for this function:

void foedus::assorted::memory_fence_acquire ( )

inline

Equivalent to std::atomic_thread_fence(std::memory_order_acquire).

A load operation with this memory order performs the acquire operation on the affected memory location: prior writes made to other memory locations by the thread that did the release become visible in this thread.

Definition at line 46 of file atomic_fences.hpp.

                                    {
   ::__atomic_thread_fence(__ATOMIC_ACQUIRE);
 }

Here is the caller graph for this function:

void foedus::assorted::memory_fence_consume ( )

inline

Equivalent to std::atomic_thread_fence(std::memory_order_consume).

A load operation with this memory order performs a consume operation on the affected memory location: prior writes to data-dependent memory locations made by the thread that did a release operation become visible to this thread.

Definition at line 81 of file atomic_fences.hpp.

Referenced by foedus::storage::array::ArrayStoragePimpl::get_record_for_write_batch(), foedus::storage::array::ArrayStoragePimpl::get_record_payload_batch(), foedus::storage::array::ArrayStoragePimpl::get_record_primitive_batch(), foedus::storage::masstree::MasstreeStoragePimpl::locate_record(), foedus::storage::hash::RecordLocation::populate_logical(), and foedus::storage::hash::HashStoragePimpl::track_moved_record_search().

                                    {
   ::__atomic_thread_fence(__ATOMIC_CONSUME);
 }

Here is the caller graph for this function:

void foedus::assorted::memory_fence_release ( )

inline

Equivalent to std::atomic_thread_fence(std::memory_order_release).

A store operation with this memory order performs the release operation: prior writes to other memory locations become visible to the threads that do a consume or an acquire on the same location.

Definition at line 58 of file atomic_fences.hpp.

                                    {
   ::__atomic_thread_fence(__ATOMIC_RELEASE);
 }

Here is the caller graph for this function:

void foedus::assorted::memory_fence_seq_cst ( )

inline

Equivalent to std::atomic_thread_fence(std::memory_order_seq_cst).

Same as memory_order_acq_rel, plus a single total order exists in which all threads observe all modifications in the same order.

Definition at line 92 of file atomic_fences.hpp.

                                    {
   ::__atomic_thread_fence(__ATOMIC_SEQ_CST);
 }

int foedus::assorted::mod_numa_node ( int numa_node )

inline

In order to run even on a non-numa machine or a machine with fewer sockets, we allow specifying arbitrary numa_node.

we just take mod.

Definition at line 31 of file mod_numa_node.hpp.

References numa_available(), and numa_num_configured_nodes().

Referenced by foedus::memory::AlignedMemory::alloc(), foedus::thread::NumaThreadScope::NumaThreadScope(), and foedus::memory::ScopedNumaPreferred::ScopedNumaPreferred().

                                         {
   // if the machine is not a NUMA machine (1-socket), then avoid calling libnuma functions.
   if (::numa_available() < 0) {
     return 0;
   }
   int hardware_nodes = ::numa_num_configured_nodes();
   if (numa_node >= 0 && numa_node >= hardware_nodes && hardware_nodes > 0) {
     numa_node = numa_node % hardware_nodes;
   }
   return numa_node;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string foedus::assorted::os_error ( )

Thread-safe strerror(errno).

We might do some trick here for portability, too.

Definition at line 67 of file assorted_func.cpp.

Referenced by foedus::memory::SharedMemory::alloc(), foedus::memory::AlignedMemory::alloc(), foedus::memory::alloc_mmap(), foedus::memory::SharedMemory::attach(), foedus::fs::DirectIoFile::close(), foedus::assorted::get_current_executable_path(), foedus::memory::PagePoolPimpl::initialize_once(), foedus::soc::SocManagerPimpl::launch_forked_children(), foedus::soc::SocManagerPimpl::launch_spawned_children(), foedus::assorted::BacktraceContext::on_libbt_create_state_error(), foedus::assorted::BacktraceContext::on_libbt_full_error(), foedus::fs::DirectIoFile::open(), foedus::FixedErrorStack::output(), foedus::ErrorStack::output(), foedus::fs::DirectIoFile::read_raw(), foedus::memory::SharedMemory::release_block(), foedus::externalize::Externalizable::save_to_file(), foedus::fs::DirectIoFile::seek(), foedus::thread::ThreadPimpl::set_thread_schedule(), foedus::debugging::DebuggingSupports::start_profile(), foedus::fs::DirectIoFile::sync(), foedus::fs::DirectIoFile::truncate(), foedus::memory::PagePoolPimpl::uninitialize_once(), foedus::soc::SocManagerPimpl::wait_for_child_attach(), and foedus::fs::DirectIoFile::write_raw().

                      {
   return os_error(errno);
 }

Here is the caller graph for this function:

std::string foedus::assorted::os_error ( int error_number )

This version receives errno.

Definition at line 71 of file assorted_func.cpp.

                                      {
   if (error_number == 0) {
     return "[No Error]";
   }
   std::stringstream str;
   // NOTE(Hideaki) is std::strerror thread-safe? Thre is no std::strerror_r. Windows, mmm.
   str << "[Errno " << error_number << "] " << std::strerror(error_number);
   return str.str();
 }

void foedus::assorted::prefetch_cacheline ( const void * address )

inline

Prefetch one cacheline to L1 cache.

Parameters

[in] address memory address to prefetch.

Definition at line 49 of file cacheline.hpp.

Referenced by foedus::snapshot::MergeSort::fetch_logs(), foedus::storage::array::ArrayStoragePimpl::get_record_primitive_batch(), foedus::storage::array::ArrayStoragePimpl::lookup_for_read_batch(), foedus::storage::array::ArrayStoragePimpl::lookup_for_write_batch(), foedus::xct::XctManagerPimpl::precommit_xct_verify_page_version_set(), foedus::xct::XctManagerPimpl::precommit_xct_verify_pointer_set(), foedus::xct::XctManagerPimpl::precommit_xct_verify_readonly(), foedus::xct::XctManagerPimpl::precommit_xct_verify_readwrite(), foedus::assorted::prefetch_cachelines(), and foedus::assorted::prefetch_l2().

                                                     {
 #if defined(__GNUC__)
 #if defined(__aarch64__)
   ::__builtin_prefetch(address, 1, 3);
 #else  // defined(__aarch64__)
   ::__builtin_prefetch(address, 1, 3);
   // ::_mm_prefetch(address, ::_MM_HINT_T0);
 #endif  // defined(__aarch64__)
 #endif  // defined(__GNUC__)
 }

Here is the caller graph for this function:

void foedus::assorted::prefetch_cachelines	(	const void *	address,
		int	cacheline_count
	)

inline

Prefetch multiple contiguous cachelines to L1 cache.

Parameters

[in]	address	memory address to prefetch.
[in]	cacheline_count	count of cachelines to prefetch.

Definition at line 66 of file cacheline.hpp.

References foedus::assorted::prefetch_cacheline().

Referenced by foedus::cache::CacheHashtable::evict_main_loop(), foedus::cache::CacheHashtable::find(), foedus::cache::CacheHashtable::find_batch(), foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::prefetch(), foedus::storage::masstree::MasstreeIntermediatePage::prefetch(), foedus::storage::masstree::MasstreeBorderPage::prefetch(), foedus::storage::masstree::MasstreeBorderPage::prefetch_additional_if_needed(), and foedus::storage::masstree::MasstreePage::prefetch_general().

                                                                           {
   for (int i = 0; i < cacheline_count; ++i) {
     const void* shifted = reinterpret_cast<const char*>(address) + kCachelineSize * cacheline_count;
     prefetch_cacheline(shifted);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::assorted::prefetch_l2	(	const void *	address,
		int	cacheline_count
	)

inline

Prefetch multiple contiguous cachelines to L2/L3 cache.

Parameters

[in]	address	memory address to prefetch.
[in]	cacheline_count	count of cachelines to prefetch.

Definition at line 79 of file cacheline.hpp.

References foedus::assorted::prefetch_cacheline().

Referenced by foedus::storage::prefetch_page_l2().

                                                                   {
   for (int i = 0; i < cacheline_count; ++i) {
     const void* shifted = reinterpret_cast<const char*>(address) + kCachelineSize * cacheline_count;
     prefetch_cacheline(shifted);  // this also works for L2/L3
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

bool foedus::assorted::raw_atomic_compare_exchange_strong	(	T *	target,
		T *	expected,
		T	desired
	)

inline

Atomic CAS.

Template Parameters

T	integer type

Definition at line 49 of file raw_atomics.hpp.

                                                                                   {
   // Use newer builtin instead of __sync_val_compare_and_swap
   return ::__atomic_compare_exchange_n(
     target,
     expected,
     desired,
     false,
     __ATOMIC_SEQ_CST,
     __ATOMIC_SEQ_CST);
   // T expected_val = *expected;
   // T old_val = ::__sync_val_compare_and_swap(target, expected_val, desired);
   // if (old_val == expected_val) {
   //   return true;
   // } else {
   //   *expected = old_val;
   //   return false;
   // }
 }

bool foedus::assorted::raw_atomic_compare_exchange_strong_uint128	(	uint64_t *	ptr,
		const uint64_t *	old_value,
		const uint64_t *	new_value
	)

Atomic 128-bit CAS, which is not in the standard yet.

Parameters

[in,out]	ptr	Points to 128-bit data. MUST BE 128-bit ALIGNED.
[in]	old_value	Points to 128-bit data. If ptr holds this value, we swap. Unlike std::atomic_compare_exchange_strong, this arg is const.
[in]	new_value	Points to 128-bit data. We change the ptr to hold this value.

Returns: Whether the swap happened

We shouldn't rely on it too much as double-word CAS is not provided in older CPU. Once the C++ standard employs it, this method should go away. I will be graybeard by then, tho.

Attention: You need to give "-mcx16" to GCC to use its builtin 128bit CAS. Otherwise, __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 is not set and we have to resort to x86 assembly. Check out "gcc -dM -E - < /dev/null".

Definition at line 25 of file raw_atomics.cpp.

Referenced by foedus::storage::DualPagePointer::atomic_compare_exchange_strong(), and foedus::assorted::raw_atomic_compare_exchange_weak_uint128().

                              {
   bool ret;
 #if defined(__GNUC__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
   // gcc-x86 (-mcx16), then simply use __sync_bool_compare_and_swap.
   __uint128_t* ptr_casted = reinterpret_cast<__uint128_t*>(ptr);
   __uint128_t old_casted = *reinterpret_cast<const __uint128_t*>(old_value);
   __uint128_t new_casted = *reinterpret_cast<const __uint128_t*>(new_value);
   ret = ::__sync_bool_compare_and_swap(ptr_casted, old_casted, new_casted);
 #elif defined(__GNUC__) && defined(__aarch64__)
   // gcc-AArch64 doesn't allow -mcx16. But, it supports __atomic_compare_exchange_16 with
   // libatomic.so. We need to link to it in that case.
   __uint128_t* ptr_casted = reinterpret_cast<__uint128_t*>(ptr);
   __uint128_t old_casted = *reinterpret_cast<const __uint128_t*>(old_value);
   __uint128_t new_casted = *reinterpret_cast<const __uint128_t*>(new_value);
   ret = ::__atomic_compare_exchange_16(
     ptr_casted,
     &old_casted,
     new_casted,
     false,              // strong CAS
     __ATOMIC_ACQ_REL,   // to make it atomic, of course acq_rel
     __ATOMIC_ACQUIRE);  // matters only when it fails. acquire is enough.
 #else  // everything else
   // oh well, then resort to assembly, assuming x86. clang on ARMv8? oh please...
   // see: linux/arch/x86/include/asm/cmpxchg_64.h
   uint64_t junk;
   asm volatile("lock; cmpxchg16b %2;setz %1"
     : "=d"(junk), "=a"(ret), "+m" (*ptr)
     : "b"(new_value[0]), "c"(new_value[1]), "a"(old_value[0]), "d"(old_value[1]));
   // Note on roll-our-own non-gcc ARMv8 cas16. It's doable, but...
   // ARMv8 does have 128bit atomic instructions, called "pair" operations, such as ldaxp and stxp.
   // There is actually a library that uses it:
   // https://github.com/ivmai/libatomic_ops/blob/master/src/atomic_ops/sysdeps/gcc/aarch64.h
   // (but this is GPL. Don't open the URL unless you are ready for it.)
   // As of now (May 2014), GCC can't handle them, nor provide __uint128_t in ARMv8.
   // I think it's coming, however. I'm waiting for it... if it's not coming, let's do ourselves.
 #endif
   return ret;
 }

Here is the caller graph for this function:

template<typename T >

bool foedus::assorted::raw_atomic_compare_exchange_weak	(	T *	target,
		T *	expected,
		T	desired
	)

inline

Weak version of raw_atomic_compare_exchange_strong().

Template Parameters

T	integer type

Definition at line 74 of file raw_atomics.hpp.

                                                                                 {
   return ::__atomic_compare_exchange_n(
     target,
     expected,
     desired,
     true,  // weak
     __ATOMIC_SEQ_CST,
     __ATOMIC_SEQ_CST);
 }

bool foedus::assorted::raw_atomic_compare_exchange_weak_uint128	(	uint64_t *	ptr,
		const uint64_t *	old_value,
		const uint64_t *	new_value
	)

inline

Weak version of raw_atomic_compare_exchange_strong_uint128().

Definition at line 108 of file raw_atomics.hpp.

References foedus::assorted::raw_atomic_compare_exchange_strong_uint128().

Referenced by foedus::storage::DualPagePointer::atomic_compare_exchange_weak().

                              {
   if (ptr[0] != old_value[0] || ptr[1] != old_value[1]) {
     return false;  // this comparison is fast but not atomic, thus 'weak'
   } else {
     return raw_atomic_compare_exchange_strong_uint128(ptr, old_value, new_value);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

T foedus::assorted::raw_atomic_exchange	(	T *	target,
		T	desired
	)

inline

Atomic Swap for raw primitive types rather than std::atomic<T>.

Template Parameters

T	integer type

Parameters

[in,out]	target	Points to the data to be swapped.
[in]	desired	This value will be installed.

Returns: returns the old value.

This is a non-conditional swap, which always succeeds.

Definition at line 130 of file raw_atomics.hpp.

                                                    {
   return ::__atomic_exchange_n(target, desired, __ATOMIC_SEQ_CST);
   // Note: We must NOT use __sync_lock_test_and_set, which is only acquire-barrier for some
   // reason. We instead use GCC/Clang's __atomic_exchange() builtin.
   // return ::__sync_lock_test_and_set(target, desired);
   // see https://gcc.gnu.org/onlinedocs/gcc-4.4.3/gcc/Atomic-Builtins.html
   // and https://bugzilla.mozilla.org/show_bug.cgi?id=873799
 
   // BTW, __atomic_exchange_n/__ATOMIC_SEQ_CST demands a C++11-capable version of gcc/clang,
   // but FOEDUS anyway relies on C++11. It just allows the linked program to be
   // compiled without std=c++11. So, nothing lost.
 }

template<typename T >

T foedus::assorted::raw_atomic_fetch_add	(	T *	target,
		T	addendum
	)

inline

Atomic fetch-add for raw primitive types rather than std::atomic<T>.

Template Parameters

T	integer type

Returns: the previous value.

Definition at line 150 of file raw_atomics.hpp.

                                                      {
   return ::__atomic_fetch_add(target, addendum, __ATOMIC_SEQ_CST);
   // Just to align with above, use __atomic_fetch_add rather than __sync_fetch_and_add.
   // It's equivalent.
   // return ::__sync_fetch_and_add(target, addendum);
 }

template<typename T >

T foedus::assorted::raw_atomic_fetch_and_bitwise_and	(	T *	target,
		T	operand
	)

inline

Atomic fetch-bitwise-and for raw primitive types rather than std::atomic<T>.

Template Parameters

T	integer type

Returns: the previous value.

Definition at line 164 of file raw_atomics.hpp.

                                                                 {
   return ::__atomic_fetch_and(target, operand, __ATOMIC_SEQ_CST);
 }

template<typename T >

T foedus::assorted::raw_atomic_fetch_and_bitwise_or	(	T *	target,
		T	operand
	)

inline

Atomic fetch-bitwise-or for raw primitive types rather than std::atomic<T>.

Template Parameters

T	integer type

Returns: the previous value.

Definition at line 174 of file raw_atomics.hpp.

                                                                {
   return ::__atomic_fetch_or(target, operand, __ATOMIC_SEQ_CST);
 }

template<typename T >

T foedus::assorted::raw_atomic_fetch_and_bitwise_xor	(	T *	target,
		T	operand
	)

inline

Atomic fetch-bitwise-xor for raw primitive types rather than std::atomic<T>

Template Parameters

T	integer type

Returns: the previous value.

Definition at line 184 of file raw_atomics.hpp.

                                                                 {
   return ::__atomic_fetch_xor(target, operand, __ATOMIC_SEQ_CST);
 }

template<typename T >

T foedus::assorted::read_bigendian ( const void * be_bytes )

inline

Convert a big-endian byte array to a native integer.

Parameters

[in] be_bytes a big-endian byte array. MUST BE ALIGNED.

Returns: converted native integer

Template Parameters

T	type of native integer

Almost same as bexxtoh in endian.h except this is a single template function that supports signed integers.

Definition at line 116 of file endianness.hpp.

References ASSUME_ALIGNED, and foedus::assorted::betoh().

                                               {
   // all if clauses below will be elimiated by compiler.
   const T* be_address = reinterpret_cast<const T*>(ASSUME_ALIGNED(be_bytes, sizeof(T)));
   T be_value = *be_address;
   return betoh(be_value);
 }

Here is the call graph for this function:

std::string foedus::assorted::replace_all	(	const std::string &	target,
		const std::string &	search,
		const std::string &	replacement
	)

target.replaceAll(search, replacement).

Sad that std C++ doesn't provide such a basic stuff. regex is an overkill for this purpose.

Definition at line 45 of file assorted_func.cpp.

Referenced by foedus::log::LogOptions::convert_folder_path_pattern(), foedus::snapshot::SnapshotOptions::convert_folder_path_pattern(), foedus::proc::ProcOptions::convert_shared_library_dir_pattern(), foedus::proc::ProcOptions::convert_shared_library_path_pattern(), foedus::soc::SocOptions::convert_spawn_executable_pattern(), foedus::soc::SocOptions::convert_spawn_ld_library_path_pattern(), and foedus::assorted::replace_all().

                                              {
   std::string subject = target;
   while (true) {
     std::size_t pos = subject.find(search);
     if (pos != std::string::npos) {
       subject.replace(pos, search.size(), replacement);
     } else {
       break;
     }
   }
   return subject;
 }

Here is the caller graph for this function:

std::string foedus::assorted::replace_all	(	const std::string &	target,
		const std::string &	search,
		int	replacement
	)

target.replaceAll(search, String.valueOf(replacement)).

Definition at line 59 of file assorted_func.cpp.

References foedus::assorted::replace_all().

                                 {
   std::stringstream str;
   str << replacement;
   std::string rep = str.str();
   return replace_all(target, search, rep);
 }

Here is the call graph for this function:

void foedus::assorted::spinlock_yield ( )

Invoke _mm_pause(), x86 PAUSE instruction, or something equivalent in the env.

Invoke this where you do a spinlock. It especially helps valgrind. Probably you should invoke this after a few spins.

See also: http://stackoverflow.com/questions/7371869/minimum-time-a-thread-can-pause-in-linux "NOP instruction can be between 0.4-0.5 clocks and PAUSE instruction can consume 38-40 clocks."; SPINLOCK_WHILE(x)

Definition at line 193 of file assorted_func.cpp.

Referenced by foedus::soc::SharedCond::broadcast(), foedus::thread::ThreadPimpl::handle_tasks(), foedus::thread::ConditionVariable::notify_all(), foedus::assorted::spin_until(), foedus::soc::SharedCond::uninitialize(), foedus::soc::SocManagerPimpl::wait_for_child_attach(), foedus::soc::SocManagerPimpl::wait_for_child_terminate(), foedus::soc::SocManagerPimpl::wait_for_children_module(), foedus::soc::SocManagerPimpl::wait_for_master_module(), foedus::soc::SocManagerPimpl::wait_for_master_status(), foedus::assorted::SpinlockStat::yield_backoff(), foedus::assorted::yield_if_valgrind(), and foedus::thread::ConditionVariable::~ConditionVariable().

                       {
   // we initially used gcc's mm_pause and manual assembly, but now we use this to handle AArch64.
   // It might be no-op (not guaranteed to yield, according to the C++ specifictation)
   // depending on GCC's implementation, but portability is more important.
   std::this_thread::yield();
   // #if defined(__GNUC__)
   //   ::_mm_pause();
   // #else  // defined(__GNUC__)
   //   // Non-gcc compiler.
   //   asm volatile("pause" ::: "memory");
   // #endif  // defined(__GNUC__)
 }

Here is the caller graph for this function:

template<uint64_t SIZE1, uint64_t SIZE2>

int foedus::assorted::static_size_check ( )

inline

Alternative for static_assert(sizeof(foo) == sizeof(bar), "oh crap") to display sizeof(foo).

Use it like this:

STATIC_SIZE_CHECK(sizeof(foo), sizeof(bar))

Definition at line 195 of file assorted_func.hpp.

References CXX11_STATIC_ASSERT.

                                {
   CXX11_STATIC_ASSERT(SIZE1 == SIZE2,
     "Static Size Check failed. Look for a message like this to see the value of Size1 and "
     "Size2: 'In instantiation of int foedus::assorted::static_size_check() [with long unsigned"
     " int SIZE1 = <size1>ul; long unsigned int SIZE2 = <size2>ul]'");
   return 0;
 }

template<typename T >

void foedus::assorted::write_bigendian	(	T	host_value,
		void *	be_bytes
	)

inline

Convert a native integer to big-endian bytes and write them to the given address.

Parameters

[in]	host_value	a native integer.
[out]	be_bytes	address to write out big endian bytes. MUST BE ALIGNED.

Template Parameters

T	type of native integer

Definition at line 131 of file endianness.hpp.

References ASSUME_ALIGNED.

                                                           {
   T* be_address = reinterpret_cast<T*>(ASSUME_ALIGNED(be_bytes, sizeof(T)));
   *be_address = htobe<T>(host_value);
 }

Variable Documentation

const uint16_t foedus::assorted::kCachelineSize = 64

Byte count of one cache line.

Several places use this to avoid false sharing of cache lines, for example separating two variables that are frequently accessed with atomic requirements.

Todo:: This should be automatically detected by cmakedefine.

Definition at line 42 of file cacheline.hpp.

Referenced by foedus::cache::CacheHashtable::evict_main_loop(), foedus::storage::masstree::MasstreeBorderPage::prefetch_additional_if_needed(), and foedus::storage::prefetch_page_l2().

const bool foedus::assorted::kIsLittleEndian = false

A handy const boolean to tell if it's little endina.

Most compilers would resolve "if (kIsLittleEndian) ..." at compile time, so no overhead. Compared to writing ifdef each time, this is handier. However, there are a few cases where we have to write ifdef (class definition etc).

Definition at line 54 of file endianness.hpp.

Detailed Description

Files

Classes

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation