sbio

Classes

Name	Description
`BatchedSequential`	Read a long batch of bytes. This only requires provided an offset and number of bytes.
`BatchHandle`	A batch of steps handed out by a zipped iteration, whose data has already been fetched.
`BrokerGroup`	The logical grouping of StreamBrokers which should be queried together.
`Composed`	An Execution policy allowing composition of a DistributionManager and MemoryManager.
`Context`	The Context constructs DataSources from IO and Execution policies within an environment.
`CudaMemory`	CudaExecution is a policy for a single process to use one GPU.
`DataSource`	The highest-level abstraction for defining the set of StreamBrokers that will be used.
`Execution`	The Execution policy is the central point for the management of IO activity.
`IAccessStyle`
`MemPool`
`MPIDistribution`	A basic shared MPI execution policy.
`MPIThreadedDistribution`	The MPIThreadedExecution policy is designed for a hybrid MPI/threaded approach.
`RandomAccess`
`SerialDistribution`	SerialDistribution is a simple distribution using a single process and thread.
`SourceSet`	—SourceSet Implementations (Zipping multiple DataSources) —///
`StepHandle`	A step handed out by a zipped iteration, whose data has already been fetched.
`StorageView`
`Stream`	A light-weight wrapper over an IO engine.
`StreamBroker`	A StreamBroker organizes Streams and mediates data requests.
`ThreadedDistribution`	ThreadedExecution manages a single-process/multi-thread IO strategy.
`Transaction`
`UnitSequential`	Read a single unit. This will check a header and payload for you.
`ZippedBatchRange`	Iterate contiguous step batches of a DataSource with fetches over a set of BrokerGroups.
`ZippedGroupRange`	Iterate the steps of a DataSource with fetches over a set of BrokerGroups.
`AllocationRequest`
`BaseTraits`	Base class tag for a data-format implementation.
`BufferDescriptor`
`BufferMember`
`ByteRegion`
`CompositeDataResult`	An organized result returned from a BrokerGroup managing one or more brokers.
`CudaDeviceBuffer`
`CudaMirroredBuffer`	A GPU device buffer with a pinner replica on the host.
`CudaPinnedBuffer`
`cuFileIO`	A IO protocol using cuFile APIs in conjunction with POSIX descriptors.
`CustomLambdaLocator`
`CustomLambdaLocatorTraits`
`CustomLambdaLocatorTraits< RandomTraits >`
`DataRequest`
`DataRequest< NamedKeys< Keys... > >`	Container used to specify retrieval of a specific piece of data.
`DataResult`	A result returned from a request to a single StreamBroker.
`DeviceBound`
`DoubleBuffered`
`ExecutionPolicyConfigured`	A tag indicating the EPolicy was configured prior to DataSource construction.
`ExtractDescriptorsList`
`ExtractDescriptorsList< Storage< List, Policy > >`
`FindDescriptor`
`FindDescriptor< Role, Id, RequirementsList< Head, Tail... > >`
`FindDescriptor< Role, Id, RequirementsList<> >`
`FixedName`
`GenericStreamConfig`
`GetHint`
`GetHint< BufferDescriptor< Role, Id, MinSize, Hint > >`
`GroupTopology`	The layout, post any sorting, of all segment references in a BrokerGroup.
`HostBuffer`
`HostMemory`	A very simple MemoryManager which places all buffers in pageable host memory.
`IndexingCursor`
`IOPolicy`
`is_stream_set`
`is_stream_set< StreamSet< SVs... > >`
`IsDescriptor`
`IsDescriptor< BufferDescriptor< Role, Id, Size, H > >`
`LocatorParametersFor`
`LocatorParametersFor< CustomLambdaLocator, RandomTraits >`
`LocatorParametersFor< PathPatternLocator, XTC2Traits >`
`LocatorParametersFor< SingleFileLocator, XTC2Traits >`
`MetadataInventory`	The MetadataInventory provides a lookup of a StreamBroker’s fields.
`MPISharedBuffer`	A buffer implementation backed by an MPI Shared Window.
`MPIWinAllocator`	A custom Allocator for an RC managed MPI_Win.
`MPIWinDeleter`	A custom Deleter for an RC managed MPI_Win.
`NamedArg`	A mechanism to attach a name/keyword to an argument.
`NamedKeys`	A wrapping container for a set of named keys.
`NamedMember`	A small wrapper to attach a name to a member attribute.
`PathPatternLocator`
`PathPatternLocatorTraits`
`PathPatternLocatorTraits< XTC2Traits >`
`PayloadOffsetCache`	A cache of field offsets within fetched DataUnits.
`PerUnitBuffer`	A buffer with one instance per parallel unit (`[BufferScope::PerUnit](#namespacesbio_1a3ceb0599575063c416cdcfc24c8fdc87a699a2f0f0b31a281375f40580dac7810)`).
`RandomTraits`
`RC`	A simple reference counted container for an object.
`ReadResult`
`RequirementsList`
`SegmentCursor`	The cursor into a data Stream corresponding to a single segment of a BrokerGroup.
`SegmentRef`	Map a StreamBroker to a logical position within a BrokerGroup.
`Shareable`
`SingleFileLocator`
`SingleFileLocatorTraits`
`SingleFileLocatorTraits< XTC2Traits >`
`StepBatch`	A contiguous batch of steps: [first, last).
`StepOffset`
`Storage`
`Storage< RequirementsList< Roles... >, Policy >`
`StreamCatalog`
`StreamIdentity`	Identifiers for positioning within the topology of StreamBrokers.
`StreamResource`
`StreamSet`
`StreamVariant`
`SyncGroup`	The SyncGroup specifies a series of references that may require synchronization. This can be exposed by any data stream broker, allowing an execution policy to to generically use appropriate synchronization mechanisms without apriori knowledge of the number, or type.
`SyncGroup< T, Rest... >`
`SyncGroup<>`
`SyncPOSIXIO`	A very basic IO implementation over standard synchronous POSIX APIs.
`ThreadLocalBuffer`
`type_list`
`use_rc_alloc_del_t`	A small struct for tag dispatching a custom-allocator/deleter RC creation function.
`use_rc_alloc_t`	A small struct for tag dispatching a custom-allocator RC creation function.
`use_rc_del_t`	A small struct for tag dispatching a custom-deleter RC creation function.
`XTC1Traits`
`XTC2Traits`

Enumerations

Name	Description
`AccessType`
`BrokerState`	The indicators of the StreamBroker state machine.
`ParallelizationMethods`	The set of parallelization methods that may be supported by Execution policies.
`IOStatus`
`IOCapability`	Feature and capability flags for what an IO policy can do.
`MemorySpace`	The MemorySpace an individual buffer lives in.
`BufferScope`	Indicator of who shares/accesses a buffer.
`AcquireIntent`	Operating through StorageView’s acquisition model, specify MemorySpace to use.
`StreamResourceType`
`StepMapping`	Indicate how a step index should map onto a SegmentRef’s actual steps.
`StreamPartitioningStrategy`	Indicates the strategy used to partition data across streams.
`StreamSentinels`

AccessType

enum AccessType

Defined in src/lib/sbio/core/access_style.hh:37

Value	Description
`NoOp`
`UnitSequential`
`BatchedSequential`
`RandomAccess`

BrokerState

enum BrokerState

Defined in src/lib/sbio/core/broker.hh:111

The indicators of the StreamBroker state machine.

As data is read from the Stream(s) the Broker will transition through these various states depending on the exact actions that are being undertaken.

The Execution policy can also move the Broker through states, or make decisions, i.e., be held up, or advanced, based on the state.

Not all data formats require the same things, so the exact actions performed by the Broker in each state will change. E.g., “INDEXING” may not always make sense for all data formats (some may not be indexable).

Value	Description
`INIT`	Initialization of any non-stream setup the Broker must do.
`ALLOCATE`	Allocation of memory required by the data format to read properly.
`CONNECT`	Connection/opening of the Streams managed by the Broker.
`DISCOVERY`	Determines the contents of the Stream.
`READY`	Ready to begin reading/brokering/transmitting streamed data.
`INDEXING`	Indexing the data stream (if meaningful).
`STREAMING`	In the process of fetching/transmitting streamed data.
`ERROR`	An error state has been encountered and should be investigated.
`DONE`	The Stream is exhausted and has been closed.

ParallelizationMethods

enum ParallelizationMethods

Defined in src/lib/sbio/core/execution.hh:46

The set of parallelization methods that may be supported by Execution policies.

A given policy may support one or more of the following parallelization strategies.

Value	Description
`THREADS`	Support for multi-threaded programs.
`MPI`	Support for MPI programs.
`CUDA`	Support for single GPU-coprocessor with CUDA.
`CUDA_MULTIGPU`	Support for multiple GPUs (per process) with CUDA.
`CUDA_FROMDEV`	Support for being invoked from inside CUDA device code.
`NUM_METHODS`

IOStatus

enum IOStatus

Defined in src/lib/sbio/core/io.hh:59

Value	Description
`Success`
`Pending`
`WouldBlock`
`OpenFailed`
`GeneralIOError`
`ZeroBytesRead`
`TruncatedRead`
`FunctionUnavailable`
`NoOffsetInData`
`HeaderReadError`
`PayloadTruncatedError`
`AllRequestedRead`
`BufferConflict`

IOCapability

enum IOCapability

Defined in src/lib/sbio/core/io.hh:110

Feature and capability flags for what an IO policy can do.

IO implementations are composed (via template) with various Execution policies completely freely; however, not all IOPolicy implementations have the same capabilities. The IOPolicy, therefore, states the capabilities it provides/supports using feature flags that can be queried at compile time.

Value	Description
`None`
`ReadToHost`	Can read into (pageable) host memory.
`ReadToPinned`	Can read into pinned (page-locked) host memory.
`ReadToDevice`	Can read into device (GPU) memory.
`ConcurrentReads`	One Stream can be read by multiple threads at once.
`DeviceCallable`	`read` APIs can be called directly from device (GPU) code

MemorySpace

enum MemorySpace

Defined in src/lib/sbio/core/storage.hh:79

The MemorySpace an individual buffer lives in.

Each buffer satisfying ValidBuffer (below) indicates the memory space that it resides in. This allows querying, and making decisions if/when memory may need to be copied or moved into different spaces.

Value	Description
`Host`	Resides in host memory.
`Pinned`
`Device`	Resides in device (GPU) memory.
`Managed`

BufferScope

enum BufferScope

Defined in src/lib/sbio/core/storage.hh:97

Indicator of who shares/accesses a buffer.

For each buffer role, the scope is decided by the execution polic. It can be determined by the “distribution side” independently of where that memory actually resides. E.g. a buffer with GPU-memory can be shared just like one that is based on host-memory.

Value	Description
`Shared`	One buffer instance for the Storage instance.
`PerUnit`	One buffer instance for each parallel unit.
`NodeShared`	One buffer instance for an entire server/node (e.g. MPI Window)

AcquireIntent

enum AcquireIntent

Defined in src/lib/sbio/core/storage.hh:116

Operating through StorageView’s acquisition model, specify MemorySpace to use.

A caller can specify a view of a buffer must be returned in the caller’s native memory space (GPU/CPU etc), or alternatively, that it can be left in the buffer’s native space. The latter option may at first seem not so useful (why would a caller request access to a buffer it cannot read?) - however, callers in the sbio infrastructure are often orchestrating other components. They can specify acquisition, initiating a transaction, and proceed to direct how the buffer be filled/read elsewhere, without actually reading it themselves. This allows for major performance improvements where the alternative would require copies back and forth between CPU and GPU memory (as an example).

Value	Description
`CallerMemorySpace`	On acquire, view should be in the caller’s space.
`BufferMemorySpace`	On acquire, view can be left in the buffer’s space.

StreamResourceType

enum StreamResourceType

Defined in src/lib/sbio/core/stream.hh:47

Value	Description
`Path`
`FileDescriptor`
`WindowsHandle`
`MemoryRegion`
`NetworkEndpoint`

StepMapping

enum StepMapping

Defined in src/lib/sbio/core/topology.hh:112

Indicate how a step index should map onto a SegmentRef’s actual steps.

By default, all step indices will be traversed directly regardless of if some kinds of steps are more or less frequent. Alternatively, the BrokerGroup and GroupTopology can be set to align steps to a specific kind. E.g., to ensure that a low-frequency step kind is retrieved in alignment with a high-frequency one.

Value	Description
`PerKind`	The BrokerGroup’s step n is the SegmentRef’s step n.
`AlignTo`	The BrokerGroup’s step n is the SegmentRef’s latest step at or before step n of `align_ptn`

StreamPartitioningStrategy

enum StreamPartitioningStrategy

Defined in src/lib/sbio/core/types.hh:59

Indicates the strategy used to partition data across streams.

When partitioning data from a single “logical unit” across multiple data streams written over time, one can imagine two basic strategies:

At each point in time, the logical unit is sub-divided and a portion is written to each data stream.
At each point in time, the entire logical unit is written to one stream, and then the data is round-robined (or via some other selection mechanism distributed) across the other streams.

SubDivide indicates the format uses strategy 1.

Chronological indicates the format uses strategy 2.

Value	Description
`SubDivide`	A single logical unit is sub-divided into multiple streams.
`Chronological`	A complete logical unit is written to one stream at a time.

StreamSentinels

enum StreamSentinels

Defined in src/lib/sbio/core/types.hh:64

Value	Description
`RequestExhausted`	All data units from this read request were read.
`StreamExhausted`	The stream is entirely exhausted (no more data)

Typedefs

Return	Name	Description
typename `LocatorParametersFor`< Locator, FTraits >::Type	`LocatorParameters_t`
typename `impl::index_state_for`< FTraits >::type	`IndexStateFor`
typename `ExtractDescriptorsList`< T >::type	`ExtractDescriptorsListT`
`ncarray::HostTag`	`ViewMemTag`	Indicator for the MemorySpace that the StorageView looks at.
`Composed`< `SerialDistribution`, `CudaMemory` >	`CudaExecution`
`Composed`< `ThreadedDistribution`, `CudaMemory` >	`ThreadedCudaExecution`
`Composed`< `MPIDistribution`, `HostMemory` >	`MPIExecution`	An MPI-based execution policy using host-memory management.
`Composed`< `MPIDistribution`, `CudaMemory` >	`MPICudaExecution`	Run MPI-based distribution with GPU support.
`Composed`< `MPIThreadedDistribution`, `CudaMemory` >	`MPIThreadedCudaExecution`	Run hybrid MPI/threads-based distribution with GPU support.
`Composed`< `MPIThreadedDistribution`, `HostMemory` >	`MPIThreadedExecution`	A hybrid thread/MPI execution policy using host-memory management.
`Composed`< `SerialDistribution`, `HostMemory` >	`SerialExecution`	A serial execution policy using host-memory management.
`Composed`< `ThreadedDistribution`, `HostMemory` >	`ThreadedExecution`	A thread-based execution policy using host-memory management.

LocatorParameters_t

using LocatorParameters_t = typename LocatorParametersFor< Locator, FTraits >::Type

Type: typename LocatorParametersFor< Locator, FTraits >::Type

Defined in src/lib/sbio/core/locator.hh:64

IndexStateFor

using IndexStateFor = typename impl::index_state_for< FTraits >::type

Type: typename impl::index_state_for< FTraits >::type

Defined in src/lib/sbio/core/state_handle.hh:130

ExtractDescriptorsListT

using ExtractDescriptorsListT = typename ExtractDescriptorsList< T >::type

Type: typename ExtractDescriptorsList< T >::type

Defined in src/lib/sbio/core/storage.hh:299

ViewMemTag

using ViewMemTag = ncarray::HostTag

Defined in src/lib/sbio/core/storage_view.hh:64

Indicator for the MemorySpace that the StorageView looks at.

If compiled as device code, set to DevTag. Using this tag allows the caller to specify its memory space for operations where that is needed.

CudaExecution

using CudaExecution = Composed< SerialDistribution, CudaMemory >

Type: Composed< SerialDistribution, CudaMemory >

Defined in src/lib/sbio/execution/cuda.hh:575

ThreadedCudaExecution

using ThreadedCudaExecution = Composed< ThreadedDistribution, CudaMemory >

Type: Composed< ThreadedDistribution, CudaMemory >

Defined in src/lib/sbio/execution/cuda.hh:577

MPIExecution

using MPIExecution = Composed< MPIDistribution, HostMemory >

Type: Composed< MPIDistribution, HostMemory >

Defined in src/lib/sbio/execution/mpi.hh:838

An MPI-based execution policy using host-memory management.

MPICudaExecution

using MPICudaExecution = Composed< MPIDistribution, CudaMemory >

Type: Composed< MPIDistribution, CudaMemory >

Defined in src/lib/sbio/execution/mpi_cuda.hh:36

Run MPI-based distribution with GPU support.

The Data buffers for a rank live on the device. If Config::devices has been used (as opposed to just device), the ranks for a node are spread out between the selected GPUs. Index role buffers stay host-side.

MPIThreadedCudaExecution

using MPIThreadedCudaExecution = Composed< MPIThreadedDistribution, CudaMemory >

Type: Composed< MPIThreadedDistribution, CudaMemory >

Defined in src/lib/sbio/execution/mpi_cuda.hh:46

Run hybrid MPI/threads-based distribution with GPU support.

The Data buffers for a rank live on the device. If Config::devices has been used (as opposed to just device), the ranks for a node are spread out between the selected GPUs. Selection is done rank-first then threads - for more details refer to the implmentation of [MPIThreadedDistribution::unit_ordinal](api-sbio-MPIThreadedDistribution.md#unit_ordinal-1).

MPIThreadedExecution

using MPIThreadedExecution = Composed< MPIThreadedDistribution, HostMemory >

Type: Composed< MPIThreadedDistribution, HostMemory >

Defined in src/lib/sbio/execution/mpi_threaded.hh:1165

A hybrid thread/MPI execution policy using host-memory management.

SerialExecution

using SerialExecution = Composed< SerialDistribution, HostMemory >

Type: Composed< SerialDistribution, HostMemory >

Defined in src/lib/sbio/execution/serial.hh:179

A serial execution policy using host-memory management.

ThreadedExecution

using ThreadedExecution = Composed< ThreadedDistribution, HostMemory >

Type: Composed< ThreadedDistribution, HostMemory >

Defined in src/lib/sbio/execution/threaded.hh:466

A thread-based execution policy using host-memory management.

Functions

Return	Name	Description
`SBIO_HD` constexpr `ReadResult`	`classify_read` `constexpr`	Assign an IOStatus based on a retrieved and desired byte count.
`SBIO_HD` constexpr `IOCapability`	[`operator	`](#operator-1)` constexpr`
`SBIO_HD` constexpr `IOCapability`	`operator&` `constexpr`
`SBIO_HD` constexpr bool	`has_capabilities` `constexpr`	Check if the set of capabilities matches some required set.
`SBIO_HD` constexpr `IOCapability`	`io_capabilities` `constexpr`	Query the capabilties of a specific IO policy.
`SBIO_HDZippedGroupRange`< DS, Groups… >	`zip`	Zip a fixed set of BrokerGroups from a DataSource for iteration over its steps.
`SBIO_HDZippedBatchRange`< DS, Groups… >	`zip_batches`	Zip a fixed set of BrokerGroups from a DataSource for iteration over its step batches.
`SBIO_HDSourceSet`< Sources… >	`source_set`	Create a SourceSet to iterate several DataSources together, in lockstep.
`SBIO_HD` bool	`is_locality_match`
`auto`	`make_sync_group`	A variadic helper function to transform any number of objects into a SyncGroup.
`void`	`check` `inline`
`void`	`checkLast` `inline`
`int`	`checkCuda`	A non-aborting check for CUDA errors given a status value from cuFile.
`int`	`checkCuFile`	A non-aborting check for cuFile errors given a status value from cuFile.
`SBIO_HD` void	`visit_ptn` `inline`	Call `fn(std::integral_constant<std::size_t, P>{})` for the runtime access pattern `ptn`, so per-pattern buffers (roles::Data, id == pattern) can be selected at compile time.
`SBIO_HD` constexpr auto &	`get_stream` `constexpr`
`SBIO_HD` constexpr `NamedMember`< Class, T >	`make_named_member` `constexpr`	Construct a NamedMember.
`SBIO_HD` void	`safe_strncpy` `inline`
`str`	`get_pkg_config`
`None`	`sbio_pkg_config`
`str`	`get_include`
`str`	`get_lib_dir`

classify_read

constexpr

constexpr SBIO_HD constexpr ReadResult classify_read(ssize_t got, hd_std::size_t want)

Defined in src/lib/sbio/core/io.hh:89

Assign an IOStatus based on a retrieved and desired byte count.

Returns

A ReadResult with the byte count and IOStatus.

Parameters

Parameter	Type	Description
`got`	`ssize_t`	The number of bytes retrieved (or negative if error).
`want`	`hd_std::size_t`	The number of bytes that were requested.

operator|

constexpr

constexpr SBIO_HD constexpr IOCapability operator|(IOCapability cap_a, IOCapability cap_b)

Defined in src/lib/sbio/core/io.hh:119

operator&

constexpr

constexpr SBIO_HD constexpr IOCapability operator&(IOCapability cap_a, IOCapability cap_b)

Defined in src/lib/sbio/core/io.hh:124

has_capabilities

constexpr

constexpr SBIO_HD constexpr bool has_capabilities(IOCapability set, IOCapability required)

Defined in src/lib/sbio/core/io.hh:132

Check if the set of capabilities matches some required set.

io_capabilities

constexpr

template<typename IO> constexpr SBIO_HD constexpr IOCapability io_capabilities()

Defined in src/lib/sbio/core/io.hh:155

Query the capabilties of a specific IO policy.

Returns

The policy’s capabilties, or DefaultIOCapabilities if the policy does not define any explicitly.

zip

template<class DS, class... Groups> SBIO_HDZippedGroupRange< DS, Groups... > zip(DS & ds, const Groups &... groups)

Defined in src/lib/sbio/core/iteration.hh:689

Zip a fixed set of BrokerGroups from a DataSource for iteration over its steps.

Returns

A range to iterate over in a range-based for loop.

Parameters

Parameter	Type	Description
`ds`	`DS &`	The DataSource the groups were created from.
`groups`	`const Groups &...`	The BrokerGroups to fetch for at each step.

zip_batches

template<class DS, class... Groups> SBIO_HDZippedBatchRange< DS, Groups... > zip_batches(DS & ds, const Groups &... groups)

Defined in src/lib/sbio/core/iteration.hh:701

Zip a fixed set of BrokerGroups from a DataSource for iteration over its step batches.

Returns

A range to iterate over in a range-based for loop.

Parameters

Parameter	Type	Description
`ds`	`DS &`	The DataSource the groups were created from.
`groups`	`const Groups &...`	The BrokerGroups to fetch for at each batch.

source_set

template<class... Sources> SBIO_HDSourceSet< Sources... > source_set(Sources &... sources)

Defined in src/lib/sbio/core/iteration.hh:1031

Create a SourceSet to iterate several DataSources together, in lockstep.

Returns

The SourceSet.

Parameters

Parameter	Type	Description
`sources`	`Sources &...`	The DataSources (after metadata discovery).

is_locality_match

template<class MemTag> SBIO_HD bool is_locality_match(MemorySpace memory_space)

Defined in src/lib/sbio/core/storage_view.hh:68

make_sync_group

template<typename... Args> auto make_sync_group(Args &... args)

Defined in src/lib/sbio/core/sync.hh:88

A variadic helper function to transform any number of objects into a SyncGroup.

check

inline

inline void check(cudaError_t err, const char *const func, const char *const file, const int line)

Defined in src/lib/sbio/cuda/utilities.hh:38

checkLast

inline

inline void checkLast(const char *const file, const int line)

Defined in src/lib/sbio/cuda/utilities.hh:54

checkCuda

int checkCuda(CUfileError_t status)

Defined in src/lib/sbio/cuda/utilities.hh:74

A non-aborting check for CUDA errors given a status value from cuFile.

Returns

0 if the status was not an error -1 if it could figure out the error and printed the message -2 if it was an unrecognized error.

Parameters

Parameter	Type	Description
`status`	`CUfileError_t`	The returned status from the cuFile API.

checkCuFile

int checkCuFile(CUfileError_t status)

Defined in src/lib/sbio/cuda/utilities.hh:107

A non-aborting check for cuFile errors given a status value from cuFile.

This checks cuFile errors first, and then will check for associated CUDA runtime errors that may have occurred while executing cuFile calls. The return value thus contains information about both direct cuFile errors and runtime errors.

Returns

0 if the status was not an error -1 if the was an interpretable runtime error and it printed the message -2 if there was an interpretable runtime error -3 if there was a cuFile error -4 if there was a cuFile error and interpretable runtime error -5 if there was a cuFile error and uninterpretable runtime error

Parameters

Parameter	Type	Description
`status`	`CUfileError_t`	The returned status from the cuFile API.

visit_ptn

inline

template<typename FTraits, class Fn> inline SBIO_HD void visit_ptn(typename FTraits::DataAccessPtn ptn, Fn && fn)

Defined in src/lib/sbio/formats/format_traits.hh:159

Call fn(std::integral_constant<std::size_t, P>{}) for the runtime access pattern ptn, so per-pattern buffers (roles::Data, id == pattern) can be selected at compile time.

get_stream

constexpr

template<typename StreamVariant, typename FTraits, typename IO> constexpr SBIO_HD constexpr auto & get_stream(const Stream< IO, FTraits > * streams)

Defined in src/lib/sbio/formats/format_traits.hh:359

make_named_member

constexpr

template<typename Class, typename T> constexpr SBIO_HD constexpr NamedMember< Class, T > make_named_member(const char * name, T Class::* ptr)

Defined in src/lib/sbio/util/parameters.hh:304

Construct a NamedMember.

Returns

A NamedMember.

safe_strncpy

inline

inline SBIO_HD void safe_strncpy(char * dst, const char * src, std::size_t max_len)

Defined in src/lib/sbio/util/string.hh:34

get_pkg_config

str get_pkg_config()

Defined in src/sbio/init.py:25

sbio_pkg_config

None sbio_pkg_config()

Defined in src/sbio/init.py:61

get_include

str get_include()

Defined in src/sbio/init.py:109

get_lib_dir

str get_lib_dir()

Defined in src/sbio/init.py:124

Variables

Return	Name	Description
constexpr `IOCapability`	`DefaultIOCapabilities` `constexpr`	The default set of capabilities assumed, if the policy does not state its own.
`constexpr hd_std::size_t`	`NoRow` `constexpr`
constexpr `use_rc_alloc_t`	`use_rc_alloc` `constexpr`	Tag to provide for custom allocator RC creation.
constexpr `use_rc_del_t`	`use_rc_del` `constexpr`	Tag to provide for custom deleter RC creation.
constexpr `use_rc_alloc_del_t`	`use_rc_alloc_del` `constexpr`	Tag to provide for custom allocator and deleter RC creation.
`str`	`lib_dir`
`bool`	`has_driver`
`str`	`stub_path`
	`mode`

DefaultIOCapabilities

constexpr

constexpr IOCapability DefaultIOCapabilities {
    IOCapability::ReadToHost | IOCapability::ReadToPinned | IOCapability::ConcurrentReads
  }

Type: constexpr IOCapability

Defined in src/lib/sbio/core/io.hh:143

The default set of capabilities assumed, if the policy does not state its own.

Before the introduction of the explicit IOCapability flags, this set was the implicitly assumed set. I.e., that an IOPolicy could synchornously read into host memory (from any executing thread).

NoRow

constexpr

constexpr hd_std::size_t NoRow { 0xFFFFFFFFu }

Defined in src/lib/sbio/core/state_handle.hh:74

use_rc_alloc

constexpr

constexpr use_rc_alloc_t use_rc_alloc {}

Type: constexpr use_rc_alloc_t

Defined in src/lib/sbio/util/rc.hh:58

Tag to provide for custom allocator RC creation.

use_rc_del

constexpr

constexpr use_rc_del_t use_rc_del {}

Type: constexpr use_rc_del_t

Defined in src/lib/sbio/util/rc.hh:62

Tag to provide for custom deleter RC creation.

use_rc_alloc_del

constexpr

constexpr use_rc_alloc_del_t use_rc_alloc_del {}

Type: constexpr use_rc_alloc_del_t

Defined in src/lib/sbio/util/rc.hh:66

Tag to provide for custom allocator and deleter RC creation.

lib_dir

str lib_dir =  get_lib_dir()

Defined in src/sbio/init.py:174

has_driver

bool has_driver =  ctypes.util.find_library("cuda") is not None

Defined in src/sbio/init.py:179

stub_path

str stub_path =  os.path.join(
            os.path.dirname(__file__), "core", "stubs", "libcuda.so"
        )

Defined in src/sbio/init.py:181

mode

mode

Defined in src/sbio/init.py:186