everett::redundant_runtime< P, Compose, Storage > Struct Template Reference

#include <redundant_runtime.h>

Classes
struct	execution
struct	worker

Public Types
using	policy_type = P
using	storage_type = Storage
using	node_type = redundant_node< P, Storage >
using	native_type = typename node_type::native_type
using	native_pointer = typename node_type::native_pointer
using	pair_type = typename node_type::pair_type
using	snapshot_type = redundant_snapshot< P, Storage >
using	query_type = typename snapshot_type::query_type
using	object_type = redundant_object< P, Storage >
using	object_pointer = std::shared_ptr< object_type const >
using	routes = redundant_routes< P, Storage >
using	level_type = redundant_level< P, Storage >

Public Member Functions
	redundant_runtime (Compose compose={})
	redundant_runtime (Storage storage, Compose compose={})
Storage const &	storage () const &
Storage const &	storage () const &&=delete
	redundant_runtime (redundant_runtime const &)=delete
redundant_runtime &	operator= (redundant_runtime const &)=delete
	redundant_runtime (redundant_runtime &&) noexcept=default
redundant_runtime &	operator= (redundant_runtime &&) noexcept=default
snapshot_type	snapshot () const
redundant_work	work () const
std::uint64_t	service_due () const
snapshot_type	checkpoint ()
bool	pending () const noexcept
bool	failed () const noexcept
void	poison () noexcept
bool	admission_ready () const noexcept
bool	recovering () const noexcept
std::uint64_t	credit () const
std::uint64_t	next_service_cost () const
std::uint64_t	admission_cost () const
bool	try_initialize_sorted (std::span< profile_record const > records, std::uint64_t allowance, std::uint64_t depth_limit)
snapshot_type	advance (std::uint64_t budget)
std::optional< snapshot_type >	try_contribute (profile_record const &record, std::uint64_t budget=0)
snapshot_type	contribute (profile_record const &record)

Static Public Member Functions
static std::uint64_t	service_budget (std::uint64_t admissions)
static redundant_runtime	from_snapshot (snapshot_type source, Compose compose={})
static redundant_runtime	from_snapshot (snapshot_type source, Storage storage, Compose compose={})

Static Public Attributes
static constexpr unsigned	maximum_levels = 64
static constexpr std::uint64_t	local_charge_bound = 32 * (P::group_size + 6) + 2048

Private Types
enum class	action {   native_start , native_step , native_finish , index_start ,   index_step , index_finish , commit }
enum class	category {   native , index , carrier , metadata ,   root }
using	merge_compose = std::conditional_t< std::is_same_v< Compose, replace_native_value >, Compose, std::reference_wrapper< Compose > >
using	merge_type = typename Storage::template merge_type< merge_compose >
using	index_type = typename Storage::template index_type< node_type >

Private Member Functions
	redundant_runtime (std::unique_ptr< execution > value)
execution const &	active () const
execution &	writable ()

Static Private Member Functions
static std::uint64_t	add (std::uint64_t a, std::uint64_t b)
static std::uint64_t	ceil (std::uint64_t n, std::uint64_t d)
static void	require (bool value, char const *message)
static void	validate (profile_record const &record)

Private Attributes
std::unique_ptr< execution >	e_

Member Typedef Documentation

index_type

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::index_type = typename Storage::template index_type<node_type>

private

level_type

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::level_type = redundant_level<P, Storage>

merge_compose

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::merge_compose = std::conditional_t<std::is_same_v<Compose, replace_native_value>, Compose, std::reference_wrapper<Compose> >

private

merge_type

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::merge_type = typename Storage::template merge_type<merge_compose>

private

native_pointer

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::native_pointer = typename node_type::native_pointer

native_type

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::native_type = typename node_type::native_type

node_type

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::node_type = redundant_node<P, Storage>

object_pointer

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::object_pointer = std::shared_ptr<object_type const>

object_type

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::object_type = redundant_object<P, Storage>

pair_type

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::pair_type = typename node_type::pair_type

policy_type

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::policy_type = P

query_type

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::query_type = typename snapshot_type::query_type

routes

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::routes = redundant_routes<P, Storage>

snapshot_type

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::snapshot_type = redundant_snapshot<P, Storage>

storage_type

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

using everett::redundant_runtime< P, Compose, Storage >::storage_type = Storage

Member Enumeration Documentation

action

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

enum class everett::redundant_runtime::action

strongprivate

Enumerator
native_start
native_step
native_finish
index_start
index_step
index_finish
commit

category

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

enum class everett::redundant_runtime::category

strongprivate

Enumerator
native
index
carrier
metadata
root

Constructor & Destructor Documentation

redundant_runtime() [1/5]

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

everett::redundant_runtime< P, Compose, Storage >::redundant_runtime ( Compose  compose = {} )

inlineexplicit

redundant_runtime() [2/5]

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

everett::redundant_runtime< P, Compose, Storage >::redundant_runtime ( Storage  storage, Compose  compose = {}  )

inline

redundant_runtime() [3/5]

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

everett::redundant_runtime< P, Compose, Storage >::redundant_runtime ( redundant_runtime< P, Compose, Storage > const &  )

delete

redundant_runtime() [4/5]

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

everett::redundant_runtime< P, Compose, Storage >::redundant_runtime ( redundant_runtime< P, Compose, Storage > &&  )

defaultnoexcept

redundant_runtime() [5/5]

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

everett::redundant_runtime< P, Compose, Storage >::redundant_runtime ( std::unique_ptr< execution >  value )

inlineexplicitprivate

Member Function Documentation

active()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

execution const & everett::redundant_runtime< P, Compose, Storage >::active ( ) const

inlineprivate

add()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

static std::uint64_t everett::redundant_runtime< P, Compose, Storage >::add ( std::uint64_t  a, std::uint64_t  b  )

inlinestaticprivate

admission_cost()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

std::uint64_t everett::redundant_runtime< P, Compose, Storage >::admission_cost ( ) const

inline

admission_ready()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

bool everett::redundant_runtime< P, Compose, Storage >::admission_ready ( ) const

inlinenoexcept

advance()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

snapshot_type everett::redundant_runtime< P, Compose, Storage >::advance ( std::uint64_t  budget )

inline

ceil()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

static std::uint64_t everett::redundant_runtime< P, Compose, Storage >::ceil ( std::uint64_t  n, std::uint64_t  d  )

inlinestaticprivate

checkpoint()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

snapshot_type everett::redundant_runtime< P, Compose, Storage >::checkpoint ( )

inline

contribute()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

snapshot_type everett::redundant_runtime< P, Compose, Storage >::contribute ( profile_record const &  record )

inline

credit()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

std::uint64_t everett::redundant_runtime< P, Compose, Storage >::credit ( ) const

inline

failed()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

bool everett::redundant_runtime< P, Compose, Storage >::failed ( ) const

inlinenoexcept

from_snapshot() [1/2]

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

static redundant_runtime everett::redundant_runtime< P, Compose, Storage >::from_snapshot ( snapshot_type  source, Compose  compose = {}  )

inlinestatic

from_snapshot() [2/2]

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

static redundant_runtime everett::redundant_runtime< P, Compose, Storage >::from_snapshot ( snapshot_type  source, Storage  storage, Compose  compose = {}  )

inlinestatic

next_service_cost()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

std::uint64_t everett::redundant_runtime< P, Compose, Storage >::next_service_cost ( ) const

inline

operator=() [1/2]

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

redundant_runtime & everett::redundant_runtime< P, Compose, Storage >::operator= ( redundant_runtime< P, Compose, Storage > &&  )

defaultnoexcept

operator=() [2/2]

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

redundant_runtime & everett::redundant_runtime< P, Compose, Storage >::operator= ( redundant_runtime< P, Compose, Storage > const &  )

delete

pending()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

bool everett::redundant_runtime< P, Compose, Storage >::pending ( ) const

inlinenoexcept

poison()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

void everett::redundant_runtime< P, Compose, Storage >::poison ( )

inlinenoexcept

recovering()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

bool everett::redundant_runtime< P, Compose, Storage >::recovering ( ) const

inlinenoexcept

require()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

static void everett::redundant_runtime< P, Compose, Storage >::require ( bool  value, char const *  message  )

inlinestaticprivate

service_budget()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

static std::uint64_t everett::redundant_runtime< P, Compose, Storage >::service_budget ( std::uint64_t  admissions )

inlinestatic

service_due()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

std::uint64_t everett::redundant_runtime< P, Compose, Storage >::service_due ( ) const

inline

snapshot()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

snapshot_type everett::redundant_runtime< P, Compose, Storage >::snapshot ( ) const

inline

storage() [1/2]

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

Storage const & everett::redundant_runtime< P, Compose, Storage >::storage ( ) const &

inline

storage() [2/2]

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

Storage const & everett::redundant_runtime< P, Compose, Storage >::storage ( ) const &&

delete

try_contribute()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

std::optional< snapshot_type > everett::redundant_runtime< P, Compose, Storage >::try_contribute ( profile_record const &  record, std::uint64_t  budget = 0  )

inline

try_initialize_sorted()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

bool everett::redundant_runtime< P, Compose, Storage >::try_initialize_sorted ( std::span< profile_record const >  records, std::uint64_t  allowance, std::uint64_t  depth_limit  )

inline

validate()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

static void everett::redundant_runtime< P, Compose, Storage >::validate ( profile_record const &  record )

inlinestaticprivate

work()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

redundant_work everett::redundant_runtime< P, Compose, Storage >::work ( ) const

inline

writable()

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

execution & everett::redundant_runtime< P, Compose, Storage >::writable ( )

inlineprivate

Member Data Documentation

e_

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

std::unique_ptr<execution> everett::redundant_runtime< P, Compose, Storage >::e_

private

local_charge_bound

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

constexpr std::uint64_t everett::redundant_runtime< P, Compose, Storage >::local_charge_bound = 32 * (P::group_size + 6) + 2048

staticconstexpr

maximum_levels

template<class P , class Compose = replace_native_value, class Storage = profile_runtime_storage<P>>

constexpr unsigned everett::redundant_runtime< P, Compose, Storage >::maximum_levels = 64

staticconstexpr

---

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

• include/everett/redundant_runtime.h