| ▼Nvecmem | Main namespace for the vecmem classes/functions |
| ►Ncuda | Namespace holding types that work on/with CUDA |
| ►Ndetails | |
| Cselect_device | Class with RAII mechanism for selecting a CUDA device |
| Cstream_owner | Struct responsible for managing the lifetime of a CUDA stream |
| Casync_copy | Specialisation of vecmem::copy for CUDA |
| Ccopy | Specialisation of vecmem::copy for CUDA |
| Cdevice_atomic_ref | Custom implementation for atomic operations in CUDA device code |
| Cdevice_memory_resource | Memory resource that wraps direct allocations on a CUDA device |
| Chost_memory_resource | Memory resource that wraps page-locked CUDA host allocation |
| Cmanaged_memory_resource | Memory resource that wraps managed CUDA allocation |
| Cruntime_error | Specific exception for CUDA errors thrown by this library |
| ►Cstream_wrapper | Wrapper class for cudaStream_t |
| Cimpl | |
| ►Ndata | Namespace holding "data types" |
| Cjagged_vector_buffer | Object owning all the data of a jagged vector |
| Cjagged_vector_data | A data wrapper for jagged vectors |
| Cjagged_vector_view | A view for jagged vectors |
| Cvector_buffer | Object owning the data held by it |
| Cvector_view | Class holding data about a 1 dimensional vector/array |
| ►Ndetails | Namespace for types that should not be used directly by clients |
| Carena_memory_resource_impl | Implementation backend for vecmem::details::arena_page_memory_resource |
| ►Cbinary_page_memory_resource_impl | Implementation of vecmem::binary_page_memory_resource |
| Cpage_ref | Helper class to refer to pages in superpages |
| Csuperpage | Container for superpages in our buddy allocator |
| Cchoice_memory_resource_impl | Implementation for vecmem::details::choice_memory_resource |
| Ccoalescing_memory_resource_impl | Implementation for vecmem::details::coalescing_memory_resource |
| Cconditional_memory_resource_impl | Implementation for vecmem::details::conditional_memory_resource |
| Cconjunction | Implementation for std::conjunction |
| Cconjunction< B1 > | |
| Cconjunction< B1, Bn... > | |
| Ccontiguous_memory_resource_impl | Implementation of vecmem::contiguous_memory_resource |
| Cdebug_memory_resource_impl | Implementation for vecmem::details::debug_memory_resource |
| Cdisjunction | Implementation for std::disjunction |
| Cdisjunction< B1 > | |
| Cdisjunction< B1, Bn... > | |
| Cinstrumenting_memory_resource_impl | Implementation for vecmem::details::instrumenting_memory_resource |
| Cis_same_nc | Helper trait for detecting when a type is a non-const version of another |
| Cis_same_nc< const TYPE, TYPE > | |
| ►Cjagged_device_vector_iterator | Custom iterator for vecmem::jagged_device_vector |
| Cpointer | Helper class for returning "pointer-like" objects from the iterator |
| Cmemory_resource_base | Base class for implementations of the vecmem::memory_resource interface |
| Cnegation | Implementation for std::negation |
| Cpool_memory_resource_impl | Implementation of vecmem::pool_memory_resource |
| Creverse_iterator | Type mimicking std::reverse_iterator |
| Cstatic_array_type | Helper type for an array with a given type and size |
| ►Cstatic_array_type< T, 0 > | |
| Ctype | |
| Cstatic_vector_type | Helper type for an array in a static_vector with a given type and size |
| Cstatic_vector_type< T, 0 > | |
| Ctuple_get_impl | Struct used to implement vecmem::get in a C++14 style |
| Ctuple_get_impl< 0 > | Specialization of vecmem::details::tuple_get_impl for the 0th element |
| Cunique_alloc_deleter | A deleter class for trivial allocations |
| Cunique_obj_deleter | A deleter class for non-trivial objects |
| ►Nedm | Namespace for the types implementing Struct-of-Array container support |
| ►Ndetails | |
| Cadd_const | Technical base type for add_const<schema<VARTYPES...>> |
| Cadd_const< schema< VARTYPES... > > | Add constness to all variable types in a schema |
| Cbuffer_alloc | |
| Cbuffer_alloc< type::jagged_vector< TYPE > > | |
| Cbuffer_alloc< type::scalar< TYPE > > | |
| Cbuffer_alloc< type::vector< TYPE > > | |
| Cdata_alloc | |
| Cdata_alloc< type::jagged_vector< TYPE > > | |
| Cdata_type | |
| Cdata_type< type::jagged_vector< TYPE > > | |
| Cdevice_get | |
| Cdevice_get< type::scalar< TYPE > > | |
| Cdevice_size_pointer | Helper trait for setting the m_size variable of a device object |
| Cdevice_size_pointer< false > | Helper trait for setting the m_size variable of a device object (for a "non-jagged schema") |
| Cdevice_size_pointer< true > | Helper trait for setting the m_size variable of a device object (for a "jagged schema") |
| Cdevice_type | |
| Cdevice_type< type::jagged_vector< TYPE > > | |
| Cdevice_type< type::scalar< TYPE > > | |
| Cdevice_type< type::vector< TYPE > > | |
| Cdevice_type_at | |
| Cget_capacities_impl | |
| Cget_capacities_impl< 0u, VARTYPES... > | |
| Chas_jagged_vector | Technical base type for has_jagged_vector<schema<VARTYPES...>> |
| Chas_jagged_vector< schema< VARTYPES... > > | Check if a schema contains at least one jagged vector variable |
| Chas_scalar | Technical base type for has_scalar<schema<VARTYPES...>> |
| Chas_scalar< schema< VARTYPES... > > | Check if a schema contains at least one scalar variable |
| Chas_vector | Technical base type for has_vector<schema<VARTYPES...>> |
| Chas_vector< schema< VARTYPES... > > | Check if a schema contains at least one vector variable |
| Chost_alloc | |
| Chost_alloc< type::scalar< TYPE > > | |
| Chost_type | |
| Chost_type< type::jagged_vector< TYPE > > | |
| Chost_type< type::scalar< TYPE > > | |
| Chost_type< type::vector< TYPE > > | |
| Chost_type_at | |
| Cproxy_data_creator | Technical base class for the proxy_data_creator traits |
| Cproxy_data_creator< schema< VARTYPE >, PDOMAIN, proxy_access::constant, proxy_type::reference > | Helper class making the data tuple for a constant device proxy |
| Cproxy_data_creator< schema< VARTYPE >, PDOMAIN, proxy_access::non_constant, proxy_type::reference > | Helper class making the data tuple for a non-const device proxy |
| Cproxy_data_creator< schema< VARTYPE, VARTYPES... >, PDOMAIN, proxy_access::constant, proxy_type::reference > | Helper class making the data tuple for a constant device proxy |
| Cproxy_data_creator< schema< VARTYPE, VARTYPES... >, PDOMAIN, proxy_access::non_constant, proxy_type::reference > | Helper class making the data tuple for a non-const device proxy |
| Cproxy_var_type | Technical base class for the proxy_var_type traits |
| Cproxy_var_type< type::jagged_vector< VTYPE >, proxy_domain::device, proxy_access::constant, proxy_type::reference > | Constant access to a jagged vector variable from a device container |
| Cproxy_var_type< type::jagged_vector< VTYPE >, proxy_domain::device, proxy_access::non_constant, proxy_type::reference > | Non-const access to a jagged vector variable from a device container |
| Cproxy_var_type< type::jagged_vector< VTYPE >, proxy_domain::host, PACCESS, proxy_type::standalone > | Standalone host jagged vector variable (const and non-const) |
| Cproxy_var_type< type::jagged_vector< VTYPE >, proxy_domain::host, proxy_access::constant, proxy_type::reference > | Constant access to a jagged vector variable from a host container |
| Cproxy_var_type< type::jagged_vector< VTYPE >, proxy_domain::host, proxy_access::non_constant, proxy_type::reference > | Non-const access to a jagged vector variable from a host container |
| Cproxy_var_type< type::scalar< VTYPE >, PDOMAIN, PACCESS, proxy_type::standalone > | Standalone scalar variable (both host and device, const and non-const) |
| Cproxy_var_type< type::scalar< VTYPE >, PDOMAIN, proxy_access::constant, proxy_type::reference > | Constant access to a scalar variable (both host and device) |
| Cproxy_var_type< type::scalar< VTYPE >, PDOMAIN, proxy_access::non_constant, proxy_type::reference > | Non-const access to a scalar variable (both host and device) |
| Cproxy_var_type< type::vector< VTYPE >, PDOMAIN, PACCESS, proxy_type::standalone > | Standalone vector variable (both host and device, const and non-const) |
| Cproxy_var_type< type::vector< VTYPE >, PDOMAIN, proxy_access::constant, proxy_type::reference > | Constant access to a vector variable (both host and device) |
| Cproxy_var_type< type::vector< VTYPE >, PDOMAIN, proxy_access::non_constant, proxy_type::reference > | Non-const access to a vector variable (both host and device) |
| Cproxy_var_type_at | Proxy types for one element of a type pack |
| Cremove_cv | Technical base type for remove_cv<schema<VARTYPES...>> |
| Cremove_cv< schema< VARTYPES... > > | Remove constness and volatility from all variable types in a schema |
| Cview_type | |
| Cview_type< type::jagged_vector< TYPE > > | |
| Cview_type< type::scalar< TYPE > > | |
| Cview_type< type::vector< TYPE > > | |
| Cview_type_base | |
| ►Ntype | |
| ►Ndetails | |
| Cadd_const | |
| Cadd_const< type::jagged_vector< TYPE > > | |
| Cadd_const< type::scalar< TYPE > > | |
| Cadd_const< type::vector< TYPE > > | |
| Cis_jagged_vector | |
| Cis_jagged_vector< type::jagged_vector< TYPE > > | |
| Cis_same_nc | |
| Cis_same_nc< type::jagged_vector< TYPE1 >, type::jagged_vector< TYPE2 > > | |
| Cis_same_nc< type::scalar< TYPE1 >, type::scalar< TYPE2 > > | |
| Cis_same_nc< type::vector< TYPE1 >, type::vector< TYPE2 > > | |
| Cis_scalar | |
| Cis_scalar< type::scalar< TYPE > > | |
| Cis_vector | |
| Cis_vector< type::jagged_vector< TYPE > > | |
| Cis_vector< type::vector< TYPE > > | |
| Cremove_cv | |
| Cremove_cv< type::jagged_vector< TYPE > > | |
| Cremove_cv< type::scalar< TYPE > > | |
| Cremove_cv< type::vector< TYPE > > | |
| Cjagged_vector | 2D jagged vector variable |
| Cscalar | Scalar variable, one for a whole container |
| Cvector | 1D vector variable |
| Cbuffer | Technical base type for buffer<schema<VARTYPES...>> |
| Cbuffer< schema< VARTYPES... > > | Buffer for a Struct-of-Arrays container |
| Ccontainer | Description of a container, with all of the types needed to use it |
| Cdata | Technical base type for data<schema<VARTYPES...>> |
| Cdata< schema< VARTYPES... > > | Data object describing a Struct-of-Arrays container |
| Cdevice | Technical base type for device<schema<VARTYPES...>,INTERFACE> |
| Cdevice< schema< VARTYPES... >, INTERFACE > | Structure-of-Arrays device container |
| Chost | Technical base type for host<schema<VARTYPES...>,INTERFACE> |
| Chost< schema< VARTYPES... >, INTERFACE > | Structure-of-Arrays host container |
| Cproxy | Technical base type for proxy<schema<VARTYPES...>,PDOMAIN,PACCESS,PTYPE> |
| Cproxy< schema< VARTYPES... >, PDOMAIN, PACCESS, PTYPE > | Structure-of-Arrays element proxy |
| Cschema | Meta type describing the "schema" of an SoA container |
| Cview | Technical base type for view<schema<VARTYPES...>> |
| Cview< schema< VARTYPES... > > | View of a Struct-of-Arrays container |
| ►Nhip | Namespace holding types that work on/with ROCm/HIP |
| ►Ndetails | Namespace for types that should not be used directly by clients |
| Crun_on_device | Helper functor used for running a piece of code on a given device |
| Cselect_device | Class with RAII mechanism for selecting a HIP device |
| Cstream_owner | Struct responsible for managing the lifetime of a HIP stream |
| Casync_copy | Specialisation of vecmem::copy for HIP |
| Ccopy | Specialisation of vecmem::copy for HIP |
| Cdevice_memory_resource | Memory resource for a specific HIP device |
| Chost_memory_resource | Memory resource for HIP shared host/device memory |
| Cmanaged_memory_resource | Memory resource that wraps managed HIP allocation |
| Cruntime_error | Specific exception for HIP errors thrown by this library |
| ►Cstream_wrapper | Wrapper class for hipStream_t |
| Cimpl | |
| ►Nsycl | Namespace holding types that work on/with oneAPI/SYCL |
| ►Ndetails | Namespace for types that should not be used directly by clients |
| Cbuiltin_address_space | Helper trait for setting up an atomic reference on global or local memory |
| Cbuiltin_address_space< device_address_space::global > | Specialization for global device memory |
| Cbuiltin_address_space< device_address_space::local > | Specialization for local device memory |
| Ccustom_address_space | |
| Ccustom_address_space< device_address_space::global > | |
| Ccustom_address_space< device_address_space::local > | |
| Cmemory_resource_base | SYCL memory resource base class |
| Cqueue_holder | Base class for all user-facing, sycl::queue using classes |
| Casync_copy | Specialisation of vecmem::copy for SYCL |
| Ccopy | Specialisation of vecmem::copy for SYCL |
| Ccustom_device_atomic_ref | Custom implementation for atomic operations in SYCL device code |
| Cdevice_memory_resource | Memory resource for a specific SYCL device |
| Chost_memory_resource | Host memory resource, connected to a specific SYCL device |
| Cqueue_wrapper | Wrapper class for ::sycl::queue |
| Cshared_memory_resource | Memory resource shared between the host and a specific SYCL device |
| Cabstract_event | Interface that language specific "events" need to implement |
| Callocator | An allocator class that wraps a memory resource |
| Carena_memory_resource | Memory resource implementing an arena allocation scheme |
| Carray | Array with a fixed size, chosen during runtime |
| Catomic | Class providing atomic operations for the VecMem code |
| Cbinary_page_memory_resource | A memory manager using power-of-two pages that can be split to deal with allocation requests of various sizes |
| Cchoice_memory_resource | This memory resource conditionally allocates memory |
| Ccoalescing_memory_resource | This memory resource tries to allocate with several upstream resources and returns the first succesful one |
| Cconditional_memory_resource | This memory resource conditionally allocates memory |
| Ccontiguous_memory_resource | Downstream allocator that ensures that allocations are contiguous |
| ►Ccopy | Class implementing (synchronous) host <-> device memory copies |
| Ctype | Wrapper struct around the copy_type enumeration |
| Cdebug_memory_resource | This memory resource forwards allocation and deallocation requests to the upstream resource, but alerts the user of potential problems |
| Cdevice_array | Class mimicking a host-filled std::array in "device code" |
| Cdevice_vector | Class mimicking an std::vector in "device code" |
| Cdummy_device_atomic_ref | Dummy / No-op atomic reference for unsupported devices / compilers |
| Chost_memory_resource | Memory resource which wraps standard library memory allocation calls |
| Cidentity_memory_resource | This memory resource forwards allocation and deallocation requests to the upstream resource |
| ►Cinstrumenting_memory_resource | This memory resource forwards allocation and deallocation requests to the upstream resource while recording useful statistics and information about these events |
| Cmemory_event | Structure describing a memory resource event |
| Cjagged_device_vector | A view for jagged vectors |
| Cmemory_monitor | Class collecting some basic set of memory allocation statistics |
| ►Cpool_memory_resource | Memory resource pooling allocations of various sizes |
| Coptions | Runtime options for vecmem::pool_memory_resource |
| Cposix_device_atomic_ref | Custom implementation for atomic operations using "POSIX" built-ins |
| Cstatic_array | Simple statically-sized array-like class designed for use in device code |
| Cstatic_vector | Class mimicking std::vector on top of a fixed sized array |
| Csynchronized_memory_resource | A memory resource that synchronizes the operations of an upstream resource |
| Cterminal_memory_resource | This memory resource does nothing, but it does nothing for a purpose |
| Ctuple | Default tuple type |
| Ctuple< T, Ts... > | Simple tuple implementation for the vecmem EDM classes |
| Ctuple_element | Default/empty implementation for vecmem::tuple_element |
| Ctuple_element< I, tuple< Ts... > > | Get the type of the I-th element of a tuple |
