vt::runtime::component namespace

Namespaces

namespace detail
namespace meter
namespace registry

Classes

struct BaseComponent
The abstract BaseComponent for VT runtime component pack.
struct Bufferable
The abstract Bufferable trait for delaying operations generically across VT components.
template<typename T>
struct Component
Component class for a generic VT runtime module, CRTP'ed over the component's actual type
template<typename T, typename _Enable = void, typename... Us>
struct ComponentConstructor
Construct a component with either a regular std::make_unique or through the specialized static construct method, which is used to create the objgroup if the component is implemented as one.
template<typename T, typename... Us>
struct ComponentConstructor<T, typename std::enable_if_t<ComponentTraits<T, Us...>::hasConstruct>, Us...>
template<typename T, typename... Us>
struct ComponentConstructor<T, typename std::enable_if_t<not ComponentTraits<T, Us...>::hasConstruct>, Us...>
struct ComponentName
Pure virtual class for concrete components to override, providing an unique name for the given component.
struct ComponentPack
ComponentPack class for holding a set of runtime components that make up a coherent inter-dependent runtime
struct ComponentReducer
Trait class for the component that composes in the unique reducer for each component.
struct ComponentRegistry
template<typename T, typename... Us>
struct ComponentTraits
struct Diagnostic
The abstract Diagnostic trait for outputting debugging state information generically across VT components.
struct DiagnosticErasedValue
Typed-erased, diagnostic values as strings for outputting to user after being formatted.
struct MovableFn
A move-only closure around a general function. This type is not user-constructible; serves as a general base class for move-only callables.
template<typename Fn>
struct MovableFnTyped
A typed move-only function closed around a lambda that can't be copied.
template<typename T>
struct PollableComponent
Component class for a generic, pollable VT runtime module, CRTP'ed over the component's actual type. A pollable component will be registered with the VT scheduler to ensure it makes progress.
struct Progressable
The abstract Progressable trait for pollable components to make progress from the scheduler.

Enums

enum class DiagnosticTypeEnum: int8_t { PerformanceDiagnostic, DebugDiagnostic }
The type of diagnostic (the category)
enum class DiagnosticUpdate: int8_t { Sum, Avg, Replace, Min, Max }
enum class DiagnosticUnit: int8_t { Bytes, Units, UnitsPerSecond, Seconds }
Unit type for a diagnostic value.
enum class UnitMultiplier: int8_t { Base = 0, Thousands = 1, Millions = 2, Billions = 3, Trillions = 4, Quadrillions = 5, Quintillions = 6 }
Multipliers for basic units.
enum class TimeMultiplier: int8_t { Seconds = 0, Milliseconds = -1, Microseconds = -2, Nanoseconds = -3 }
Time multipliers for DiagnosticUnit::Seconds.

Typedefs

template<typename... Ts>
using StartupDeps = typename BaseComponent::StartupDepsPack<Ts...>
Type alias for a pack of startup dependencies.
template<typename... Ts>
using RuntimeDeps = typename BaseComponent::RuntimeDepsPack<Ts...>
Type alias for a pack of runtime dependencies, automatically including all startup dependencies.

Functions

auto diagnosticUpdateTypeString(DiagnosticUpdate update) -> std::string
Convert a diagnostic update enum to a human-readable string.
auto diagnosticShowTotal(DiagnosticUpdate update) -> bool
Whether to print the total (or sum across processors) of a given type of update.
auto diagnosticUnitTypeString(DiagnosticUnit unit) -> std::string
Convert a diagnostic unit type to a human-readable string.
auto diagnosticMultiplierString(UnitMultiplier multiplier) -> std::string
Convert a diagnostic unit multiplier to a human-readable string.
auto diagnosticTimeMultiplierString(TimeMultiplier time) -> std::string
Convert a time unit multiplier to a human-readable string.

Enum documentation

enum class vt::runtime::component::DiagnosticTypeEnum: int8_t
#include <src/vt/runtime/component/diagnostic_types.h>

The type of diagnostic (the category)

Enumerators
PerformanceDiagnostic

A performance diagnostic
DebugDiagnostic

A debugging diagnostic

enum class vt::runtime::component::DiagnosticUpdate: int8_t
#include <src/vt/runtime/component/diagnostic_types.h>

Enumerators
Sum

Sum diagnostic values during update
Avg

Avg diagnostic values during update
Replace

Replace diagnostic value during update
Min

Min diagnostic value during update
Max

Max diagnostic value during update

enum class vt::runtime::component::DiagnosticUnit: int8_t
#include <src/vt/runtime/component/diagnostic_units.h>

Unit type for a diagnostic value.

Enumerators
Bytes

Memory units as bytes
Units

Units of some entity
UnitsPerSecond

Units per second
Seconds

Time units as seconds

enum class vt::runtime::component::UnitMultiplier: int8_t
#include <src/vt/runtime/component/diagnostic_units.h>

Multipliers for basic units.

Enumerators
Base

Multiplier = 1
Thousands

Multiplier = 1,000
Millions

Multiplier = 1,000,000
Billions

Multiplier = 1,000,000,000
Trillions

Multiplier = 1,000,000,000,000
Quadrillions

Multiplier = 1,000,000,000,000,000
Quintillions

Multiplier = 1,000,000,000,000,000,000

enum class vt::runtime::component::TimeMultiplier: int8_t
#include <src/vt/runtime/component/diagnostic_units.h>

Time multipliers for DiagnosticUnit::Seconds.

Enumerators
Seconds

Multiplier = 1
Milliseconds

Multiplier = 0.001
Microseconds

Multiplier = 0.000001
Nanoseconds

Multiplier = 0.000000001

Typedef documentation

#include <src/vt/runtime/component/component_pack.h>
template<typename... Ts>
using vt::runtime::component::StartupDeps = typename BaseComponent::StartupDepsPack<Ts...>

Type alias for a pack of startup dependencies.

#include <src/vt/runtime/component/component_pack.h>
template<typename... Ts>
using vt::runtime::component::RuntimeDeps = typename BaseComponent::RuntimeDepsPack<Ts...>

Type alias for a pack of runtime dependencies, automatically including all startup dependencies.

Function documentation

std::string vt::runtime::component::diagnosticUpdateTypeString(DiagnosticUpdate update)
#include <src/vt/runtime/component/diagnostic_enum_format.h>

Convert a diagnostic update enum to a human-readable string.

Parameters
update in the update type
Returns a string for printing

bool vt::runtime::component::diagnosticShowTotal(DiagnosticUpdate update)
#include <src/vt/runtime/component/diagnostic_enum_format.h>

Whether to print the total (or sum across processors) of a given type of update.

Parameters
update in the update type
Returns whether to print the total

\internalFor example, a DiagnosticUpdate::Max value updater does not make sense to print the total across nodes.

std::string vt::runtime::component::diagnosticUnitTypeString(DiagnosticUnit unit)
#include <src/vt/runtime/component/diagnostic_enum_format.h>

Convert a diagnostic unit type to a human-readable string.

Parameters
unit in the unit
Returns a string for printing

std::string vt::runtime::component::diagnosticMultiplierString(UnitMultiplier multiplier)
#include <src/vt/runtime/component/diagnostic_enum_format.h>

Convert a diagnostic unit multiplier to a human-readable string.

Parameters
multiplier in the multiplier type
Returns a string for printing

std::string vt::runtime::component::diagnosticTimeMultiplierString(TimeMultiplier time)
#include <src/vt/runtime/component/diagnostic_enum_format.h>

Convert a time unit multiplier to a human-readable string.

Parameters
time in the time unit
Returns a string for printing