| Ccore< P >::access< Priv > | Default-constructible base for topology accessors |
| Cnarray< Policy >::access< Priv > | Topology interface base |
| Cntree< Policy >::access< Priv > | See specialization_base::interface |
| Cunstructured< Policy >::access< Privileges > | Topology interface base |
| Caccessor< L, T, Priv > | A data accessor |
| Caccessor< dense, DATA_TYPE, PRIVILEGES > | |
| Caccessor< dense, std::size_t, OP > | |
| ►Caccessor< raw, T, P > | |
| Caccessor< dense, T, P > | Accessor for ordinary fields |
| ►Caccessor< raw, T, privilege_pack< privilege_merge(P)> > | |
| Cragged_accessor< T, P, privilege_repeat< ro, privilege_count(P)> > | |
| Cragged_accessor< T, P, privilege_repeat< privilege_discard(P) ? wo :rw, privilege_count(P)> > | |
| Cragged_accessor< class, Privileges, Privileges > | Accessor for ragged fields |
| Caccessor< sparse, T, P > | Accessor for sparse fields |
| Ccontrol< P >::action< T, CP, M > | The action type provides a mechanism to add execution elements to the FleCSI control model |
| Ccontrol< P >::action< wrap, cp > | |
| Caxis | Information about the layout of an entire axis |
| ►Caxis_color | High-level information about one axis of one color |
| Caxis_info | Collected information about one color along one axis. This class is supported for GPU execution |
| Caxis_definition | This type is part of the index definition, and defines the coloring of an individal axis |
| Caxis_layout | The layout of one axis of one color |
| Cbase< core > | Each core topology type must register its base type |
| CBBox< DIM > | The bounding box type that is used by KDTree as input |
| Cbind_accessors< Proc > | The bind_accessors type is called to walk the user task arguments inside of an executing legion task to properly complete the users accessors, i.e., by pointing the accessor view instances to the appropriate legion-mapped buffers |
| ►Cbind_tag | Task parameters of types that inherit from bind_tag must be specially initialized by the backend |
| Ctopology_accessor< typename Policy::mesh_type, privilege_repeat< get_privilege(0, Priv), 3 > > | |
| Caccessor< raw, DATA_TYPE, PRIVILEGES > | Accessor for potentially uninitialized memory |
| Caccessor< single, DATA_TYPE, PRIVILEGES > | Accessor for a single value. This class is supported for GPU execution |
| Cmulti< class > | A sequence of accessors obtained from a launch::mapping |
| Cmutator< ragged, T, P > | Mutator for ragged fields |
| Cmutator< sparse, T, P > | Mutator for sparse fields |
| Creduction_accessor< R, T > | Accessor for computing reductions |
| Ctopology_accessor< class, Privileges > | Topology accessor type |
| Cborrow | A selection of rows, typically of a data::prefixes object |
| ►Cborrow_base | Specialization-independent definitions |
| Cborrow_category< P > | A selection from an underlying topology |
| Cborrow_extra< T > | Topology-specific extension to support multi-color topology accessors |
| ►Cborrow_extra< P::Base::core > | |
| Cborrow_category< P > | A selection from an underlying topology |
| Cbuffers_base::buffer | The buffer type stores the data array to be used for communication, along with a reader and writer type to read from and write to the data array |
| Ctee_buffer_t::buffer_data_t | The buffer_data_t type is used to hold state and the actual low-level stream buffer pointer |
| Cbuffers_base | This topology implements pipe-like communication in terms of our color-specific accessors by having one ghost index point for every edge in a directed communication graph |
| Ccast | Aggregate helper that converts to any type via get |
| Cnarray_base::coloring | Coloring type |
| Cntree_base::coloring | Ntree coloring |
| Cset_base::coloring | This struct gives the coloring interface for the Set topology |
| Cunstructured_base::coloring | Information for constructing an unstructured mesh |
| Ccoloring_slot< class > | A mpi_coloring object, constructed on request |
| Ccoloring_slot< D > | |
| Cconfig | Specification for Flog operation |
| ►Cconfig_base | Specification of options for FleCSI |
| Cconfig | Backend-specific options |
| Cconfig | Backend-specific options |
| Cconfig | Backend-specific options |
| Ccontext | The context type provides a high-level execution context interface that is implemented by a specific backend |
| Ccontext< T > | Base for annotation contexts |
| Ccontext< execution > | |
| Ccontrol< P > | The control type provides a control model for specifying a set of control points as a coarse-grained control flow graph, with each node of the graph specifying a set of actions as a directed acyclic graph (DAG) |
| ►Ccontrol_base | Base class for providing default implementations for optional interfaces |
| Ccontrol_policy | An example control policy that is not really implemented |
| Cconvert< T > | Defines a serialization in terms of a representation type |
| Ccopy_engine | Performs a specified copy operation repeatedly |
| Ccopy_plan | Specifies a pattern of data movement among colors in an index space |
| ►Ccore_base | An example topology base that is not really implemented |
| Ccore< P > | An example core topology that is not really implemented |
| Ccounter< M > | A counter with a maximum |
| Ccrs | Efficient (compressed-row) storage for a sequence of sequences of integers |
| Ccycle< Predicate, ControlPoints > | Allow users to define cyclic control points |
| Cdag< NodePolicy > | Basic DAG type |
| Cdata_guard | An RAII type to manage the global coloring and topologies |
| Cfield< T, L >::definition< Topo, Space > | A field registration |
| Cfield< T, L >::definition< claims > | |
| Cfield< T, L >::definition< flecsi::topo::resize > | |
| Cfield< T, L >::definition< meta< P > > | |
| Cfield< T, L >::definition< meta< Policy > > | |
| Cfield< T, L >::definition< used > | |
| Cdependencies_config | Specification for initializing underlying libraries |
| Cdependencies_guard | RAII guard for initializing/finalizing FleCSI dependencies |
| Cdimensioned_array< TYPE, DIMENSION, NAMESPACE > | The dimensioned_array type provides a general base for defining contiguous array types that have a specific dimension |
| Cdimensioned_array< double, DIM > | |
| Cntree_specialization::entity_data | Struct containing data for entities to compute interactions |
| Ccontrol_base::exception | Exception class for control points |
| Cfield< T, L > | Helper type to define and access fields |
| Cfield< buffer > | |
| Cfield< Color > | |
| Cfield< color_id > | |
| Cfield< copy_engine::Point > | |
| Cfield< data::intervals::Value > | |
| Cfield< entity_data > | |
| Cfield< flecsi::topo::hcell_base_t > | |
| Cfield< h_s_t > | |
| Cfield< hist_int_t > | |
| Cfield< hmap_pair_t > | |
| Cfield< int > | |
| Cfield< interval > | |
| Cfield< key_t > | |
| Cfield< key_type > | |
| Cfield< meta, data::single > | |
| Cfield< meta_type, data::single > | |
| Cfield< node_data > | |
| Cfield< ntree_data > | |
| Cfield< std::size_t > | |
| Cfield< util::id > | |
| Cfield_info_t | The field_info_t type provides a structure for capturing runtime field information |
| Cfield_reference< class, layout, Topo, index_space > | Identifies a field on a particular topology instance |
| Cfilling_curve_key< DIM, T, DERIVED > | Space filling curve keys generator, CRTP base |
| ►Cfilling_curve_key< DIM, T, hilbert_key< DIM, T > > | |
| Chilbert_key< DIM, T > | Point on a Hilbert-Peano space filling curve |
| ►Cfilling_curve_key< DIM, T, morton_key< DIM, T > > | |
| Cmorton_key< DIM, T > | Point on a Morton space filling curve |
| ►Cfilling_curve_key< DIM, T, my_key< DIM, T > > | |
| Cmy_key< DIM, T > | Example implementation of filling curve derived from the filling_curve_key CRTP |
| Cfull_range | This class computes full range size if prefix or subinterval of the range is not specified |
| Cfuture< Return, Launch > | Single or multiple future |
| Cfuture< bool > | |
| Cfuture< Return > | Single-valued future |
| Cfuture< Return, exec::launch_type_t::index > | Multi-valued future from an index launch |
| Cgetopt | Command-line parser |
| Cgraphviz | Class for creating Graphviz trees |
| Ctrace::guard | RAII guard for executing a trace |
| Cguard | Scope guard for categorizing output |
| Cguard< ctx, severity > | Scope guard for marking a code region |
| Chcell_base_t< DIM, T, KEY > | Base type for an entry in the hashtable This type can point to either a node or an entity in the ntree |
| Cidentity | Interpret a type as itself in functional contexts |
| Cindex_color | Information specific to a single index space and color |
| Cindex_definition | This type is part of the coloring, and encapsulates the coloring information for a single index space (such as how many colors per axis the mesh needs to be partitioned into, if boundaries are periodic, etc), that is used by the coloring algorithm to create mesh partitions |
| Cunstructured_base::coloring::index_space | Coloring information for a single index space |
| Cinplace_vector< T, SIZE > | A small implementation of std::inplace_vector as proposed for C++26 |
| Ciota_view< I > | A very simple emulation of std::ranges::iota_view from C++20 |
| Cmutator< sparse, T, P >::row::iterator | Bidirectional iterator over key-value pairs |
| CKDTree< DIM > | A k-d tree for efficiently finding intersections between shapes |
| Ckey_tuple< VT > | A std::tuple containing the given types and indexed by the given keys |
| Claunch_domain | An explicit launch domain size |
| Cmap_base< D > | A partition of some prefix of the whole numbers into substrings |
| ►Cmap_base< equal_map > | |
| Cequal_map | A partition with substrings of equal size |
| ►Cmap_base< offsets > | |
| Coffsets | A partition with substrings of arbitrary size |
| Cmapping< P > | A prepared assignment of colors |
| Cmapping< sort_base::sort_array_t > | |
| Cmax | Maximum reduction type |
| ►Cmdbase< T, D > | A multi-dimensional view of an array |
| Cmdcolex< T, D > | A variation of mdspan with reversed indices (distinguished by ()) |
| Cmdspan< T, D > | A small, approximate subset of mdspan from C++23 |
| Cmessage< Policy > | The message type provides a basic log message type that is customized with a formatting policy |
| Cnarray_specialization::meta_data | Specialization-specific data to store once per color |
| Cmin | Minimum reduction type |
| Cmove_optional< T > | Empty upon move |
| Cmove_optional< core > | |
| Cmove_optional< id_t > | |
| Cspecialization< C, D >::mpi_coloring | Constructs a coloring in an MPI task |
| Cmpi_mapper_t | FleCSI's mapper, named for its support for rank-matching for MPI tasks |
| Cmulti_reference< T, L, Topo, S > | Identifies a field on a launch::mapping |
| Cmutator< layout, class, Privileges > | A specialized accessor for changing the extent of dynamic layouts |
| ►Cnarray_base | Specialization-independent definitions |
| Cnarray< Policy > | Narray Topology |
| Cntree_specialization::node_data | Struct containing data for nodes to compute interactions |
| Ccontrol_policy::node_policy | Base class for control point objects |
| ►Cntree_base | Ntree topology base |
| Cntree< Policy > | The ntree topology represents a binary, quad or octree stored/accessed using a hashtable |
| Cpartial< F, AA > | A simple version of C++20's bind_front that can be an argument to a task template |
| ►Cpartition | Base class storing a prefix of each row in a region_base |
| ►Cpartition | Common dependent partitioning facility |
| Cintervals | A subset of each row in a region_base, expressed as a set of intervals |
| ►Cprefixes | A prefix of each row in a region_base |
| Crepartition | A partition with a field for dynamically resizing it |
| Cprefixes | A prefix of each row in a region_base |
| Crows | All of each row in a region_base |
| Cpeer_entities | Communication pattern for a single pair of colors |
| Cpoint_walker< P > | The point_walker class allows execution of statically-defined control points |
| Cresize::policy | A heuristic for automatically resizing a partition |
| Cprefix_range | This class computes the range based on the prefix specified |
| Cproduct | Product reduction type |
| Cprogram_option< ValueType > | The program_option type is a wrapper that implements a useful subset of Boost's Program Options utility |
| Cqueue< T, SIZE > | A simple queue implementation based on a std::array This class is supported for GPU execution |
| Cbuffers::ragged | Utility to transfer the contents of ragged rows via buffers |
| Cnarray< Policy >::ragged_impl< Space, T > | Ragged communication routines |
| Cbuffers_base::buffer::reader | An input stream for a buffer |
| Creduce | An example reduction type that is not really implemented |
| Cregion< CTX > | Base for code region annotations |
| Cregion< execution > | |
| Cregion_base | A rectangular abstract array |
| Crguard< reg > | Scope guard for marking a code region |
| Caccessor< sparse, T, P >::row | A mapping backed by a row. Use the ragged interface to iterate |
| Cmutator< ragged, T, P >::row | A row handle |
| Cmutator< sparse, T, P >::row | A row handle |
| Cruntime | FleCSI runtime state |
| ►Csend_tag | Classes that inherit from send_tag can decompose themselves into simpler parameters via a send member function template |
| Cparticle_accessor< T, P, false > | |
| ►Cparticle_accessor< T, P, true > | |
| Cmutator< particle, T, P > | Mutator for particle fields |
| Cragged_accessor< T, P, privilege_repeat< ro, privilege_count(P)> > | |
| Cragged_accessor< T, P, privilege_repeat< privilege_discard(P) ? wo :rw, privilege_count(P)> > | |
| Ctopology_accessor< typename Policy::mesh_type, privilege_repeat< get_privilege(0, Priv), 3 > > | |
| Caccessor< dense, T, P > | Accessor for ordinary fields |
| Caccessor< single, DATA_TYPE, PRIVILEGES > | Accessor for a single value. This class is supported for GPU execution |
| Cmulti< class > | A sequence of accessors obtained from a launch::mapping |
| Cmutator< ragged, T, P > | Mutator for ragged fields |
| Cmutator< sparse, T, P > | Mutator for sparse fields |
| Cparticle_accessor< class, Privileges, bool > | Accessor for particle fields |
| Cragged_accessor< class, Privileges, Privileges > | Accessor for ragged fields |
| Ctopology_accessor< class, Privileges > | Topology accessor type |
| Cset< Policy > | This struct is a Set topology interface |
| Csort< FieldRef > | Sort object implementing a distributed sort and load balancing |
| Cspan< T > | A workalike for std::span from C++20 (only dynamic-extent, without ranges support) |
| Cspan< element_type > | |
| Cspan< pair_t > | |
| ►Cspecialization_base | Utilities and defaults for specializations |
| ►Cspecialization< detail::buffers_category, buffers > | |
| Cbuffers | The buffers type provides an interface for dynamic amounts of data |
| Cspecialization< topo::array_category, intervals > | |
| Cspecialization< topo::column, used > | |
| Cspecialization< array_category, array< P > > | |
| ►Cspecialization< borrow_category, borrow< Q > > | |
| Cborrow< topo::meta< Q > > | |
| Cborrow< Q > | Specialization for borrowing |
| Cspecialization< column, claims > | |
| ►Cspecialization< global_category, global > | |
| Cglobal | Unpartitioned topology whose fields are readable by all colors |
| ►Cspecialization< index_category, index > | |
| Cindex | The index type allows users to register data on an arbitrarily-sized set of indices that have an implicit one-to-one coloring |
| Cspecialization< user, meta< P > > | |
| Cspecialization< user, meta< Policy > > | |
| ►Cspecialization< narray, narray_specialization > | |
| Cnarray_specialization | Example specialization which is not really implemented |
| ►Cspecialization< ntree, ntree_specialization > | |
| Cntree_specialization | Example specialization which is not really implemented |
| Cspecialization< ragged_category, ragged< T > > | |
| Cspecialization< ragged_partition_category, ragged_partition > | |
| ►Cspecialization< column, resize > | |
| Cresize | A subtopology for storing/updating row sizes of a partition |
| ►Cspecialization< set, set_specialization > | |
| Cset_specialization | Example specialization which is not really implemented |
| Cspecialization< user, ctopo > | |
| ►Cspecialization< unstructured, unstructured_specialization > | |
| Cunstructured_specialization | Example specialization which is not really implemented |
| Cspecialization< topo::color, sort_color > | |
| ►Cspecialization< borrow_category, borrow< flecsi::topo::resize > > | |
| Cborrow< flecsi::topo::resize > | |
| Chelp | Convenience base class for specialization class templates |
| Cspecialization< C, D > | CRTP base for specializations |
| Cstate | The state type provides access to logging parameters and configuration |
| Csub_range | This class computes subinterval of a range based on the starting and ending indices provided |
| Csubstring_view< R > | A view of part of a range |
| Csum | Sum reduction type |
| CSymbol< S > | Dummy class template |
| Ctag | A tag for labeling output to enable |
| Ctask_local< T > | A global variable with a task-specific value |
| Ctask_local< std::size_t > | |
| Ctask_local< test_output_t > | |
| ►Ctask_prologue< Proc > | Handling for low-level special task parameters/arguments |
| Cprolog< Proc > | Analyzes task arguments and updates data objects before launching a task |
| Ctask_wrapper< F, P > | The task_wrapper type provides execution functions for user and MPI tasks |
| Ctee_buffer_t | The tee_buffer_t type provides a stream buffer that allows output to multiple targets |
| Ctee_stream_t | The tee_stream_t type provides a stream class that writes to multiple output buffers |
| Ctopology_slot< Topo > | A movable slot that holds a topology, constructed upon request |
| Ctrace | Records execution of a loop whose iterations all execute the same sequence of tasks |
| Ctraits< T, E > | Extension point for serialization |
| Ctransform_view< C, F > | A very simple emulation of std::ranges::transform_view from C++20 |
| ►Cunstructured_base | Specialization-independent definitions |
| Cunstructured< P > | |
| Cunstructured< Policy > | Topology type |
| Cvalue< T > | Convenience for stateless types |
| Cvalue< data::topology_accessor< T, Priv > > | |
| Cvalue< future< T > > | |
| ►Cwith_size | Size information for a partition |
| Crepartition | A partition with a field for dynamically resizing it |
| Cbuffers_base::buffer::writer | An output stream for a buffer |
1.12.0