| ►Nboost | |
| Cgraph_traits< stapl::sequential::directed_preds_graph< stapl::MULTIEDGES, VertexProperty, EdgeProperty > > | Specialization of boost::graph_traits for STAPL sequential directed_preds_graph |
| Cgraph_traits< stapl::sequential::graph< stapl::DIRECTED, stapl::MULTIEDGES, VertexProperty, EdgeProperty, stapl::sequential::adj_graph_traits< stapl::DIRECTED, stapl::MULTIEDGES, VertexProperty, EdgeProperty > > > | BGL-style traits class for the STAPL sequential graph |
| Cstapl_graph_data_map | Class for property map over STAPL sequential graph.Returns a reference to the value stored on the vertex of the graph |
| Cstapl_graph_edge_id_map | Edge property map for BGL that returns identity (edge-id) |
| Cstapl_graph_edge_wt_id_map | Edge property map for BGL that returns the weights of edges stored in an external weight-vector |
| Cstapl_graph_id_map | Vertex property map for BGL that returns identity |
| Cstapl_graph_traversal_category | Struct to tag various traversal categories for graph algorithms |
| Cstapl_property_map | Class for property map over STAPL sequential graph |
| Cstapl_property_map< edge_all_t > | Specialization of stapl_property_map for all edges |
| Cstapl_property_map< edge_index_t > | Specialization of stapl_property_map for edge indices |
| Cstapl_property_map< vertex_all_t > | Specialization of stapl_property_map for vertices, using stored data |
| Cstapl_property_map< vertex_index_t > | Specialization of stapl_property_map for vertex indices |
| ►Nstapl | |
| ►Naggr_algo_detail | |
| Cadd_edge_wf | Helper functor to add provided edge to the graph |
| Cadd_property_edge_wf | Helper functor to add provided edge with property to the graph |
| Caggregator_helper_wf | Helper functor to execute user-provided functor on the graph |
| Crand_cont | Functor to generate random numbers between [0, i) |
| Ctarget_aggr_helper | Helper functor to wrap user-provided functor to provide a target |
| Cvertex_apply_wf | Helper functor to execute user-provided functor on the target vertex. For use in aggregator_apply |
| Cvp_apply_aggr_helper | Helper functor to execute user-provided functor on the target vertex's property |
| ►Nalgo_details | |
| Cadjacent_diff | Work function to compute the difference of two adjacent elements in a view |
| Cassign_if | Work function for replace_if(), which assigns the stored value to the argument if the predicate returns true |
| Cbinary_search_map_wf | Work function which invokes std::binary_search |
| Cconvert_to_int | Convert boolean return value of partition predicate passed to is_partitioned() to int, so that it is in the tribool form expected by the is_partitioned_reduce reduction operator of the stapl::map_reduce |
| Ccopy_with_replacement | Copies the first argument to the second unless the first meets the predicate provided, in which case the given value is copied to the second argument |
| Cequal_range_reduce_wf | Work function for equal_range() which, given two domains, returns the one which is non-empty, or merges them together |
| Cfind_end_reduce | Work function which returns its second argument if non-null, and the first otherwise |
| Cfind_reduce | Work function which returns its first argument if non-null, and the second otherwise |
| Cgen_comp_func | Work function for is_sorted() which takes a reference to two elements, and returns true if the given functor returns false when called with (second, first) |
| Cis_partitioned_reduce | Work function used in is_partitioned() to determine whether the input is partitioned |
| Cis_sorted_until_compare | Work function for is_sorted_until(), which returns false if the given elements are out of order, and true otherwise |
| Cis_sorted_until_reduce | Work function for is_sorted_until(), which returns the first argument if it is not sorted, and otherwise returns the second |
| Clexico_compare | Work function which implements a lexicographical ordering based on the provided functor |
| Clexico_reduce | Work function which returns the second argument if the first compares equal to 0, and the first otherwise |
| Cmax_element_reduce | Work function which reduces two pairs of index and values, selecting the pair with maximum value |
| Cmerge_map | Work function which merges the two input views into the output view |
| Cmerge_output_indices | Compute the index of the nth element of the provided view |
| Cmerge_output_sizes | Work function which sets the third argument equal to the sums of the sizes of the two input views |
| Cmerge_send_leader | Work function which takes an input map and sets the given key equal to the given value |
| Cmerge_splitters | Work function which merges two local splitters into the global set of splitters |
| Cmin_element_reduce | Work function which reduces two pairs of index and values, selecting the pair with minimumvalue |
| Cminmax_element_reduce | Work function which reduces inputs to select min and max values from ranges and their corresponding indices |
| Crange_adjacent_find | Work function invokes sequential (i.e., STL) adjacent_find |
| Crange_all_of | Work function invokes sequential (i.e., STL) all_of |
| Crange_any_of | Work function invokes sequential (i.e., STL) any_of |
| Crange_count_if | Work function invokes sequential (i.e., STL) count_if |
| Crange_equal | Work function invokes sequential (i.e., STL) equal |
| Crange_equal_range | Work function for equal_range() which returns the position of its argument if the argument compares equal to the given value according to the given ordering, or null_reference position otherwise |
| Crange_find | Work function invokes sequential (i.e., STL) find |
| Crange_find_end | Work function invokes sequential (i.e., STL) find_end |
| Crange_find_first_of | Work function invokes sequential (i.e., STL) find_first_of |
| Crange_lower_bound | Work function for lower_bound(), which takes a view over a sorted input, and computes the std::lower_bound on it, or null_reference if the range is all less than the given value |
| Crange_max_element | Work function invokes sequential (i.e., STL) max_element, returning the index and value of the corresponding element |
| Crange_min_element | Work function invokes sequential (i.e., STL) min_element, returning the index and value of the corresponding element |
| Crange_minmax_element | Work function invokes sequential (i.e., STL) minmax_element. returning the index and value of both corresponding elements |
| Crange_mismatch | Work function invokes sequential (i.e., STL) mismatch |
| Crange_none_of | Work function invokes sequential (i.e., STL) none_of |
| Crange_search | Work function invokes sequential (i.e., STL) search |
| Crange_search_n | Work function invokes sequential (i.e., STL) search_n. Returns information about matches found in the range as well as partial matches found at the front and back of the range |
| Csearch_n_reduce_wf | Reduction work function for search_n which synthesizes the the lhs and rhs full and partial match information |
| Cupper_bound_map_wf | Work function for upper_bound(), which takes a view over a sorted input, and computes the std::upper_bound on it, or null_reference if the range is all less than or equal to the given value |
| Cwt_inner_product_map_wf | Work function that implements the weighted product operation used in weighted_inner_product |
| ►Narray_impl | |
| Ccompute_array_traits | Metafunction to compute traits class for array container. For primary template, some optional parameters are defined, but no customized traits. Use array_traits |
| Ccompute_array_traits< T > | Specialization when none of the optional parameters are provided at template instantiation. Use array_traits, with default partition and mapper argument types |
| Ccompute_array_traits< T, Partition, Mapper, Traits > | Specialization when traits is actually passed at class |
| ►Nbc_algo_detail | |
| Capply_delta_wf | Workfunction to calculate delta |
| Cbc_mssp_wf | Workfunction to calculate the sigma values for active sources and builds bfs dags |
| Cdependency_wf | "Reverse" BFS that calculates betweenness centrality value of each vertex using sigma and delta values of current and child vertices |
| Cmap_init | Initializes vertex properties and allocates memory for the number of sources to calculate per iteration |
| Cmap_resources | Resets the calculations made for previous sources and sets sources in the range [begin, end) as active |
| Cupdate_func | Update function for bc_mssp_wf. Calculates the sigma values for active sources |
| ►Nbc_base_impl | |
| Ccleanup_elements | Called in destructor of a base container to destroy heap-allocated value held by container_wrapper_ref, if the value type of the base container is a nested container |
| Ccleanup_map_elements | Called in destructor of map_base_container to destroy heap value held by container_wrapper_ref, if the value type of the base container is a nested container |
| Cconstruct_vbdist_element | Called to conditionally wrap a nested container construction that accepts a distribution specification with container_wrapper_ref for the map_base_container |
| Cconstruct_vbdist_element< Value, true, false > | Specialization used when the map value is a container, but the container does not use a viewbased distribution |
| Cconstruct_vbdist_element< Value, true, true > | Specialization used when the map value is a container with a view-based distribution |
| Cdefault_construct_element | Called to conditionally wrap nested container default construction with container_wrapper_ref for the map_base_container |
| Cincrement_ref | Increments value of member reference whenever function operator is called, ignoring passed future parameter |
| Cis_vbdist_container | Helper functor to identify container instances that have viewbased distributions |
| ►Nbfs_algo_detail | |
| Cbfs_init_wf | Vertex-initializer functor for breadth_first_search() |
| Cbfs_map_wf | Work-function for breadth_first_search(). A vertex is visited if it is active (the level on the vertex matches the current level of the paradigm. Active vertices update their neighbors with new BFS level and parent information. Returns true if vertex was active, false otherwise |
| Cupdate_func | Visitor functor for breadth_first_search() |
| Cvp_reducer | Reducer functor for breadth_first_search() |
| ►Ncc_algo_detail | |
| Ccc_map_wf | Work-function for computing connected-component IDs for each vertex |
| Cextract_cc_stats_wf | Work-function to extract the vertices belonging to a given CCID |
| Cextract_graph_cc_stats_wf | Work-function to extract the different CCs and count the vertices belonging to them |
| Cinit_cc_wf | Work-function to initialize each vertex's CCID to its own descriptor |
| Creduce_cc_stats_wf | Work-function to combine two input maps by adding their valid elements |
| Cupdate_func | Functor to update neighbor vertices with CCID information |
| Cvp_reducer | Reducer functor for connected_components() |
| ►Ncm_impl | |
| ►Ndetail | |
| Cmulti_identity_mapping_function | A mapping function used as an identity for GIDs |
| Cmulti_offset_mapping_function | A mapping function used to transform a GID by adding the starting GID of its base container |
| Cbc_min_max | Work function implementing the traversal of a tuple to compare each element against known min and max values |
| Ccombine_partition_info | Work function used to merge the partial partition information from two locations when the number of locations is not a power of two |
| Cconstruct_bc_with_dom | Functor implementing the construction of base containers using the domain of GIDs and component id provided |
| Cdistributor | Distributed object that implements the transfer of elements between locations that is performed during container redistribution |
| Cdistributor< std::map< RangeSet, BaseContainer * >, PartitionInfo, ElemAssign, BaseContainerFactory > | Distributed object that implements the transfer of elements between locations that is performed during container redistribution |
| Cdistributor< std::vector< BaseContainer >, PartitionInfo, ElemAssign, BaseContainerFactory > | Distributed object that implements the transfer of elements between locations that is performed during container redistribution |
| ►Cdistributor_base | Common data members and methods of the distributed objects that implement the transfer of elements between locations during container redistribution |
| Ccid_eq | Functor used to find the base container information of the cid provided |
| Cget_second | Helper class used to retrieve the second element from a pair |
| Cloc_and_part_id_less | Comparator used to sort partial domain information in ascending order of location id and then partition id |
| Cloc_equal | Comparator used to find partition information elements for a specific location id |
| Cmerge_partial_info_helper | Helper struct to merge two tuples representing partial partition information together |
| Cmerge_partition_info | Work function passed to butterfly to construct a PARAGRAPH that takes the partial partition information from each location, merges it with the others, and in the end places the partition information for a given location on that location |
| Cmin_max_interval | Basic implementation of a multidimensional interval |
| Cmulti_bitmap_gid_set | A set of GIDs (stored as bitsets), where GIDs can be stored across multiple base containers |
| Cmulti_gid_set | A set of GIDs, where GIDs can be stored across multiple base containers |
| Cmulti_gid_set_iterator | Iterator for the multi_gid_set, that traverses all elements in the GID set and produces local references |
| Cmulti_implied_gid_set | A set of GIDs, where every element in every base container managedy by a container manager is considered part of the set |
| Cmulti_implied_gid_set_iterator | A hierarchical iterator that traverses all elements in the base containers managed by a container manager |
| Cpart_loc_neq | Comparator used to identify adjacent elements in the vector of partition information that belong to different locations |
| Cset_element_assign | Functor implementing assignment of a base container element using the base container's set_element method |
| Csingle_bitmap_gid_set | A set of GIDs represented as a bitset, where all GIDs are in the same base container |
| Csingle_gid_set | A set of GIDs, where all GIDs are in the same base container |
| Csingle_gid_set_iterator | Iterator for the single_gid_set, that traverses all elements in the GID set and produces local references |
| Csingle_implied_gid_set | A set of GIDs, where every element in the registry is considered in the set |
| Csplit_partition_info | Work function used to split the final partition information for two locations when the number of locations is not a power of two |
| Cvp_assign | Functor implementing the assignment of vertices of a base container using the base container's add_element method |
| ►Ncoarsen_partition_impl | |
| Cbuild_combined_metadata | Function object that receives a set of 1D domains and builds a multidimensional domain by combining their firsts and lasts |
| Ccoarsen_partition | Helper functor used to coarsen metadata based on locality for the given view |
| Cconstruct_domain | Helper struct that allows for the construction of a domain given the first and last indices and the view container to be specialized |
| Cconstruct_domain< domainset1D< Distribution > > | Specialization of domain construction for domainset1D |
| Cconstruct_domain< domset1D< T > > | Specialization of domain construction for domset1D |
| Cconstruct_domain< implicit_regular_mesh_domain< Coordinates, Traversal > > | Specialization of domain construction for implicit_regular_mesh_domain |
| Cconstruct_domain< iterator_domain< DomainContainer, Functor > > | Specialization of domain construction for iterator_domain |
| Cprojection_construct_domain | Helper struct used to construct a domain in the projection process |
| Cprojection_construct_domain< domainset1D< Distribution > > | Helper struct used to construct a domain in the projection process when domainset1D is involved |
| Cprojection_construct_domain< domset1D< T > > | Helper struct used to construct a domain in the projection process when domset1D is involved |
| Cprojection_construct_domain< iterator_domain< DomainContainer, Functor > > | Helper template to correctly construct domain in projection process when iterator_domain is involved |
| ►Ncomposition | |
| ►Nresult_of | |
| Cmap_func | Reflect return type of map_func passed workfunction MapWF and a variable number of views |
| Cmap_func< binder1st< Operation, Stored, true >, V0 > | Reflect return type of map_func specialization when unary workfunction is an instantiation of the binder1st class template |
| Cmap_func< binder2nd< Operation, Stored, false >, V0 > | Reflect return type of map_func specialization when unary workfunction is an instantiation of the binder2nd class template |
| Cmap_func< prototype::functional::inner_product, V0, V1 > | Reflect return type of map_func specialization when workfunction is prototype::functional::inner_product |
| ►Cblock_matvec_wf | A coarsened workfunction for matrix vector multiplication that operates on a block of a two dimensional matrix and the vector portion corresponding to it |
| Cresult | Nested struct which reflects the return type of the function operator based on the types of the input views |
| Ccm_res_view | Used as the return value for coarse_map_wf. Implements concept of Array |
| ►Ccoarse_map_wf | The default coarsened workfunction uses iterators to apply the elementary workfunction to each element in coarsened view passed to it |
| Cresult | Reflect the return type of the function operator, a view whose type is an instance of cm_res_view, backed by an instance of class template my_container |
| Ccomponent_holder | Implements required interface of the old views to provide a components class with the method get_id |
| Cdelete_disposer | Function object implementing the disposer concept defined by Boost.Intrusive. Function operator signatures restricted to |
| Cfind_result_storage | Attempts to transparently reuse the underlying storage of a workfunction's input views (when they are not mutated). Enables a functional programming model, while avoiding the heap allocation and locality loss drawbacks often associated with this model |
| Cget_element_func | Function object which returns the application of operator[] on the input parameter, passing a data member as the index argument |
| Cholder_recycler | List of buffers previously used by instances of ref_cnt_elem_holder maintained in place of deletion to allow reuse by future ref_cnt_elem_holder objects |
| ►Cm_mr_transform_wf | Workfunction that is one possible algorithmic coarsening of the nested skeleton map_func(functional::map_reduce(), ...) |
| Cmap_wf | Coarsened binary workfunction which is map operator for m_mr_transform_wf |
| Creduce_wf | Coarsened binary reduction workfunction defined for result type of map_wf |
| ►Cmap_factory | Factory implementing functional version of map_func which returns a view over the result of the mapping function applied to all elements. The input views are not mutated |
| Cresult | Reflect return type of map_factory. Passed view list in Signature which includes the arguments to function operator |
| Cmap_subview | Returned by map_view as index into a coarsened portion of return value it represents. Typically is all the elements on a given location. Used to facilitate inter-PARAGRAPH data flow |
| Cmap_view | A view that is the result of the functional map operation map_func |
| Cmy_container | Used in conjunction with mpi_messager to implement RDMA style transmission of edge_container values. Used to back edge values of type cm_res_view |
| Cnest_map_mr_factory | Customized implementation of a map_func(map_reduce()...) skeleton that is used for matrix vector multiplication |
| Cnest_map_mr_task_mapper | Custom key mapper passed to the Directory when using the nest_map_mr_factory factory within a PARAGRAPH |
| Cref_cnt_elem_holder | Class used to manage underlying storage for views of coarse_map_reduce |
| Crepeat_view | Defines a one dimensional view where every element is a light wrapper around a copy of the underlying view of type View |
| ►Csimple_wf | Workfunction that receives a view and returns it. Effectively an identify functor |
| Cresult | Nested struct that reflects return type of function operator invocation |
| ►Ndetail | |
| Cadvance_apply | Function object that advances an iterator a given number of times and applies a higher-order function to the result of dereferencing that iterator |
| Cadvance_apply_get | Function object that advances an iterator a given number of times and returns the result of applying a higher-order function to the dereferenced value of that iterator |
| Cadvance_inner | Function object that advances an iterator a given number of times |
| Capply_divide | Divides a given number by all of the elements of a tuple |
| Capply_divide<-1 > | Base case apply_divide |
| Capply_get_helper | Functor which stores a pointer to member function and corresponding arguments, making the invocation on an object passed to it when called. Handles non-void returning, mutating invocations for accessor_base, avoiding compilation overhead of lambda + bind operation |
| Capply_get_wrapper | Helper functor for container_accessor::apply_get which facilitates asynchronous return of Functor invocation via a promise to the initiating location. Properly packages views for serialization if necessary |
| Capply_modulo | Computes the modulus of a 1-dimensional number with the linear size of all of the dimensions before the current dimension N |
| Capply_modulo< 0 > | Base case apply_modulo |
| Capply_set_helper | Functor which stores a pointer to member function and corresponding arguments, making the invocation on an object passed to it when called. Handles void returning invocations for accessor_base, avoiding compilation overhead of lambda + bind operation |
| Cas_reference_impl | Helper for extracting a reference from a local accssor |
| Cas_reference_impl< local_accessor< C > > | Specialization for local accessor |
| Cas_reference_impl< local_accessor_graph< C > > | Specialization for the graph's local accessor |
| Cassign_val | Class for assigning value to a reference |
| Cbasic_counter_notifier | Defines a counter for notifications, forwarding the notification signal when N notifications are received |
| Cbasic_edge_entry | Minimal entry class used when edge initialized without an edge_container |
| Cbinary_negate_helper | Base class for binary_negate the reflects the type first_argument_type and second_argument_type if they are defined in the template. It's assumed that the two argument type parameters either both exist or both do not, so we only check for first_argument_type |
| Cbinary_tm_accessor | Accessor to defer the application of a given binary Functor until the evaluation is required |
| Ccheck_localizable | Type metafunction reflecting std::true_type if a view has chosen to disable localization and std::false_type otherwise |
| Ccheck_localizable< View, true > | |
| Ccomp_spec_ptr | Wrapper for a composed distribution specification. This struct is used when a nested container is being created on a lower level of the system. It is passed into the communication group for the container and restores the pointer to the composed distribution specification. This is needed because the runtime currently does not support sending p_object instances between locations |
| Ccompare_req | Unary functor to compare the return value of any object's request method with a given edge_request_type variable.Used to search versions list in edge_entry |
| Ccompare_type_parameters | Helper metafunction used by compute_type_parameters to delay the invocation of the type transformation metafunction call until OptionalParams padded with use_default types at the end if needed |
| Ccompute_edge_request_type | Template metafunction reflecting edge_request_type value associated with the specified filter type |
| Ccompute_edge_request_type< df_identity< T > > | Specialization for df_identity<T>. Reflect FULL request type |
| Ccompute_edge_request_type< df_null_functor< T > > | Specialization for df_null_functor<T>. Reflect SIGNAL request type |
| Ccompute_edge_view_filter | Type metafunction to extract optional filter parameter from variadic type parameter pack if specified, otherwise, use df_identity. Also reflect the value_type the edge view refers to, after applying the filter to the edge value |
| Ccompute_first_gid | Use domain within specified object to find first index unless passed an std::vector or immutable_range_wrapper |
| Ccompute_invoked_wf | Metafunction that inserts a const qualification on the workfunction if persistency mode in the PARAGRAPH is enabled |
| Ccompute_invoked_wf< WF, true > | Specialization when b_persistent == true. Reflect WF with const qualification added (if not already present) |
| Ccompute_mixed_viewset | Helper struct that computes the type of the tuple used to store views. The type of view in each tuple element varies based on whether the view is local or not |
| Ccompute_mixed_viewset< 2, FastVec, View0, View1 > | Specialization for the case where there are two views in the PARAGRAPH |
| Ccompute_mixed_viewset< 3, FastVec, View0, View1, View2 > | Specialization for the case where there are three views in the PARAGRAPH |
| Ccompute_plane_sizes | Computes the factor by which a component of an n-dimensional GID should be multiplied when linearizing the GID |
| Ccompute_plane_sizes< 0, 0 > | Specialization for the 1-D case |
| Ccompute_plane_sizes< 0, LastIdx > | Specialization for first iteration of compute_plane_sizes |
| Ccompute_plane_sizes< LastIdx, LastIdx > | Specialization for final iteration of compute_plane_sizes |
| Ccompute_task_view_storage | Type metafunction to compute the storage class template used by a task in the paragraph |
| Ccompute_task_view_storage< Fast, false, FastVec, Views... > | Specialization used for tasks when localization is performed and migration support is disabled |
| Ccompute_task_view_storage< Fast, true, FastVec, Views... > | Specialization used for tasks when localization is performed and migration support is enabled |
| Ccompute_task_view_storage< Mixed, false, FastVec, Views... > | Specialization used for tasks when localization may be performed and migration support is disabled |
| Ccompute_task_view_storage< Mixed, true, FastVec, Views... > | Specialization used for tasks when localization may be performed and migration support is enabled |
| Ccompute_task_view_storage< Standard, Migratable, FastVec, Views... > | Specialization used for tasks when no localization is performed. Only store one copy of original views |
| Cconditional_multiply | Small function to optimize index linearization by not performing multiplication on the first element |
| Cconditional_multiply< 0 > | Specialization for first element of tuple. Do not perform multiplication and assert the first element in plane_sizes is 1 |
| Cconforms_to | Metafunction that determines if a a choice (tuple of types) conforms to an option, which may or may not contain don't cares |
| Cconst_apply_get_helper | Functor which stores a pointer to member function and corresponding arguments, making the invocation on an object passed to it when called. Handles non-void returning, non-mutating invocations for accessor_base, avoiding compilation overhead of lambda + bind operation |
| Cconst_index_accessor | Accessor used to access the element referenced for the given index in the specified view |
| Cconst_index_accessor< graph_view< PG, Dom, MapFunc, Derived > > | Specialization of index_accessor for graph_view |
| Cconst_index_accessor< hgraph_view< PG, Dom, MapFunc, Derived > > | Specialization of const_index_accessor for hgraph_view |
| Cconst_iterator_selector | Helper function to determine the type of iterator to use based on the View type and its value type T |
| Cconst_view_iterator | Definition of read only iterator used for the segmented_view View |
| Ccontainer_impl | Base class of containers that implements functionality that is independent of whether nested container composition exists (mainly distribution related functionality). boost::shared_ptr is being used in place of std::shared_ptr in order to minimize the number of conflicts caused by ADL. Performance was shown to be comparable |
| Ccontainer_make_reference | Static functor calling make reference if view container type is not a proxy to std::vector. Otherwise, call operator[] |
| Ccontainer_make_reference< proxy< lightweight_vector< T >, A > > | Specialization of make_referene for the cases that the underlying container is a proxy of a lightweight_vector |
| Ccounter_based_terminator | Custom PARAGRAPH termination detection which signals termination after a predefined number of invocations of the receive_notify method |
| Ccounter_receive_notify_callback | Notifier used by custom termination detection for composition::nest_map_mr_factory |
| Ccreate_task_impl | Called after a tasks' views have been created to make the task object. Statically guards localization with is_localizable< metafunction |
| Ccross_map_impl | Helper struct for cross_map which builds the cross product of arguments to pass to the function |
| Ccross_tg_notifier | Function object that delays the execution of a PARAGRAPH, pending notification from predecessor PARAGRAPHs who compute values that the successor receives as view inputs.Allows initialization of PARAGRAPH (and perhaps some task initialization to proceed concurrently with predecessor PARAGRAPH execution |
| Cdefault_key_mapper | Define default key to location mapping strategy used in the directory class used by containers and the PARAGRAPH |
| Cdefault_nested_initializer | Function object called by a container whose value type is another container to properly populate the former's base container |
| Cdetermine_num_locations | Functor with partial specialization to get num_locations for containers that aren't p_objects |
| Cdetermine_rmi_handle | Functor with partial specialization to get an rmi_handle for containers that aren't p_objects |
| Cdf_identity | Filtering function object associated internally in the edge_container implementation for edges representing FULL consumption a producer task's value by the successor. Hence it is an identity filter, returning the full value passed to it |
| Cdf_null_functor | Filtering function object associated internally in the edge_container implementation for edges representing only a SIGNAL (i.e., an explicit predecessor passed to paragraph_view::add_task.To unify the implementation, the function operand returns full value passed to it, but this is not made available to the predecessor task |
| Cdirectory_base | Base class of Directory that provides the bulk of the non migration specific implementation |
| Cdirectory_registry_iterator | Custom iterator for directory_registry, returned to callers of find method |
| Cdirectory_request | Derived class of directory_request_base which holds function object associated with request and also defines the pointer to member method of the directory which will be used to service this request |
| Cdirectory_request_base | Abstract base representing encapsulation of a buffered directory request which must be buffered at location managing a given key, pending key registration |
| Cdiscard_from_sequence | Metafunction to call tuple_ops::heterogeneous_discard multiple times based on Slices from an index_sequence |
| Cdiscard_from_sequence_impl | Metafunction to recursively call tuple_ops::heterogeneous_discard |
| Cdiscard_from_sequence_impl< SlicesSize, SlicesSize, Slices, Tuple > | Metafunction to recursively call tuple_ops::heterogeneous_discard |
| Cdo_once_impl | Helper struct for do_once which uses partial specialization to dispatch to correct implementation for void and non-void return types of F |
| Cdomain_intersection | Helper functor to compute the intersection between two given domains (d0 and d1) |
| Cedge_entry | The primary storage class for dependence and data flow values in the PARAGRAPH. One instance of this class or the base class edge_entry_base exists for each producer task, both on the location where it executes as well as on all locations with active consumers |
| Cedge_entry_base | The stored element type of edge_container. One instance of this class or a derived class exists for each producer task, both on the location where it executes as well as on all locations with active consumers |
| Cedge_entry_wrapper | Provides trivial iterator interface to an edge_entry pointer and avoids serialization of object. Used in data flow fire (edge_container::receive_value) to elide relookup in value cache |
| Cedge_info_holder | Encapsulates access to edge entry and version storage objects for PARAGRAPH, to be used for out edge paragraph data flow optimizations (e.g., zero copy). Empty class if result type is void |
| Cedge_local_notifier | Derived class of edge_local_notifier_base that holds notifier counters, associated task and metadata for scheduling. Type is erased immediately after construction in task_graph_impl::add_task |
| Cedge_local_notifier_base | Represents the primary interface through which users of the edge_container or edge_view (i.e., task_graph) are informed of data flow events triggered by the completion of predecessor tasks.Instances of this class are heap allocated and passed to the edge_container when successor tasks create an edge via edge_view::setup_flow. When data flow is available for a successor, the edge_container will invoke this object's function operator, once per specified predecessor. When all notifications have been received, this object passes the successor task to the PARAGRAPH's executor, making it eligible for execution |
| Cedge_notifier_wrapper | Wrap remote edge notifier objects to support moving them to a new location when the associated producer task is migrated |
| Cedge_notifier_wrapper< void, Notifier > | Specialization for signal (i.e., void) consumption. Avoid move and sharing related logic |
| Cedge_remote_notifier | Notifier passed to a producer location to notify a remote location with only partial (filtered) or full value consumers |
| Cedge_remote_signal_notifier | Notifier passed to a producer location to notify a remote location with only signal consumers |
| Cedge_storage | Manages storage of edges of the edge_container |
| Cedge_target_comp | Comparator for testing < of two edge targets |
| Cedge_target_equal | Comparator for testing if two edges point to the same target |
| Cedge_target_location_comp | Comparator for sorting edges based on target's home location |
| Cedge_version_entry | Version notifier list used for FULL value edge consumption |
| Cedge_version_entry< void, Notifier, Hook > | Specialization of basic version notifier list for signals |
| Cedge_version_entry_base | Define basic interface that all edge value versions should implement. The stored type of the versions lists stored by edge_entry |
| Cedge_version_storage | Storage class for all edge flowed values that abstracts how access to the value is provided |
| Cedge_version_storage< void > | Specialization for signal / void edge flow. Maintain convention of treating it internally as an int |
| Cedges_to_adjacency_list | Work function to convert a sequence of edges to a local adjacency list representation |
| Celement_ref_cache | Caches a pointer to the value referred to by a container_accessor when the value type is a nested container. Otherwise, it's an empty class |
| Centry_compare | Comparator required by methods of Boost.Intrusive unordered_set to search for elements. Allows lookups based on the edge entry's task identifier field |
| Centry_disposer | Function object implementing the disposer concept defined by Boost.Intrusive |
| Centry_storage_access | Lazily provides access to the edge_version_storage associated with an edge version entry if desired by another version entry |
| Centry_value_access | Lazily provides access to the value in an edge version entry's underlying storage if desired by another version entry |
| Cephemeral_pg | Conditional base class of task_graph_impl used for PARAGRAPHs that destroy themselves incrementally as they execute |
| Cextract_domain | Helper functor to extract the domain associated with the given container |
| Cextract_domain< Container, false > | Helper functor to extract the domain associated with the given container |
| Cextract_domain< std::list< T >, false > | Helper functor to extract the domain associated with the given container |
| Cextract_domain< std::string, false > | Helper functor to extract the domain associated with the given container |
| Cextract_domain< std::vector< T >, false > | Helper functor to extract the domain associated with the given container |
| Cextract_property_apply | Class for extracting a property from a vertex reference and applying the functor to it |
| Cextract_value_ref_mf | Metafunction that extracts a reference to the user level value that was stored in the edge_container.Used to unwrap proxies held in proxy_holder objects |
| Cextract_value_ref_mf< proxy< T, A > > | Specialization for edge views without a filtering function whose edge type is a proxy |
| Cfast_mg_storage | View Storage used for tasks when localization is performed and migration is enabled. Store both original and localized views |
| Cfast_no_mg_storage | View storage used for tasks when localization is performed and migration is disabled. Only store the localized views |
| Cfast_view_builder | Helper class used to cast given view instance to one over the provided base container instance |
| Cfast_view_builder< BaseContainer, false, false > | Terminator of the recursive fast_view_builder instantiation when the bottom-most container of the original view has been hit |
| Cfast_view_builder< CastView, true, false > | Helper class used to cast given view instance to one over the provided base container instance |
| Cfill_edge | Function object that performs a deep copy of input view into a std::vector and returns this container.Class is used as workfunction in colocation factory below to migrate a copy of a read only array_view via the edge_container to the location where task using the data will be executed to avoid remote element fetches |
| Cfiltered_edge_version_entry | Derived class of filtered version which stored Filter and implemented methods requiring this type |
| Cfiltered_edge_version_entry_base | Abstract base class template of filtered_edge_version_entry used to store entries in filtered_edge_versions. Allow state querying and full value based edge flow to be performed without having to know the type of the filtered edge |
| Cfiltered_edge_versions | Represents a list of versions, each of which represents a filtered edge consumption with a different filter |
| Cfind_first_index_impl | Helper function to find the first item in a given tuple that satisfies a given predicate |
| Cfind_first_index_impl< Items, Predicate, index, 0, Arg... > | The base case for find_first_index_impl |
| Cget_const_iterator | Helper to return the const_iterator type provided for the View's container |
| Cget_iterator | Helper to return the iterator type provided for the View's container |
| Cget_nested_initializer_type | Metafunction that returns reflected nested_initializer_type if the specified container Traits reflects a typedef. Otherwise, return default value (default_nested_initializer) |
| Cget_nested_stored_value_type | Metafunction that returns reflected nested_stored_value_type if the specified container Traits a typedef exists. Otherwise, return default value (Traits::value_type) |
| Cget_second_deref | Helper class used to retrieve the second element from a pair with operator* applied |
| Cglobal_member_iterator | Defines an iterator used to reference data member elements through a parent accessor |
| Cgraph_distribution_base | Base distribution class for the graph containers |
| Cgraph_nested_initializer | Function object called by a container whose value type is another container to properly populate the former's base container |
| Chas_edge_helper | Helper functor that is invoked on the source vertex location to set the promise to the correct value for has_edge |
| Chas_same_domain | Metafunction to determine if an object has a nested trait inverse |
| Chas_set_elements | Metafunction to check whether given view parameter has a set_elements() method, by inspecting the reflected type |
| Chash_buckets | Holds bucket count and array of buckets for hashtable used in edge_storage (and eventually by edge_container). Encapsulated here to properly manage lifetime, so that buckets are destroyed after the Boost.Intrusive unordered_set they serve |
| Chome_storage | Derived class instantiated by registry to hold an instance of the manager. Implements virtual methods for lookup and partition & mapper resets |
| Chome_storage_base | Abstract base class, a pointer of which is held in a registry object, allowing it to interact with a home manager object without knowing its concrete type, just it's gid / key type |
| Chome_storage_intermediate | Intermediate base class of home_storage which encodes the type of the partition and mapper. Allows us to support quasi-virtual member template call |
| Cindex_accessor | Accessor used to access the element referenced for the given index in the specified view |
| Cindex_accessor< graph_view< PG, Dom, MapFunc, Derived > > | Specialization of index_accessor for graph_view |
| Cindex_accessor< hgraph_view< PG, Dom, MapFunc, Derived > > | Specialization of index_accessor for hgraph_view |
| Cindices_of_most_significant< Slices, Traversal, index_sequence< Indices... > > | Metafunction to compute the reordering of a Slices tuple (as a tuple of indices) in descending order of Traversal's most significant (slowest moving) dimensions |
| Cintrusive_notifier_list | Encapsulate notifier list behavior used by result_container. Namely two interfaces: one to add a new notifier to a list and another to invoke all notifiers, delete them, and empty the list |
| Cis_localizable | Recursive type metafunction which returns false if any of the views in the parameter pack have disabled localization |
| Citerator_selector | Helper function to determine the type of iterator to use based on the View type and its value type T |
| Ckba_identity | Functor returning the element passed in constructor |
| Clocalized_member_iterator | Defines an iterator used to reference data member elements directly through a pointer |
| Clocalizer | Function object that returns true if localization type transformation (i.e., fast_view_type) is safe to apply |
| Clocalizer< proxy< T, Accessor >, false > | Specialization matches proxies and redirects is_local queries to the underlying accessor |
| Clocalizer< T, false > | Specialization matches non proxies or view types. Return true |
| Clocation_0_placement_policy | Trivial task placement policy used by serial_io that forces all tasks to run on location 0 |
| Clocation_storage | Storage location for remote_notifier class, mainly so that remote_edge_version_entry can access this information for assertion in a type erased (i.e., lighter compile time) manner |
| Cmake_iterator | Helper functor to construct an iterator base on the View type and the Iterator type expected |
| Cmake_reference | Helper function to construct a reference to the element of given view at given position |
| Cmapfun_comp | Generic composition of two mapping functions |
| Cmerge_adjacencies | Butterfly work function to merge adjacency lists together and filter out only the subset of vertices that is pertinent for this level of the butterfly |
| Cmesh_identity | Functor returning the element passed in constructor |
| Cmetadata_functor | Functor invocation used to invoke defer_metadata_at on a distribution via forwarding in the Directory |
| Cmigratable_base | Class used by detail::directory_base to verify a key is still registered on a location when migration is enabled (it's possible key has moved while this request was in flight) |
| Cmixed_mg_storage | View Storage used for tasks when per-view localization is performed and migration is enabled. Store both original and localized views |
| Cmixed_no_mg_storage | View storage used for tasks when per-view localization is performed and migration is disabled. Only store the transformed views |
| Cnc_detect_pobject | Type checker to determine if T is a p_object, query it about whether nested_construction occurred. Otherwise, return false |
| Cnc_detect_type | Type checker to determine if T is a nested construct or not |
| Cnc_detect_type< proxy< T, A >, b_is_view > | Specialization for proxies |
| Cnc_detect_type< T, true > | Specialization for views |
| Cnon_migratable_base | Trivial class used to unconditionally signal certainty about presence of key on a location when migration is disabled |
| Cnotifier_entry | An entry in the notification list held by notifier_list. Inherit the Notifier function operator, add Hook for storage in a Boost.Intrusive container, and define pool allocation usage via STAPL_USE_MANAGED_ALLOC |
| Cnotifier_entry_disposer | Function object implementing the disposer concept defined by Boost.Intrusive.Intrusive containers do not manage the lifetime of the objects they contain. This is left to the container's user to manage. The disposer callback functor allows the user to do this during container operations where object deletion may be desired (i.e., clear()). In the version context, this disposer is a simple delete call |
| Cnotifier_invoker | Notifier invoker passed by edge_version_entry to notifier_list base class |
| Cnotifier_list | Provides storage for notifiers associated with a edge version of a task. Defines operations to add a new notifier and flush (i.e., invoke) notifiers when the corresponding data flow is triggered |
| Cnotifier_list_base | Base class of notifier_list which holds data members and operation not dependent on template parameters (avoid code bloat) |
| Cnotifier_loc_compare | Compares location member to remote_notifier base class location_storage (assertion purposes) |
| Cnotifier_void_invoker | Notifier invoker passed by edge_version_entry (void value specialization) to notifier_list base class |
| Cone_sided_wait_td_notifier | Event handler which receives signals from inter-paragraph data flow and termination detection and waits until both are received before calling a notifier which informs the parent paragraph that this one-sided initialized child paragraph has completed and provides the corresponding dataflow |
| Cone_sided_wait_td_notifier< void > | Specialization of class for paragraphs with void return type. In this case, there is no inter paragraph dataflow to hold. Notification is hooked directly into termination detection |
| Cpair_compare | Returns if the first element of the left std::pair is less than the first element of the second std::pair |
| Cpair_compare_loc | Returns if the second element of the stored std::pair is equal to the second element of the given std::pair |
| Cpartition_base | Base class for partitions that encapsulates the logic needed to determine if shifting can be used in place of division to map a GID to a partition id |
| Cpartitioned_view_selector | Functor returning the partitioned mix view appropriate for given input view |
| Cpartitioned_view_selector< partitioned_mix_view< View, Part, CC >, Part > | Functor returning the partitioned mix view appropriate for given input view |
| Cpersistent_pg | Conditional base class of task_graph_impl that maintains all tasks and edges persistent in memory after one execution so that it can be reused |
| Cpointer_accessor | Defines an accessor to local element using an iterator to reference it |
| Cprocessor_map_2D | Function object to generate neighbors of a location id in a 2D space |
| Cregister_vote | Returns the preferred location for a task to run |
| Cremote_edge_version_entry | Maintains list of edge notifications for locations with remote consumers |
| Cremote_notifier | Wraps notifier passed to edge_entry. Provides storage and access method for the location associated with the base remote notifier |
| Cremote_notifier_invoker | Notifier invoker passed by remote_edge_version_entry to notifier_list base class |
| Cremote_notifier_migrator | Function object encapsulating notifier migration request passed through the Directory |
| Cremote_pointer_accessor | Defines an accessor to a pointer on a remote location using an iterator to reference it |
| Cremote_task_metadata | Class containing everything needed to callback to PARAGRAPH outside its communication group and notify it that a task has completed |
| Creorder_localize_linearize | Reorders input Indices according to provided traversal order, decrements each by corresponding value in first and then multiplies by corresponding value in plane_sizes, accumulating the results into a linearized index |
| Creorder_localize_linearize< LastIdx, LastIdx, Traversal > | Base case of the recursion |
| Crequest_queue | Basic request queue used by the Directory to buffer pending messages to an unregistered key. Includes functionality to guard against re-entrant, duplicated traversals of the structure |
| Cresult_container | This object is allocated on each location of a PARAGRAPH as storage for that location's return value of the PARAGRAPH. The key feature is that its lifetime can extend beyond the PARAGRAPH itself and is driven by the return value's use by other computation |
| Cresult_container_base | Base class used to allow PARAGRAPH class hierarchy to provide access to result_container where the result type is erased |
| Cresult_ct_parent_notifier | Notifier used in result_container for a consumer PARAGRAPH who is the parent of producer (i.e., output port to output port dataflow). Holds various filters and mappers used to guide the dataflow process |
| Cresult_ct_sibling_notifier | Notifier used in result_container for a consumer PARAGRAPH at the same level of nesting as the producer. Holds various filters and mappers used to guide the dataflow process |
| Cresult_manager | This class is used internally by the PARAGRAPH to manage the setup of storage for the PARAGRAPH's result as well as setting up the notification flow from the internal task on each location in the PARAGRAPH gang |
| Cresult_manager< void, false > | Specialization for PARAGRAPH's with a void return value |
| Cresult_value_storage_entry | Storage class for buffering value in the result_container when there are still unspecified consumers |
| Cresult_view | Models array_view concept over the result_container of a PARAGRAPH. The result container is held by pointer whose lifetime is managed among instances of this class via reference counting |
| Creturn_handle | Functor calling get_rmi_handle on any object passed to it |
| Creverse_linearize | Translates a 1-dimensional linearization back to its n-dimensional form |
| Creverse_linearize<-1, GID > | Base case of recursion for reverse_linearize |
| Creverse_traversal_order | Rearrange the contents of a tuple to be in the reverse traversal order |
| Cscoped_drain_call | Use RAII to conditionally invoke a executor drain after the body of paragraph::operator() |
| Cslice_result | Type metafunction reflecting the reduced rank linearizer that a slice operation returns |
| Cstd_storage | View Storage used for tasks when localization is not performed |
| Cstrip_comp_spec_ptr | Helper struct to remove the comp_spec_ptr type from the composed distribution specification. This allows the comp_spec_ptr to be used without all containers providing a constructor to accept it |
| Cstrip_fast_view | Computes the type of the view underlying an nfast_view instance |
| Cstrip_mix_view | Computes the type of the view underlying a mix_view instance |
| Cstrip_repeat_view | Computes the type of the view underlying an repeat_view instance |
| Ctask_graph_base | Intermediate class in PARAGRAPH class hierarchy responsible for handling registration of the instantiaion with the runtime.In addition to object registration this class is responsible for removing get_location_id() from the public interface of the task_graph |
| Ctermination_reduce | Reduction operator in termination detection. Add task added / processed counts and AND escape tasks booleans (used for early termination optimization) |
| Cterminator_initializer | Responsible for initializing the termination detection object that the PARAGRAPH's executor employs to determine when the local computation for the PARAGRAPH is completed.Partial specialization of this class provides a mechanism to customize the termination detection algorithm of a given PARAGRAPH |
| Cterminator_initializer< composition::nest_map_mr_factory > | Partial specialization to enable custom termination detection for composition::nest_map_mr_factory |
| Ctg_result_accessor | Accessor used by result_view that allows notification requests and operations requests to wait until deferred value is available |
| Ctraversal_order | Rearrange the contents of a tuple to be in the correct traversal order |
| Ctraversal_order< std::size_t, tuple< IntTypes... >, index_sequence< Indices... > > | Specialization for size_t |
| Ctry_commit_impl | Helper function to commit/uncommit a graph if it is CSR |
| Ctry_commit_impl< Graph, false > | Helper function to do nothing if a graph is not CSR |
| Ctuple_hash_impl | Recursive, static function to call boost::hash_combine() on each member of the input tuple and update seed parameter accordingly |
| Ctuple_type_reflector | Trivial type metafunction reflecting second type parameter Used in variadic expansion of integral parameter packs of a class that wishes to define a tuple of homogeneous types (i.e., indexed_domain) |
| Cunary_negate_helper | Base class for unary_negate the reflects the type argument_type if defined in the template |
| Cunary_tm_accessor | Accessor to defer the application of a given unary Functor until the evaluation is required |
| Cunderlying_container_impl | Metafunction to extract the bottom-most container from a view type |
| Cunderlying_container_impl< T, false, false > | Specialization when we've reached the bottom |
| Cunderlying_container_impl< T, true, true > | Specialization for composed segmented_views |
| Cvariable_distribution_factory | Factory encapsulating the creation of nested containers with the the composed distribution specification for instantiation with variable distributions. Follows interface of Boost.Factory, returns pointer to heap allocated instance of the created object |
| Cvariable_sizes_factory | Factory encapsulating the creation of nested containers with the the sizes view idiom for instantiation with variable sizes. Follows interface of Boost.Factory, returns pointer to heap allocated instance of the created object |
| Cversion_entry_disposer | Function object implementing the disposer concept defined by Boost.Intrusive.Intrusive containers do not manage the lifetime of the objects they contain. This is left to the container's user to manage. The disposer callback functor allows the user to do this during container operations where object deletion may be desired (i.e., clear()). In the version context, this disposer is a simple delete call |
| Cview_iterator | Definition of read only iterator used for the segmented_view View |
| Cwrite_adjacencies_to_graph | Work function to take the output of the butterfly (which should be the adjacency list for only the vertices on this location) and write the edges back to the graph |
| ►Ndetail_impl | |
| Cindices_type | Helper function to return an index tuple if the gid is a tuple or void if the gid is size_t |
| ►Ndirectory_impl | |
| Cmanager | A directory's manager maps GIDs to locations that are responsible for knowing exact locality about that GID. The result of this mapping is not necessarily the actual locality of the element. This manager uses the partition and mapper information to perform the translation |
| ►Ndist_spec_impl | |
| Ccb_gid_to_part | Mapping function from GID to partition id used to construct an arbitrary distribution specification from a container of partition information |
| Ccb_part_to_loc | Mapping function from partition id to location id used to construct an arbitrary distribution specification from a container of partition information |
| Ccombine_min_max_gid | Work function used to combine GID domain information extracted from a container of arbitrary partition information. Used in the construction of a container-based arbitrary distribution specification |
| Cextract_min_max_gid | Work function used to extract GID domain information from a container of arbitrary partition information. Used in the construction of a container-based arbitrary distribution specification |
| Cindex_times_lower_dim_size | Implements the linearization of a multidimensional id to a scalar |
| Cindex_times_lower_dim_size< Last, 0 > | Specialization for the last instance |
| Cindex_times_lower_dim_size< Last, Last > | Specialization for the first instance |
| Clarge_block_size_op | Function object that computes the size of large blocks in a balanced partition |
| Cmap_index_op | Functor implementing the mapping operation of a single dimension of the balanced partition of a multi-dimensional space |
| Cmapping_base | Base class of mapping functions used in view-based distribution specifications. The distribution_spec_view holds its mapping function using this base class |
| Cmapping_wrapper | Wrapper class used to hold mapping functions in view-based distribution specifications. The distribution_spec_view constructor creates an instance of this class and maintains access to it using a pointer to mapping_base |
| Cmerge_contains_info | Work function to combine the partial results from part_contains_gid invocations. This is used as the reduce operation of a map_reduce that performs the GID to partition id mapping in a container-based arbitrary distribution specification |
| Cpart_contains_gid | Work function to determine if the partition information contains the desired GID. This is used as the map operation in a map_reduce to determine which partition of an arbitrary distribution specification contains the desired GID as part of the mapping of a GID to its partition id |
| ►Ndist_view_impl | |
| Cexplicit_loc_mapping_function | Mapping from location id in the creator gang to a location id in the created gang based on an explicit set of locations that will be part of the created gang |
| Cexplicit_loc_resolution_function | Mapping from location id in the created gang to a location id in the creator gang based on an explicit set of locations that will be part of the created gang |
| Csystem_container | Container that represents the set of locations in the system |
| Csystem_container_distribution | |
| Ctrivial_p_object | Basic p_object used by system_container to initialize a gang over its set of locations |
| ►Ndomain_impl | |
| Ccore_iteratorDom | Defines a domain represented by two iterators, where all the elements between these two iterators belong to the domain |
| Cf_deref | Functor to get the gid associated with a given iterator |
| Cindexed_domain_base | Base class of indexed_domain that holds traversal order independent functionality |
| ►Nfunctional | |
| Carray_ro_view | Functor to define a functional construction of array_ro_view |
| Carray_view | Functor to define a functional construction of array_view |
| ►Ngenerator_impl | |
| Cstate_adjust | Wrapper around state_adjust_impl that detects presence of state_type nested typename and either forwards its corresponding boolean value to state_adjust_impl or false if the typename does not exist |
| Cstate_adjust_impl | Static polymorphic functor that either returns a provided generator or adjusts its state for a given starting offset through the offsetting constructor interface |
| ►Ngenerators | |
| ►Ndetail | |
| Cadd_edge | Functor that adds a given edge to a graph |
| Cadd_random_edge | Work-function to add a random edge |
| Cav_helper | Functor used to call the provided vertex addition functor |
| Cav_helper< WF, false > | Functor used to call the provided vertex addition functor. |
| Cav_helper< WF, true > | |
| Cbinary_tree_neighbors | Functor which adds edges to generate a binary tree |
| Ccomplete_neighbors | Functor which adds edges to form a complete graph |
| Ccycle_neighbors | Functor which adds edges to form a chain/collection of cycles |
| Cdag_neighbors | Functor which adds edges from an unordered_map adjacency list |
| Cdisjointed_complete_neighbors | Functor which adds edges to form a graph of complete subgraphs |
| Cerdos_renyi_m_generator | Graph generator for a Erdos-Renyi type M graph |
| Cerdos_renyi_neighbors | Functor which adds edges to form an Erdos-Renyi random network |
| Cgenerate_barabasi_albert_edge | Functor that generates the i'th edge that should exist in the graph, giving preferential selection for lower vertex descriptors |
| Cgrid_neighbors | Functor which adds edges to form a grid of the given dimensions |
| Cis_dynamic | Type-traits metafunction used to determine if a given graph is a stapl::dynamic_graph |
| Clist_neighbors | Functor which adds edges to form a list graph |
| Clists_tree_neighbors | Functor which adds edges to form a tree-of-lists graph of the given size |
| Cmesh_neighbors | Functor which adds edges to form a mesh of the given dimensions |
| Cpopulate_vertices | Functor which adds vertices to a generated graph with the default property |
| Crandom_k_neighbors | Work function which adds edges to the given graph to form a random neighborhood |
| Csparse_mesh_neighbors | Functor which adds edges with the given probability to form a mesh of the given dimensions |
| Cstar_neighbors | Functor which adds edges to form a star of the given dimensions |
| Ctorus_neighbors | Functor which connects vertices to form a torus of the given dimensions |
| Ctorus_neighbors_3D | Functor which connects vertices to form a 3D-torus of the given dimensions |
| Cwf_generate_dag_neighbors | Functor which generates the unordered_map adjacency list |
| Cws_neighbors | Functor which connects vertices with their k-nearest neighbors to form a Watts-Strogatz graph |
| Cws_rewire | Functor which rewires edges in a Watts-Strogatz graph |
| Cbinary_tree_network | Graph generator for a binary tree network graph |
| Cextract_graph_type | Metafunction which extracts the type of the generated graph from a graph generator type |
| Cextract_graph_type< Gen< G > > | Metafunction which extracts the type of the generated graph from a graph generator type. |
| Cextract_graph_type< Gen< G, EF, VF > > | Metafunction which extracts the type of the generated graph from a graph generator type. |
| Cgenerator | Generator which generates a graph using the provided edge and vertex functors |
| Cgenerator_base | Base class for all graph generators |
| Cperturbed_mesh | Populates a graph so it represents a perturbed mesh using a simulated number of processors |
| Crand_gen | Class for generating random numbers |
| Crandom_neighborhood | Graph generator for a random neighborhood graph |
| Cwatts_strogatz_stable | A stable implementation of watts_strogatz that generates the the same random Watts-Strogatz graph for a specified number of simulated processors (irrespective to the actual number of processes being run on) |
| ►Ngraph_bc_impl | |
| Ccleanup_elements | Called in destructor of graph_base_container_base to destroy heap value held by container_wrapper_ref, if the value type of the base container is a nested container |
| ►Ngraph_impl | |
| Cglobal_edge_copy | Work-function that adds bidirectional edges to the output graph for each directed edge in the input vertex |
| ►Ngraph_io_impl | |
| Cdefault_header_reader | Default work-function to read header lines of a file |
| ►Ninfinite_impl | |
| Cinfinite_base | Common base class of infinite domains used in implementation of has_finite_domain metafunction |
| ►Nkla_detail | |
| Ccombine_continue_halt_votes | Function used to OR results between wf and predicate values |
| Cempty_post_execute | Empty function that can be used as a null post-execute |
| Cempty_pre_execute | Empty function that can be used as a null pre-execute |
| Cfalse_predicate | Predicate used to vote to stop a traversal |
| Ckla_visitor | Visitor object that is passed as the second paramter to the vertex operator for KLA algorithms |
| Cneighbor_operator_apply | Functor to visit the target vertex with the user provided neighbor-operator |
| Cneighbor_operator_apply< reinvoke_behavior::avoid_hubs, VertexOp, NeighborOp > | Functor to visit the target vertex with the user provided neighbor-operator |
| Cneighbor_operator_apply< reinvoke_behavior::never, VertexOp, NeighborOp > | Functor to visit the target vertex with the user provided neighbor-operator |
| Cneighbor_operator_apply< reinvoke_behavior::upto_k, VertexOp, NeighborOp > | Functor to visit the target vertex with the user provided neighbor-operator |
| Cneighbor_operator_apply_base | Functor to visit the target vertex with the user provided neighbor-operator |
| Cvertex_operator_apply | Work function to wrap the user provided vertex-operator |
| Cvertex_operator_apply< reinvoke_behavior::avoid_hubs, Graph, VertexOp, Frontier, Predicate > | Work function to wrap the user provided vertex-operator |
| ►Cvertex_operator_apply_base | Work function to wrap the user provided vertex-operator |
| Cmake_wrapped_neighbor_operator | Helper class used to create a wrapped neighbor operator, which may or may not include a copy of the vertex operator, depending on the reinvoke behavior |
| Cvisit_transporter | Helper class to transport visitations through the graph |
| Cvisit_transporter< true > | Helper class to transport visitations through the graph. Specialization when the visits are guarded with an RMI lock |
| ►Nloc_ref_detail | |
| ►Nlocalize | |
| Cis_static_dontcare | Type metafunction that returns static true for all types except mix_view and proxy |
| Clocalize_object | Defines an object that provides the same interface as std::pair |
| Cstub_literal_localization | Defines an object that provides the methods for data localization required for the task |
| Cstub_localization | Defines an object that provides the methods for data localization required for the task |
| ►Nmap_func_impl | |
| Cselect_span | Reflects the correct span for a map instantiated with a view set |
| ►Nmetadata | |
| ►Ndetail | |
| Call_info_set | Functor to determine if all the metadata that is required to be stored in current location was assigned |
| Call_metadata_aligned | Functor used to determine if all the partitioned metadata is aligned |
| Ccheck_equal_size | Static functor to check if (1) all views have the same number of local partitions on all locations and (2) all corresponding partitions between views are of the same size |
| Ccheck_static_metadata | Unary function that returns the boolean from the pair representing the metadata of a view indicating if the metadata container is a fixed-size balanced distributed container |
| Ccompare_size | Unary functor comparing member to input parameter's size method. True if values (representing sizes) are the same or the parameter's size is tagged as infinite |
| Ccompare_size< std::pair< bool, T > > | Unary functor comparing member to input parameter's size method. True if values (representing sizes) are the same or the parameter's size is tagged as infinite |
| Cconstruct_domain | Functor to convert between different domain types |
| Cconstruct_domain< domainset1D< T > > | Functor to convert from a given domain to domainset1D domain |
| Cconstruct_domain< domset1D< T > > | Functor to convert from a given domain to domset1D domain |
| Cdomain_size | Helper static polymorphic function to compute view container size based on either size() or dimensions() call, based on the the dimensionality of the partitioned data it represents |
| Cextract_local | Helper functor to create an extractor on a remote location and return result of calling local_entries |
| Cgenerate_zero_cid | Small static functor to create a valid component identifier for infinite_container to use when creating metadata entries |
| Cinfinite_iter | Represents an infinite iterator |
| Cinitialize_guided_offset_alignment | Helper functor to initialize the temporary local information required for the alignment |
| Cmetadata_info | Defines a metadata entity that does not store information about locality, instead uses the given distribution (D) to respond to the information requests |
| Cplus | Operator used by growable_container for prefix scan algorithm call |
| Cproc_equal_offset | Helper functor to align metadata entries that have the same offset (are left aligned) |
| Cproc_unequal_offset | Helper functor to check if this location has all the information which is required for doing local computation of coarsening |
| Cselect_alignment_policy | Metafunction to compute the alignment policy for a given set of views |
| Ctransform_view_from_metadata | Helper functor to construct a partitioned_mix_view from the given view and metadata container |
| Cview_partition_impl | Default implementation for constructing an iterator range over a view's container's local base containers |
| Cbase_container_wrapper | Defines a locality metadata container for a given base container (BC) |
| Ccoarsening_traits | Traits class that specializes functionality of the coarsening process |
| Ccontainer_extractor_base | Class for computing the metadata of static containers that use container_manager_static that inherits from the base-container, and thus, is the base-container itself. This type of container manager has only one component per location |
| Ccontainer_metadata_projection | Helper functor used to project the domains in the given locality metadata (P) to the domain of the given View. The result is projected metadata locality information, where the metadata is expressed using the view's domain type |
| Ccontainer_wrapper | Metadata container that wraps a distribution of a pContainer |
| Cdefault_metadata_projection | Metafunction to compute the type of the metadata projection function object |
| Cdomain_container_extractor | Functor to create metadata for a |
| Cequal_second | Helper functor to determine if the given pair <size, offset> p, has the same specified offset |
| Cextract_and_project_view | Retrieves the metadata for a view by calling the extraction operator for the container immediately invoking the projection operator |
| Cextract_and_restrict_view | Retrieves the metadata for a view by calling the extraction operator for the container and potentially restricting the domain of the metadata |
| Cextract_metadata | Functor used to coarsen the data managed for the given Container based on the data locality |
| Cextract_metadata< View, true, false > | Functor used to coarsen the data managed for the given Container based on the data locality |
| Cextract_metadata< View, true, true > | Functor used to coarsen the data managed for the given Container based on the data locality |
| Cextract_view | Retrieves the metadata for a view by calling the extraction operator. Used when it is statically known that projection is not necessary for the given view |
| Cextractor_traits | Traits class specialized by derived classes of container_extractor_base to provide access to distribution type during inheritance with CRTP to avoid additional template parameter which unnecessarily stresses compiler |
| Cflat_container | Container for metadata used when the number of elements (metadata information) is known at the construction time |
| Cgenerator_container | Metadata container to create metadata information on demand using a balance partition of the view's domain to determine the metadata information |
| Cgenerator_extractor | Functor used to return the locality metadata information of a general container (container that does not provide a metadata locality extractor functor) |
| Cgeneric_metadata_projection | Helper functor used to project the domains in the given locality metadata (P) to the domain of the given View. The result is projected metadata locality information |
| Cget_copy_md_entry_type | Helper functor to determine the local storage type for the metadata information |
| Cgrowable_container | Container for metadata used when the number of elements (metadata information) is not known at construction |
| Cguided_alignment< tuple< View... > > | Generates a metadata alignment for the given view set, using the view at position k to guide the alignment |
| Cguided_offset_alignment | Generates a metadata alignment for the given view set, using the view at position k to guide the alignment |
| Cimplicit_metadata_projection | Helper functor used to project the domains in the given locality metadata (P) to the domain of the given View. The result is projected metadata locality information, where the metadata is expressed using the view's domain type |
| Cinfinite_container | Metadata container used for views that represent an infinite collection of elements (e.g. repeat_view, output_view) |
| Cinvertible_metadata_projection | Helper functor used to project the domains in the given locality metadata (P) to the domain of the given View. The result is projected metadata locality information |
| Cinvoker | Invokes an arbitrary functor with a p_object as a parameter |
| Cmetadata_ctor_func | Functor used to compute the view's domain metadata from the container's domain |
| Cmin_size_offset | Helper functor to compute the minimum size and offset from the given pairs of size and offset |
| Cmultiview_coarsener_impl | Helper class template for multiview_coarsener, dispatching coarsener implementation based on the number of finite views found in the set of views passed in tuple parameter Views |
| Cmultiview_coarsener_impl< tuple< partitioned_mix_view< View0, Part, CC > >, Align, 1 > | Specialization for the single partitioned_mix_view |
| Cmultiview_coarsener_impl< tuple< partitioned_mix_view< View0, Part, CC >, Views... >, Align, FiniteViews > | Specialization for the case when a partitioned_mix_view is present in the input view set |
| Cmultiview_coarsener_impl< Views, Align, 0 > | Specialization when no finite views are found. Statically assert as this case does not make sense for this coarsening approach |
| Cmultiview_coarsener_impl< Views, Align, 1 > | Specialization when one finite view is found. No alignment (or corresponding check needed). Call native coarsener |
| Cmultiview_coarsener_impl< Views, false, FiniteViews > | Specialization for the case when alignment is explicitly disabled |
| Cprojected_container | Wrapper around a metadata container to create metadata information on demand, by projecting the container's domain into the view's domain |
| Cpush_static_metadata | Distributed object used to push metadata to neighboring locations in cases where static metadata is used. This eliminates blocking reads of the partition data in guided_offset_alignment::apply |
| Creverse_container | Metadata container used for views that represent an elements in reverse order (e.g |
| Creverse_extractor | Functor used to extract the locality metadata associated with a Reverse |
| Csegmented_metadata_projection | Helper functor used to project the domains in the given locality metadata (P) to the domain of the given View. The result is projected metadata locality information |
| Csegmented_view_extractor | Functor to extract the locality metadata for a view whose elements are subviews (Segmented) |
| Csize_offset | Helper functor to compute the size and offset from the metadata at position i |
| Cslices_projection | Helper functor used to project the domains in the given locality metadata (P) to the domain of the given View. The result is projected metadata locality information |
| Cstatic_container_extractor | Class for computing the metadata of static containers that use container_manager_static that inherits from the base-container, and thus, is the base-container itself. This type of container manager has only one component per location |
| Cstencil_metadata_projection | Helper functor used to project the domains in the given locality metadata (P) to the domain of the given View. The result is projected metadata locality information |
| Cview | Definition of a view over a metadata container |
| Cview_base | Metadata container base class for view |
| Cview_wrapper | Wrapper class over a view used to erase the type of the container metadata |
| ►Nmultiarray_impl | |
| Cblock_partition | N-dimensional partition consisting of balanced_partitions of indexed_domain. This class will partition a multidimensional domain into multidimensional blocks with a certain number of blocks in each dimension. This is the default partition for the multiarray container |
| Cmake_multiarray_size | Function object that initializes a tuple of n elements that is used to create an n-dimensional multiarray partition |
| Cnot_prime | Determines if a number is not prime |
| ►Noperations | |
| Capplyable | Operations class for container distributions that provides apply_set() and apply_get() |
| Cbase | Operations class for container distributions that provides basic functionality for standard containers including getting, setting and applying |
| Cconst_referencer | Functor that creates a const reference either as a proxy or a view, based on use_view_as_reference metafunction |
| Cgettable | Operations class for container distributions that provides get_element |
| Citerable | Operations class for container distributions that provides global iteration |
| Cmigratable | Operations class for container distributions that provide element migration |
| Crandom_access | Operations class for container distributions that provides for random access by allowing the creation of references |
| Creferencer | Functor that creates a reference either as a proxy or a view, based on use_view_as_reference metafunction |
| Csettable | Operations class for container distributions that provides set_element |
| Cuse_bc_set_elements | Used to enable use of base container set_elements method for servicing request. Limited to now to small set of array cases |
| ►Nordering_detail | |
| Cadvance_bw | Functor used to advance backward the given gid, n positions, returning the advanced gid using the given promise |
| Cadvance_fw | Functor used to advance forward the given gid, n positions, returning the advanced gid using the given promise |
| Cdistance_fw | Functor used to compute the distance between to given gids, returning the computed distance in the given promise |
| Cdistance_fw_associative | Functor used to compute the distance in associative containers between to given gids, returning the computed distance in the given promise |
| Cfind_bw | Functor used to find the last gid, returning in the given promise |
| Cfind_first | Functor used to find the first gid, returning in the given promise |
| Cfind_fw | Functor used to find the first gid, returning in the given promise |
| Cfind_last | Functor used to find the last gid, returning in the given promise |
| Csearch_fw | Functor used to search in a stapl::list for a specific gid in the given range [first..last], returning if the gid was found or not using the given promise |
| ►Nordering_impl | |
| Cnode | Defines an entry node in the list of base containers |
| Cptr_bcontainer | Defines a connection between base containers (ordering pointer) |
| ►Npack_ops | |
| Cand_ | Metafunction that performs a logical and of its compile-time boolean template parameters |
| Cpack_element | Metafunction to compute the type of the I-th parameter in the parameter pack Ts.. |
| ►Npage_rank_impl | |
| Cpage_rank_copy_wf | Work-function to copy the auxiliary rank to the actual PageRank values and reinitialize the auxiliary rank |
| Cpage_rank_init_wf | Work-function to initialize the auxiliary and actual PageRank values |
| Cpage_rank_wf | Work-function to compute the PageRank of a vertex and push it to the vertex's neighbors |
| Cupdate_func | Functor to add the value of the incomming PageRank to the target vertex's auxiliary PageRank |
| Cvp_reducer | Reducer functor for page_rank() |
| ►Nparagraph_impl | |
| Ccheck_finished | Metafunction that invokes member finished on the factory if it inherits from incremental_wf, denoting that it implements the incremental workfunction concept.Primary template matches incremental case. Invoke finished on the factory |
| Ccheck_finished< Factory, false > | Specialization matching case when Factory conforms to the incremental workfunction concept.Return true, no invocation is required |
| Ccoarsener_type | Metafunction that computes the coarsener type for a given Factory |
| Ccoarsener_type< Factory, false > | The specialization of coarsener_type metafunction for the case that the coarsener_type is not defined by the Factory |
| Ccompute_demotion_wf | Functor that recovers the original workfunction passed to task creation prior to any wrappers to support the promotion of localized return values |
| Ccompute_demotion_wf< promote_wf< WF, GlobalVS > > | Functor class specialization matching task workfunctions that were wrapped with promote_wf to support localization.Extracts and return the original workfunction |
| Ccompute_df_edge_type | Temporary metafunction used in task_graph::processed() to extract proxies from proxy_holders they were wrapped in for serialization |
| Ccompute_nested_paragraph_type | Type metafunction to compute PARAGRAPH type for a nested PARAGRAPH by expanding the tuple in the task's viewset into a type list to pass to the paragraph's template instantiation |
| Ccompute_promotion_wf | Functor invoked by the task creation process. Compares the return types of the workfunction when given the global and local viewsets. If they differ the workfunction that task uses is changed to facilitate the promotion of the return value based on the localized viewset to a form valid in the global / enclosing scope |
| Ccompute_promotion_wf< WF, GlobalVS, LocalVS, false > | Functor class specialization matching cases where a promotion wrapper is needed to generalize the localized return value from the workfunction.Wrap the workfunction with promote_wf, initialized the wrapper with both the base workfunction and the non localized view set |
| Ccompute_tid_mapper_type | Extracts the key mapper type from the Factory class if it is defined |
| Ccontains_leaf | Work function used when traversing the set of trees to determine which tree contains the task to process the specified view element |
| Ccount_df_preds_func | Functor used to identify deferred evaluation views and accessors in the specification of a task |
| Ccreate_paragraph | Facilitates creation of one-sided PARAGRAPH creation via construct. Template exist instead of inline in add_task to allow creation of index integer pack via partial specialization so that we can expand the viewset into an argument list an apply view packaging prior to transmission |
| Cedge_unpackager_impl | Implementation class of edge_unpackager, allowing partial specialization to intercept proxies backed by an edge_accessor. Primary template is for non matches and is an identity operation |
| Cedge_unpackager_impl< lazy_edge_reference< T > > | Partial specialization matching edge_accessor proxies. Get predecessor task id from packaged proxy and initialize a new proxy with storage that will be initialized with a promise fulfilled by predecessor data flow |
| Cfactory_task | Concrete implementation of abstract class task_base, used to invoke the factory (the initial task executed for any PARAGRAPH which populates the graph with additional tasks) from the PARAGRAPH's executor |
| Cget_nested_scheduler | Static functor with partial specialization to detect if the factory for a nested PARAGRAPH provides a custom scheduler for the PARAGRAPH or if the default_scheduler should be used |
| Chas_enable_migration | Metafunction that checks if enable_migration is defined for T.Extends from false_type by default |
| Chas_enable_migration< T, typename T::enable_migration > | Metafunction that checks if enable_migration is defined for T.Extends from true_type for T that has T::enable_migration |
| Cidentity_task_impl | Implementation base class for Task class template specializations involving identity tasks. Inspects the incoming edge and attempts to move / share the associated value object instead of copying |
| ►Cidentity_wf | Trivially wraps a workfunction |
| Cresult | Nested result struct to compute return type. Redirect to any definition in WF |
| Cin_edge_reset | Functor used by PARAGRAPH to reset port edges from producing paragraph prior to re-invocation of the paragraph in persistent mode |
| Cinitialize_migrating_scheduler | Static functor with partial specialization to detect a scheduler using task migration and provide it with a pointer to the now initialized paragraph |
| Cis_deferred | Default metafunction used in the identification of deferred evaluation views and accessors in input_edge_available_func |
| Cmigration_packer | Given an edge value type T, this metafunction returns the type serialized during task migration |
| Cmigration_packer< lazy_edge_reference< T > > | Specialization for instances of proxy backed by the edge_accessor with default filtering (i.e., no filtering). Wrap these proxies in proxy_holder |
| Cmigration_unpacker | Given an edge value type T, this metafunction returns the unpacked type of the egde, post task migration |
| Cmigration_unpacker< proxy_holder< lazy_edge_reference< T > > > | Specialization for instances of edge container proxies which have been wrapped in a proxy_holder. Reconstructs the proxy after inserting value in the local edge_container |
| Cnested_pg_dataflow_setup | Functor passed to async_construct which is executed after construction of a nested PARAGRAPH (on all locations in the new PARAGRAPH). Used to initiate discovery for consumer PARAGRAPHs and dataflow from any producers this PARAGRAPH consumes from |
| Cnested_pg_directory | Basic generalization of a directory for keys referring to a distributed object. Specific use here is to forward consumption requests from one nested paragraph to another |
| Cnested_pg_task | Task wrapper for nested PARAGRAPH. Used to reinvoke the paragraph in from a persistent parent paragraph |
| Cnested_tag | Used to distinguish one-sided nested and collective PARAGRAPH constructor calls |
| Cno_preds_t | Constexpr class used by callers of add_task to signify that there are no explicit, signal only consumers of a given task |
| Cobject_wrapper | Trivial holder for an object (currently the factory in the PARAGRAPH which holds an instance and can be inherited from without polluting the derived class with members which may cause naming conflicts |
| Cparagraph | The PARAGRAPH is the dependence graph representation of programs in STAPL. It's generally not advised for users to instantiate it directly, but rather use stapl::make_paragraph |
| Cparagraph_view | Provides an interface for a PARAGRAPH's factory as well as dynamic tasks to add new tasks to the PARAGRAPH during execution |
| Cparagraph_view_base | Trivial view class for PARAGRAPH holding a task_graph pointer. Used for consume() statements and as a base class of Scheduler typed class template paragraph_view |
| Cpost_execute_func | Function object used by Task to invoke post_execute on each element of the viewset unless it is a proxy or paragraph_view |
| Cpost_execute_impl | Implementation class of post_execute_func. Uses partial specialization to call method in object if and only if it is a view |
| Cpre_execute_func | Function object used by Task to invoke pre_execute on each element of the viewset unless it is a proxy or paragraph_view |
| Cpre_execute_impl | Implementation class of pre_execute_func. Uses partial specialization to call method in object if and only if it is a view |
| Cpromote_wf | Workfunction wrapper that facilitates promotion of a localized return value to the global scope (i.e., that of the PARAGRAPH instead of the task |
| Cpromotion_resolver | Functor that attempts to deduce what input parameter to the workfunction the return value is based on and exactly of what it is a reference to (e.g., reference to some portion of a view element, etc). It then redirects to an appropriate invocation of promote_ref to perform the actual promotion and returns the promoted result.Primary template used when framework doesn't know how to perform promotion. Unconditionally asserts at compile time |
| Cpromotion_resolver< WF, GlobalVS, typename tuple_element< 0, GlobalVS >::type::reference > | Functor specialization used when WF::result_type == View0::reference and View::reference is a proxy |
| Cpromotion_resolver< WF, GlobalVS, typename tuple_element< 0, GlobalVS >::type::reference::reference > | Functor specialization used when WF::result_type == View0::reference::reference (e.g., reference from element (view) of a partitioned view) and View0::reference::reference is a proxy |
| Cproxy_holder< lazy_edge_reference< T > > | Specialization for instances of proxy backed by the edge_accessor.Hold a copy of the value and the corresponding task identifier directly |
| Cquery_task_placement | Static functor to check if a PARAGRAPH's scheduler has defined the task_placement_all_local type, stating that all tasks created on this location should be run here. If so, invocation of Scheduler::execution_location() is bypassed, with a trivially constructed locality_info object returned |
| Cresult_storage_mf | Metafunction to compute storage type for lhs side of workfunction invocation in Task::operator(). Allows void and nonvoid types to be handled uniformly to avoid a complete specialization the Task class template |
| Cresult_storage_mf< void > | Class specialization for workfunction returning void. Reflect empty_class |
| Csetup_edge_flow_func | Creates the notifiers necessary to flow the result of a non-explicitly dependent task (i.e., those specified via consume) so it is available for the task being added on this location |
| Csetup_flow_func | Functor used for setup_flow in nested paragraph directory call to pass to invoke_where. At the location where the nested PARAGRAPH's rmi_handle is known by the directory, use it to initiate a call to request_out_flow on the producer PARAGRAPH |
| Csetup_parent_flow_func | Functor used for setup_parent_flow in nested paragraph directory call to pass to invoke_where. At the location where the nested PARAGRAPH's rmi_handle is known by the directory, use it to initiate a call to request_parent_out_flow on the producer PARAGRAPH |
| Cstrip_df_proxy | Metafunction that unwraps redundant proxy / view wrapping such as with the edge_accessor backed proxy when the edge type is a proxy |
| Cstrip_df_proxy< lazy_edge_reference< T > > | Specialization for edge_container backed values. Creates proxy<edge_accessor<T>> |
| Cstrip_df_proxy< pg_lazy_edge_reference< T > > | Specialization for edge_container backed values for inter-paragraph dataflow. Creates proxy<edge_accessor<T>> |
| Cstrip_df_proxy< proxy< T, A >, typename T::is_view_ > | Specialization for proxy<view<T>>.Remove the proxy by invoking proxy's conversion operator |
| Cstrip_wrapper | Type metafunction strips immutable_shared wrapper from reflected type if it exists |
| Csubview_type< ptr_wrapper< View >, false > | Specialization for views passed to add_task using ptr_wrapper. This happens with edge_view or aggregated_edge_view, so it captures all PARAGRAPH data flow parameters to a task |
| Csubview_type< View, false > | Specialization for for non edge views not having get_subview method |
| Ctag_type | Metafunction that computes the tag type for a given Factory |
| Ctag_type< Factory, false > | Metafunction that computes the tag type for a given Factory for the case that tag_type is not defined by the Factory |
| CTask | Concrete implementation of abstract class task, used to invoke user workfunction with views that were defined as task via an add_task method call on the paragraph_view |
| CTask< SchedulerEntry, EnableMigration, EnablePersistence, identity< Q >, Storage< lazy_edge_reference< T > > > | Specialization for identity that applies identity task squashing optimization implemented in identity_task_impl |
| CTask< SchedulerEntry, EnableMigration, EnablePersistence, identity_op, Storage< lazy_edge_reference< T > > > | Specialization for identity_op that applies identity task squashing optimization implemented in identity_task_impl |
| Ctask_base | Encapsulates all information needed to execute a task. Constructed by the PARAGRAPH and passed to executor when all dependences have been satisfied |
| Ctask_base_intermediate | Intermediate class in task_base / Task inheritance relationship which encodes the scheduler metadata type so that a virtual function signature can be defined and polymorphically invoked by the scheduler (who doesn't know concrete type of Task) to initiate task migration |
| Ctask_graph | Contains all functionality of the PARAGRAPH that isn't dependent on the Scheduler or View types |
| Ctask_graph_impl | Contains functionality of the PARAGRAPH that is dependent on the the type of scheduler used in the executor processing the PARAGRAPH, though not the Views of the PARAGRAPH.PARAGRAPH persistence is enabled by a typedef reflected by the scheduler. task_graph_impl derives from persistent_pg or ephemeral_pg depending on whether the typedef is reflected by the scheduler or not |
| Ctransform_lazy_view | View specification transformation functor used by the paragraph_view to include a rmi_handle::reference as well when accepting and forwarding view specifications via add_task() |
| Ctransporter | Functor pass to executor_rmi for out of group task placement / execution |
| Ctransporter_notifier | Notifier used for tasks created using transporter, allowing them to wait on predecessor data flow |
| Ctree_info | Represents the statistics of a balanced binary tree of tasks that is part of a PARAGRAPH performing a reduction or prefix scan on a view |
| Cunwrap_pointer | Type metafunction to strip pointer_wrapper from the type if it exists |
| Cview_manager | This function object is responsible for applying the coarsener functor to the views passed to the PARAGRAPH constructor. The returned tuple is the set of views stored by the PARAGRAPH and passed to the factory |
| Cview_manager< Coarsener > | Specialization for PARAGRAPH with no input views. Returns an empty tuple |
| Cwf_invoke | Function object that invokes a workfunction by expanding a set views stored in a tuple into a comma separated list of parameters. This list defines the actual parameters to the workfunction.It is used for workfunctions returning non-void value types |
| Cwf_invoke< WF, tuple< Args... >, index_sequence< Indices... > > | Specialization of class for i number of views |
| Cwf_invoke_void | Function object that invokes a workfunction by expanding a set views stored in a tuple into a comma separated list of parameters. This list defines the actual parameters to the workfunction.It is used for workfunctions returning void |
| Cwf_invoke_void< WF, tuple< Args... >, index_sequence< Indices... > > | Specialization of class for i number of views |
| ►Npartitioner_details | |
| Cadd_partition | Functor to add the adjacent edge weight and associated partition id to a vertex |
| Cadjust_edge_weight_wf | Functor adjusting an edge weight with the target vertex weight for improving the matching phase |
| Cadjust_edge_weight_wf2 | Functor adjusting an edge weight with the target vertex outdegree for improving the matching phase |
| Cadjust_matched_value | Functor adjusting the matched value of a vertex to be the same as the one of its matched vertex, this value is used for the creation of a level of hierarchy |
| Capply_vertex_wf | Functor to apply a functor on an element of a view |
| Cbuild_edge_hierarchical_graph_wf | Functor to copy the edges of a weighted graph to a graph with the multilevel property |
| Cbuild_pair_weight_id | Transform a graph base container into the CSR format used by METIS |
| Cbuild_vertex_hierarchical_graph_wf | Functor to copy a vertex from a weighted graph to a graph with the multilevel property |
| Cclear_maybe_matched2_wf | Functor to clear MAYBE_MATCHED status of the local information about non-local vertices |
| Cclear_maybe_matched_wf | Functor to clear MAYBE_MATCHED status of a vertex |
| Ccombine_vector_wf | Functor to combine two vectors by summing their elements pair-wise |
| Ccompute_partition_weights | Functor computing the partition weights of a graph |
| Cfm_refinement_wf | Fiduccia-Mattheyses heuristic functor to decrease the edge-cut of a graph partition while maintaining a low partition imbalance |
| Cget_cut_weight | Functor computing the cut-weight produced by a vertex in a graph |
| Cget_group_id | Functor to extract group id from the vertex property for the creation of a super-vertex in a new level of hierarchy |
| Cget_partition_doms | Extract partition domains from vertices |
| Cget_partition_weights | Functor getting the weight of each partition |
| Cmatch_info | Local information about the matching status of non-local vertices |
| Cmatch_vertex | Functor requesting the matching of a vertex |
| Cmetis_bisection_wf | Functor for parallel nested bisection partitioning of a graph. This implementation uses the METIS library for the bisection |
| Cmetis_kway_wf | Functor to set the partition id of a vertex with the result of the METIS k-way partitioner |
| Cmultilevel_edge_property | Vertex property for multilevel graph partitioner |
| ►Cmultilevel_vertex_property | Vertex property for multilevel graph partitioner |
| Cgain_comparator | Compares the gain of two partitions. Returns true if the first partition has a higher gain |
| Cpid_comp | Compares id of partition with a specific partition id |
| Cproperty_add_wf | Functor adding a specific weight to a property |
| Cproperty_divide_wf | Functor dividing a property with a specific weight |
| Crmi_allgather_obj | Object to broadcast a graph in CSR format used by METIS |
| Csend_mypartition_id | Functor to share vertex partition id with neighboring vertices |
| Cset_children_partition_id | Functor to setting the partition id of a vertex |
| Cset_children_pid | Functor setting the partition ids of super-vertex's children |
| Cset_partition_domain_wf | Functor to set partition domains in the hierarchical view |
| Cshare_matching_status_wf | Functor to share matching status of a vertex with neighboring vertices |
| Cshuffle_wf | Functor to shuffle elements of a base container |
| Ctarget_aggr_wf | Functor to apply a functor on a vertex of a graph |
| Cupdate_partition | Functor updating neighboring partition information of a vertex |
| Cvalidate_request | Functor to validate a matching request |
| Cvertex_match_wf | Functor trying to match a vertex with one of its neighbor |
| ►Npartitions_impl | |
| Cpartitions_generator | Function object that initializes an n-dimensional tuple of partitions to n balanced partitions, each partitioned by the number of locations |
| Cpartitions_generator< 1, Domain, Tuple > | Base case to end recursion for partitions_generator |
| ►Npolicy | |
| Cfull | Tag-class describing the distribution policies for nested-pContainer construction. This class specified that the nested-pContainer will be distributed globally |
| Chere | Tag-class describing the distribution policies for nested-pContainer construction. This class specified that the nested-pContainer will be distributed locally |
| ►Nproperties | |
| Cbc_property | Vertex property for use with betweenness_centrality(). Set of properties for each vertex, distance, delta, sigma, list of parent vertices, and a marker for BFS visitation |
| Cbfs_property | Vertex property for use with breadth_first_search() |
| Ccc_property | Vertex property for use with connected_components() |
| Cno_property | Struct used to define graphs with no property for vertices or edges |
| Cpage_rank_property | Vertex property for use with page_rank() |
| Csssp_property | Vertex property for use with sssp() |
| ►Nprototype | |
| ►Nresult_of | |
| Ccount | Defines the return type of the count function |
| Cmap_reduce | Computes the result type of a map_reduce PARAGRAPH |
| ►Nproxy_impl | |
| Ccompute_accessor | Type metafunction that returns OptionalAccessor if specified and otherwise returns Selector::accessor_type |
| ►Nresult_of | |
| Caggregated_consume | Defines return type consume signature for aggregated, multiple edge consumption and user provided filter function |
| Cbalance_view | Defines balance_view type over View |
| Cbind1st | Defines the type of a binder1st instantiated with the given parameters |
| Cbind1st< Operation, proxy< T, A > > | Defines the type of a binder1st instantiated with the given parameters, where the bound argument is a stapl::proxy |
| Cbind2nd | Defines the type of a binder2nd instantiated with the given parameters |
| Cbind2nd< Operation, proxy< T, A > > | Defines the type of a binder2nd instantiated with the given parameters, where the bound argument is a stapl::proxy |
| Cbind3rd | Defines the type of a binder2nd instantiated with the given parameters |
| Cbind3rd< Operation, proxy< T, A > > | Defines the type of a binder2nd instantiated with the given parameters, where the bound argument is a stapl::proxy |
| Cconsume | Defines return type consume signature in single predecessor case |
| Ccounting_view | Defines the type of a counting view parameterized with T |
| Clocalize_object | Helper class to determine the localization object based on the reference type |
| Clocalize_object< Ref, true > | Helper class to determine the localization object based on the reference type |
| Cmake_paragraph | Metafunction which reflects return type of a make_paragraph call |
| Cmap_reduce< Tag, skeletons::tags::coarse< CoarseTag, ExecutionTag >, ReduceOp, Args... > | This specialization exists to accommodate the over eager template instantiations of clang in a disabled map_reduce function signature guarded by enable_if. It tries to compute the return type even though it will never be used |
| Cnative_view | Defines native_view type over View |
| Creverse | Reverses a given tuple. For example, tuple<char, int, double> would become tuple<double, char, int> |
| Ctransform_reference | Helper to determine the deferred reference based on the given references (References1, References2) and binary Functor type |
| Ctransform_reference< Reference, Functor, void > | Helper to determine the deferred reference based on the given References and unary Functor type |
| ►Nruntime | STAPL Runtime System implementation classes and functions |
| ►Nanonymous_namespace{p_object_registry.cc} | |
| Cregistry_entry | Typed p_object registry entry |
| ►Nboost_impl | |
| Cthread_local_storage | Implements thread-local storage using boost::thread_specific_ptr |
| ►Nbuffer_archive_impl | |
| Cinput_stream | Reads bytes from the given buffer |
| Coutput_stream | Writes the bytes to the given buffer |
| Csize_stream | Calculates the total number of bytes written to the stream |
| ►Ncontext_impl | |
| Caggregator | RMI request aggregator to a destination location |
| ►Ngeneric_impl | |
| Cfuzzy_barrier | Binary-tree based fuzzy barrier |
| Cqueue | A thread-safe queue |
| Cread_write_mutex | A generic, non-optimized implementation of a read-write mutex |
| Cthread_local_storage | Helper class for thread-local storage through C++11 thread_local |
| ►Nphtread_impl | |
| Cread_write_mutex | A read-write mutex based on pthread_rwlock_t |
| ►Npolymorphic_impl | |
| Capply_impl | Scans a std::tuple of types (T) and calls f.apply<U>() if and only if the type_id matches a type in T |
| ►Ntbb_impl | |
| Cqueue | A thread-safe queue using tbb::concurrent_queue |
| Cread_write_mutex | An implementation of a read-write mutex based on tbb::queueing_rw_mutex |
| Cthread_local_storage | Implements thread-local storage using tbb::enumerable_thread_specific |
| Cactive_handle_response | Function object to call the function operator of a distributed object with the given value |
| Caggregator | Aggregator for point-to-point requests |
| Call_locations_rpc_aggregator | Aggregator for RPC requests to all locations of a gang |
| Call_locs_construct_request | Request to construct an object on all locally managed locations |
| Callgather_object | Performs an allgather over all locations of the current gang |
| Callreduce_object | Performs an allreduce over all locations of the current gang |
| Cany | any can hold an object of any type. The object can be retrieved only by casting to the correct type |
| Cany_range | Type erased range of const objects with associated size information |
| Carbitrary | Arbitrary mapping function |
| Carg_storage | Storage for an object of type T that is retrieved by lvalue reference |
| Carray_mailbox | Mailbox for multiple threads that are contiguously numbered |
| Casync_result | Storage for a result that can be asynchronously assigned and retrieved |
| Casync_results | Storage for an array of results that can be asynchronously assigned and retrieved |
| Casync_rmi_request | RMI request that discards the return value and supports combining |
| Casync_rpc_request | Remote Procedure Call (RPC) request that discards return values |
| Cbackoff_metadata | Backoff mechanism metadata |
| Cbarrier | Performs a barrier over the processes specified by the topology object |
| Cbarrier_object | Performs a barrier over all locations of the current gang |
| Cbcast_aggregator | Aggregator for ordered and unordered broadcast requests |
| Cbind_rmi_result | Establishes a communication tunnel to a member function of a distributed object |
| Cbinomial_tree_iterator | Iterator to generate range of children ids required from make_binomial_tree |
| Cblock_registry | Implements a registry that allows registration of ranges (blocks) of keys to be used by an entity that has a unique id |
| Cblocked | Block mapping function |
| Cbool_mutex | Bool based mutex |
| Cbroadcast_object | Performs a broadcast over all locations of the current gang |
| Cbuffer_iarchive | Archive to unpack an object from a stream |
| Cbuffer_oarchive | Archive to pack an object to a stream |
| Cc_string | Wraps a C string into a class |
| ►Ccache_line_aligned_allocator | An allocator that enforces that all allocated memory returned to the caller begins at the start of a cache line |
| Crebind | Provides a way to obtain an allocator for a different type |
| Ccache_line_aligned_storage | Storage for a single instance of type T. Class has alignas directive to ensure cache line alignment. Used as storage type for cache_line_aligned_vector |
| Ccache_line_aligned_vector | Basic vector class based on std::vector which enforces cache line alignment |
| Ccall_promise_set_value | Calls promise<rmi_handle::reference>::set_value() from location 0 |
| Ccentralized_fuzzy_barrier | Centralized fuzzy barrier |
| Ccloner | Copy constructs a new T object on heap allocated memory |
| Ccollective | Handle for distributed memory collective operations |
| Ccombinable_rmi_request | Encapsulates an RMI request that supports combining for subsequent execution via the function operator |
| Ccombined_request_size | Information about the size of combined requests |
| Ccommon_gang_md | Metadata that can be shared between multiple gangs |
| Ccommunicator | This class assists with sending messages between processes |
| Ccomparable_proxy | Proxy object that allows type-erased objects or function pointers to be compared between them |
| Ccomparator | Function object to test if two objects are equal |
| Cconcurrency | Initializes and controls threads for shared-memory concurrency |
| Cconst_member_pointer | Returns a member function pointer of type R (T::*)(Arg...) const |
| Cconstruct_request | Request to construct an object in a new gang over specific locations of an existing gang |
| Ccontext | Execution context of a task or request |
| Ccontext_id | Id for an execution context. It is associated with context object |
| Ccontinuation_request | Calls function f with a Future created with t... |
| Ccopied_arg_storage | Storage for a moved object that is retrieved by copy or by const reference |
| Ccopied_ref_storage | Storage for a moved object that is retrieved by non-const reference |
| Ccopyable | Tag type for objects that for which is_copyable is std::true_type |
| Ccreate_object | Calls the constructor of T with Args |
| Ccreate_shared_ptr | Creates a new shared_ptr from the given object |
| Cctx_impl | Wrapper to store a context and allow queueing it into a boost::intrusive::list |
| Cdata_race_helper | Helper class for detecting possible data races in a class static or stand-alone function |
| Cdeferred_t | Tag type to defer an operation |
| Cdelete_object_request | Request to delete a distributed object |
| Cdistributor | Gang id and metadata distributor |
| Cexception | Runtime base exception object |
| Cexecutor_intermediate | Intermediate class to allow adding entries with scheduling information |
| Cexecutor_rmi_request | Request for executing the given function on the destination location |
| Cexternal_caller | Function object that calls a function passed from external_call() |
| Cfence_md | Fence metadata for intergang communication when a gang_md has no representative |
| Cfence_md_delete | Destroys fence_md objects while sending the metadata to the correct process |
| Cfence_section | Enters a section of the code that is related to fence |
| Cfixed | Fixed mapping function |
| Cfull_location | Describes a location as a tuple of a gang id and a location id |
| Cfuture_base | Provides a common base for an asynchronously returned object |
| Cfutures_base | Provides a common base for asynchronously returned arrays of objects |
| ►Cgang_description | Contains information about the locations of a gang |
| Cprocess_iterator | Iterator over process ids |
| Cprocess_location_iterator | Iterator over locations ids of a specific process |
| ►Cgang_md | Gang metadata that is shared by the locations that are on the same process |
| Cfence_md | Fence metadata for intergang requests |
| Cgang_md_registry | Gang metadata registry |
| Cgang_retriever | Retrieves the gang_md& associated with the gang id |
| Cgang_switcher | Switches to and from the given gang |
| Cglobal_wf | Function object to create a new distributed or mixed-mode environment |
| Chandle_response | Function object to assign an object to a distributed object via the Handle::set_value() function |
| Chas_define_type_impl | Detects if T has a function T::define_type(stapl::typer&) |
| ►Cheader | Provides the enum and the different headers for communication |
| Cbcast_location_rpc | Header for broadcast RPCs to locations |
| Cbcast_request | Header for ordered and unordered broadcast requests |
| Clocation_rpc | Header for broadcast RPC to locations |
| Crequest | Header for ordered and unordered point-to-point requests |
| Cheap_tracker_init | Nifty counter idiom to initialize the heap tracker and keep it alive until the last object file that uses it is finalized |
| Chierarchical_mutex | Hierarchical synchronization primitive that does not emit memory fences |
| Cidentity | Identity mapping function |
| Cidentity_member_pointer | Returns a member function pointer of type R (T::*)(Arg...) |
| Cindexed_handle_response | Function object to assign an object to a distributed object that accepts multiple objects via the Handle::set_value() function |
| Cindexed_response | Function object to assign an object to a known address that expects multiple objects |
| Cinstrument | Provides instrumentation capabilities for runtime functions |
| Cintrusive_mpsc_queue | An intrusive lock-free MPSC (multiple producer, single consumer) queue |
| Cintrusive_mpsc_queue_hook | Hook for intrusive_mpsc_queue |
| Cis_appropriate_handle | Returns std::true_type if Handle can be used to call PMF, otherwise std::false_type |
| Cis_contiguous_iterator | If T is an iterator to a container that its elements are in contiguous space it is equivalent to std::true_type, for any other iterator it is std::false_type |
| Cis_copyable | Typedefs member type to std::true_type if T is a copyable type, otherwise it typedefs it to std::false_type |
| Cis_known_polymorphic | Returns if a type T has polymorphic_callable defined |
| Cis_movable | Typedefs member type to std::true_type if T is a movable type, otherwise it typedefs it to std::false_type |
| Cis_reference_wrapper | Returns if T is a std::reference_wrapper<> or boost::reference_wrapper |
| Cis_reference_wrapper_impl | Returns if T is a std::reference_wrapper<> or boost::reference_wrapper |
| Cis_shared_ptr | Returns if T is a std::shared_ptr<> or boost::shared_ptr |
| Cis_shared_ptr_impl | Returns if T is a std::shared_ptr or boost::shared_ptr |
| ►Clocation_md | Location metadata |
| Cfence_md | Fence metadata for intragang requests |
| Clocation_rpc_aggregator | Aggregator for RPC requests to a single location |
| Clocation_rpc_executor | Executes RPC requests for a specific location, preserving the requests that could not be executed for a later invocation |
| Clocation_rpc_request | Encapsulates an RPC request directed to a location for subsequent execution via the function operator |
| Clogical_clock | Implements a logical clock for managing epochs |
| Cmailbox | Mailbox for multiple threads with arbitrary numbering |
| Cmake_arg_storage | Argument storage type creation metafunction |
| Cmake_arguments< F, T... > | Metafuction for creating a tuple of arg_storage_t to store the objects in list T |
| ►Cmalloc_allocator | An allocator that uses std::malloc() directly |
| Crebind | Provides a way to obtain an allocator for a different type |
| Cmanaged_locations_info | Container that associates parent gang to child gang location ids only for locally managed locations |
| Cmanaged_locations_rpc_aggregator | Aggregator for RPC requests to all locations in shared memory |
| Cmeets_requirements_oarchive | Archive to determine if the object meets the packing requirements |
| Cmemory_allocator | Provides interfaces to do pool allocation for objects |
| ►Cmessage | Communication buffer |
| Cheader_type | Message header |
| Cmessage_delete | Deleter for message objects |
| Cmessage_handle | This class is used to keep track of the handles associated with a message |
| Cmessage_shared_ptr | Intrusive message shared pointer |
| Cmessage_slist | Intrusive message list |
| Cmovable | Tag type for objects that for which is_movable is std::true_type |
| Cmoved_cref_storage | Storage for a moved object that is retrieved by const reference |
| Cmoved_object_storage | Storage for an object that is moved and retrieved either by copy or by rvalue reference |
| Cmoved_ref_storage | Storage for a moved object that is retrieved by reference |
| Cmpe_profiler | Notifies MPE of a new instrumented section |
| Cmpi_communicator | Implements a communicator based on MPI-2 |
| Cnc_async_rmi_request | RMI request that discards the return value |
| Cnested_wf | Function object to create a new threads-only environment |
| Cno_context_t | Tag type to skip any operations related to a context |
| Cno_implicit_flush_t | Tag type to mark that a flush is not implicit |
| Cnon_const_arg_storage | Storage for a non-const, non-basic, non-distributed object that is retrieved by non-const lvalue reference to non-basic object |
| Cnon_const_ptr_storage | Storage for a pointer to non-const, non-basic, non-distributed object that is retrieved by pointer to a non-const, non-basic object |
| Cobject_storage | Storage for objects used in communication over shared memory |
| Cobject_virtual_address | Distributed object virtual address |
| Cp_object_ptr_cast_impl | Casts the void pointer to pointer to T |
| Cp_object_ref_storage | Storage for an lvalue reference to a distributed object |
| Cpacked_handle | Packs rmi_handle::reference and rmi_handle::const_reference for use in requests |
| Cpacked_handle_epoch | Packs rmi_handle::reference and rmi_handle::const_reference and the epoch for use in requests |
| Cpacked_object_storage | Storage for object of type T used in communication |
| Cpacked_value | Handles unpacking objects stored in an arg_storage |
| Cpapi_clock | Represents a clock based on PAPI_get_real_usec() |
| Cpapi_cycle_clock | Represents a clock based on PAPI_get_real_cyc() and MHz |
| Cpoly_destroy | Calls typer_traits::destroy() for polymorphic types |
| Cpoly_meets_requirements | Calls the requested function from typer_traits for polymorphic types |
| Cpoly_pack | Calls typer_traits::pack() for polymorphic types |
| Cpoly_packed_size | Calls typer_traits::packed_size() for polymorphic types |
| Cpoly_unpack | Calls for typer_traits::unpack() for polymorphic types |
| Cpool | Pool of memory chunks of a specific size |
| Cprimitive_traits | Traits for primitives |
| Cread_lock_guard | Lock guard for read lock ownership |
| Cread_lock_t | Tag type for read lock ownership |
| Cready_future | future_base implementation for ready values |
| Cready_futures | futures_base implementation for ready values |
| Creduce | Distributed memory collective reduce |
| Creduce_rmi_handle | Handle to wait for values from reduce_rmi() |
| Creduction | Shared memory reduction using atomic counter. Last thread through does serial reduction and returns true, signaling value is ready for consumption |
| Cref_counted | Provides a reference counting mechanism for objects that derive from it |
| Cref_counted_range | Provides a range-based interface for ref_counted derived objects |
| Cref_counted_wrapper | Wrapper over T to make it conformable with ref_counted |
| Crequest_queue | Request queue |
| Cresponse | Function object to assign an object to a known address |
| Cresponse_aggregator | Aggregator for responses to requests |
| Crestore_request | Request for restoring an SPMD section |
| Crmi_delegate | Delegate for an RMI request |
| Crmi_executor | Executes RMI requests for a specific context, preserving the requests that could not be executed for a later invocation |
| Crmi_handle_base | Distributed object base handle |
| Crmi_handle_extended_base | Extended distributed object handle information |
| Crmi_handle_info | Distributed object handle information |
| Crmi_request | Encapsulates an RMI request for subsequent execution via the function operator |
| Crpc_aggregator | Aggregator for RPC requests to a process or a range of processes |
| Crpc_executor | Executes RPC requests for a process |
| Crpc_request | Encapsulates an RPC request directed to a process for subsequent execution via the function operator |
| ►Crunqueue | Queue for scheduling requests |
| Cimpl | Location RMI and RPC runqueue |
| Clock_type | Locks the runqueue at construction, unlocks at destruction |
| Crunqueue_gang_id_comparator | Less than equal comparator for runqueue::impl and gang ids |
| Cruntime_error | Runtime error exception object |
| Crval_storage | Storage for an object that is retrieved by rvalue reference |
| Cshared_object_factory | Factory for creating object shared between threads |
| ►Cshared_runqueue | Runqueue shared among locations of a gang that are on the same process |
| Cimpl | Shared runqueue implementation |
| Csingle_location_construct_request | Request to construct an object in a new single location gang |
| Csize_oarchive | Archive to calculate the size an object needs for packing |
| Cspmd_registry | Registry for SPMD-registered objects |
| Cstack | Thread stack information object |
| Csupports_stapl_packing | Returns std::true_type if typer_traits specialization exists for T or T::define_type(stapl::typer&) is defined |
| Csupports_stapl_packing_impl | Returns std::true_type if typer_traits specialization exists for T or T::define_type(stapl::typer&) is defined |
| Csync_rmi_request | RMI request that calls the given callback with the return value of the function |
| Ctask_queue< R(Args...)> | A lock-free MPSC (multiple producer, single consumer) queue of tasks to be executed |
| Cthin_spin_mutex | Spin-based synchronization primitive that does not emit memory fences |
| Cthread_info_t | Thread information |
| Ctimer | Provides a timer mechanism |
| Ctl_pools | Thread local memory chunk pools |
| Ctopology | Describes the topology of the processes of a gang |
| Ctransport_qualifier | Tags T with movable, copyable, or leaves it T |
| Ctry_rmi_request | RMI request that will not execute if the distributed object has been destroyed and that discards the return value |
| Ctunnel_aggregator | RMI request aggregator for a single destination location |
| Cuint_rng | Returns a suitable random number generator for the given unsigned integral type size |
| Cvalue_handle | Handle for receiving one result |
| Cvalues_handle | Handle for receiving multiple results |
| Cwrite_lock_t | Tag type for write lock ownership |
| ►Nsequential | |
| ►Ndetail | |
| Cconst_bitset_set_index_iterator | Iterator over only the active indices that are set to 1 in a bitset |
| ►Nhops_detail | |
| Chops_visitor | Find all of the vertices that are no more than m_limit hops away from the source vertex |
| C__CCVID_Compare | A comparator work function that returns x>y |
| C_compare_pair_vid | Compare two values |
| C_hei | Helper to infer the return property (const or non const) depending on the constness of the edge iterator |
| C_hei< Value & > | Helper to infer the return property (non const) if edge iterator is non const |
| C_hei< Value const & > | Helper to infer the return property (const) if edge iterator is const |
| C_hei_it | Helper to infer the return property (const or non const) depending on the constness of the edge iterator |
| C_hei_it< Value & > | Helper to infer the return property (non const) if edge iterator is non const |
| C_hei_it< Value const & > | Helper to infer the return property (const) if edge iterator is const |
| C_hei_usr_prop | Helper to infer the user property (const or non const) |
| C_hei_usr_prop< const Value & > | Helper to infer the user property (const or non const). Specialized for const |
| C_hei_usr_prop< Value & > | Helper to infer the user property (const or non const). Specialized for non-const |
| C_init_in_degree_map | Initializes the in-degree map for a topological traversal |
| C_init_in_degree_map< Graph, Visitor, InDegreeMap, Buffer, true > | Initializes an in-degree map for an input graph, to be used in a topological sort. This function defines the behavior when the boolean value in the template parameters is true. Instead of manually finding the in-degree of each node, this function assumes that the vertices have a list of their predecessors, and the in-degree is taken as the size of this list |
| C_visitor_cc_edges | Store and provide access to the edges between the connected components |
| Cadj_edge_iterator_adaptor | Class to provide an adaptor for the adjacent edge iterator |
| Cadj_graph_traits | Default traits for the sequential graph.The adjacency list is used by default, with vector storage for vertices and their adjacent edges, and integral vertex descriptors |
| Cadj_graph_traits_list_storage | Traits for the sequential graph with "smart" list storage.The adjacency list is used by default, with smart-list storage for vertices and their adjacent edges, and smart vertex descriptors. A "smart" list storage keeps versioning information for the graph, using which "smart" vertex descriptors can return iterators to their vertices in O(1) time. Smart vertex descriptors store iterators to their vertices inside, and return that iterator if the version matches the version of the graph |
| Cadj_graph_traits_vector_storage | Traits for the sequential graph with "smart" vector storage.The adjacency list is used by default, with smart-vector storage for vertices and their adjacent edges, and smart vertex descriptors. A "smart" vector storage keeps versioning information for the graph, using which "smart" vertex descriptors can return iterators to their vertices in O(1) time. Smart vertex descriptors store iterators to their vertices inside, and return that iterator if the version matches the version of the graph |
| Cadj_graph_traits_vector_storage_intVD | Traits for the sequential graph with vector storage.The adjacency list is used by default, with vector storage for vertices and their adjacent edges, and integral vertex descriptors |
| Cadj_map_int | Traits for the sequential graph with map storage.The adjacency list is used by default, with map storage for vertices and vector storage for their adjacent edges, and integral vertex descriptors |
| Cadjacency_descriptor_impl | Adjacency list of a vertex |
| Cadjacency_list_graph | Adjacency list implementation of the sequential graph |
| Cbgl_adaptor_traits | Default traits for the bgl_adaptor |
| Cbgl_edge_descriptor_adaptor | STAPL adaptor for the BGL edge descriptor |
| Cbgl_edge_iterator_adaptor | STAPL adaptor for the BGL edge iterator |
| Cbgl_edge_reference | BGL edge reference wrapper |
| Cbgl_graph | Core graph implementation based on BGL |
| Cbgl_ve_view | View on the vertices. The vertices are accessible with iterators |
| Cbgl_vertex_iterator_adaptor | STAPL adaptor for the BGL vertex iterator |
| Cbgl_vertex_reference | BGL vertex reference wrapper |
| Cbitset | A sequential compressed set of bits, where each bit can be individually accessed |
| Ccompute_short_edge_type | Metafunction to compute the short edge type from a full edge edge |
| Cconst_bgl_edge_iterator_adaptor | STAPL adaptor for the BGL edge iterator. |
| Cconst_bgl_edge_reference | BGL edge reference wrapper. |
| Cconst_bgl_vertex_iterator_adaptor | STAPL adaptor for the BGL vertex iterator. |
| Cconst_bgl_vertex_reference | BGL vertex reference wrapper. |
| Cconst_dpg_vertex_iterator_adaptor | Class to provide a const adaptor for the vertex iterator over a directed_preds_graph |
| Cconst_dpg_vertex_reference | Class to provide a const reference to a vertex object for the directed_preds_graph.Provides the interface of a graph vertex, with additional functionality for working with predecessors. This is the type returned when a const vertex iterator is dereferenced |
| Cconst_vdata_iterator | Const vertex data iterator to iterate over the vertex properties. Dereferencing provides the vertex property |
| Cconst_vertex_iterator_adaptor | Class to provide a const adaptor for the vertex iterator |
| Cd_ary_heap_indirect | Implementation of d-ary heap, copied from boost/graph/detail/d_ary_heap.hpp and modified |
| CDG | Class implementing a directed graph |
| Cdirected_preds_graph | Class implementing a directed graph with predecessors.A directed predecessor graph extends the graph hierarchy with methods to maintain predecessors. Methods like add/delete vertex/edges add some overhead. The directed with predecessors graph is an extension of the STAPL graph. The property associated with each vertex is an extended property where one of the fields is the list of predecessors. The directed with predecessors graph will overload add/delete vertex/edge to update this field. The vertex property is wrapped inside an internal property that is used to track predecessors info. For most part this is invisible to the user |
| Cdpg_vertex_iterator_adaptor | Class to provide an adaptor for the vertex iterator over a directed_preds_graph |
| Cdpg_vertex_reference | Class to provide a reference to a vertex object for the directed_preds_graph.Provides the interface of a graph vertex, with additional functionality for working with predecessors. This is the type returned when a vertex iterator is dereferenced |
| Cedge_iterator_adaptor | Class to provide an adaptor for the edge iterator.An edge iterator allows traversal of all (out)edges in the graph. It does this by iterating over all adjacent edges of one vertex, moves to the next vertex and so on. There is no guaranteed order of edge traversal. In undirected graphs only one edge of a pair of sibling edges will be traversed |
| Cedge_property_map | The edge property map that maps each edge in a set to an edge property |
| Cedge_reference | Class to provide a reference to an edge object.Provides the interface of a graph edge. This is the type returned when a adj/edge iterator is dereferenced |
| Ceiwfunc_comp | Compares the properties of two edges |
| Cgraph | The STAPL sequential graph class.Inherits from a number of classes as specified in the traits class |
| Cgraph_edge | The Graph Edge without edge property storage |
| Cgraph_external_property_map | The graph external property map class, which maps each element in a container to a property |
| Cgraph_property_edge | The Graph Edge with edge property storage |
| Cgraph_type | Helper class using partial template specialization to translatefrom a flag (DIRECTED, UNDIRECTED, MULTIEDGES, NONMULTIEDGES) to its corresponding class (DG, UG, MG, NMG) |
| Cgraph_type< Traits, DIRECTED > | Helper class using partial template specialization to translate from a flag (DIRECTED, UNDIRECTED, MULTIEDGES, NONMULTIEDGES) to its corresponding class (DG, UG, MG, NMG) Specialized for Directed graph |
| Cgraph_type< Traits, MULTIEDGES > | Helper class using partial template specialization to translate from a flag (DIRECTED, UNDIRECTED, MULTIEDGES, NONMULTIEDGES) to its corresponding class (DG, UG, MG, NMG) Specialized for Multiedges graph |
| Cgraph_type< Traits, NONMULTIEDGES > | Helper class using partial template specialization to translate from a flag (DIRECTED, UNDIRECTED, MULTIEDGES, NONMULTIEDGES) to its corresponding class (DG, UG, MG, NMG) Specialized for Non-Multiedges graph |
| Cgraph_type< Traits, UNDIRECTED > | Helper class using partial template specialization to translate from a flag (DIRECTED, UNDIRECTED, MULTIEDGES, NONMULTIEDGES) to its corresponding class (DG, UG, MG, NMG) Specialized for UnDirected graph |
| Chgraph_select_vertex | Helper for selecting the vertex implementation depending on if the hierarchical graph is with or without properties on vertices |
| Chgraph_select_vertex< VD, AdjList, properties::no_property > | Specialization of helper hgraph_select_vertex for selecting the vertex implementation with property storage of type no_property if the property is not specified |
| Chgraph_vertex_impl | Vertex for adjacency list for the hierarchical_graph.It contains a descriptor and an adjacency list of edges, as well as a set of children vertices for this graph |
| Chgraph_vertex_property_impl | Vertex for adjacency list for the hierarchical_graph with property.It contains a descriptor and an adjacency list of edges, and extends the hgraph_vertex_impl class with data/methods related to the property field |
| Cinternal_scc_color_func | Object that allows for manipulation of the color property |
| Cinternal_scc_property | Object that stores the color and status properties |
| Cis_bidirectional_view | Type-checker to see if an instantiation is a bidirectional view |
| Cmap_property_map | A specialized external property map class, which uses a std::mad as the container type |
| CMG | Class implementing a multiedges graph.A multiedges graph allows multiple edges between the same source and target vertices |
| Cmit_adaptor | Iterator adaptor for using a map for vertex storage |
| Cmit_const_reference | Specialization of helper to construct the type of the const reference used by adjacency list using map for vertex storage |
| Cmit_pointer | Specialization of helper to infer the return property pointer (const or non const) for non const value, used by adjacency list using map for vertex storage |
| Cmit_pointer< const Value & > | Specialization of helper to infer the return property pointer (const or non const) for const value, used by adjacency list using map for vertex storage |
| Cmit_reference | Specialization of helper to infer the return property reference (const or non const) for non const value, used by adjacency list using map for vertex storage |
| Cmit_reference< const Value & > | Specialization of helper to infer the return property reference (const or non const) for const value, used by adjacency list using map for vertex storage |
| Cn_iterations | Keeps track of the number of iterations that have been run. Will return true after n iterations have passed |
| CNMG | Class implementing a non-multiedges graph.A non-multiedges graph does not allow multiple edges between the same source and target vertices |
| Cpreds_property | Wrapper property around user specified property to maintain predecessors information |
| Cscc_helper | Compute the strongly-connected components of the graph by building the reverse graph and performing a breadth-first search on it |
| Cscc_helper< VGraph, ColorMap, true > | If the graph is bidirectional, do nothing |
| Cselect_adj_edge_iterator | Selector class for adjacent edge iterator |
| Cselect_const_adj_edge_iterator | Selector class for const adjacent edge iterator |
| Cselect_const_vertex_iterator | Selector class for const vertex iterator.Other graphs may specialize the iterator type, and in order to do that they have to specialize based on the particular property type |
| Cselect_const_vertex_iterator< Iterator, preds_property< VD, UserProperty > > | Selector class for vertex iterator for directed_preds_graph |
| Cselect_edge | Helper for selecting the edge implementation based on property on edge and directedness of graph |
| Cselect_edge< VertexDescriptor, properties::no_property, DIRECTED > | Helper for selecting the edge implementation based on property on edge and directedness of graph. Specialized for when the graph is directed and the edge property is no_property |
| Cselect_edge< VertexDescriptor, properties::no_property, UNDIRECTED > | Helper for selecting the edge implementation based on property on edge and directedness of graph, specialized for undirected graph.Other specializations for directed are in adj_list_vertex_edge.h |
| Cselect_edge< VertexDescriptor, Property, UNDIRECTED > | Helper for selecting the edge implementation based on property on edge and directedness of graph, specialized for undirected graph.Other specializations for directed are in adj_list_vertex_edge.h |
| Cselect_vertex | Helper for selecting the vertex implementation depending on if the graph is with or without properties on vertices |
| Cselect_vertex< VD, properties::no_property, AdjList > | Specialization of helper select_vertex for selecting the vertex implementation with property storage of type no_property if the property is not specified |
| Cselect_vertex_iterator | Selector class for vertex iterator.Other graphs may specialize the iterator type, and in order to do that they have to specialize based on the particular property type |
| Cselect_vertex_iterator< Iterator, preds_property< VD, UserProperty > > | Selector class for vertex iterator for directed_preds_graph |
| Cshort_graph_edge | A short graph edge with no property |
| Cshort_graph_property_edge | A short graph edge with a property |
| CUG | Class implementing an undirected graph |
| Cundirected_edge_helper | Helper class for undirected graph.Edge descriptors are created with a special flag, and edge properties are cleared differently than for directed graph |
| Cundirected_edge_helper< EdgeDescriptor, Iterator, properties::no_property > | Helper class for undirected graph.Edge descriptors are created with a special flag, and edge properties are cleared differently than for directed graph |
| Cundirected_graph_edge_property | The Graph Edge with edge property storage for an undirected graph.If the graph uses no_property for the edge property type, then the graph edge contains just the edge_descriptor_impl. If the graph is with properties then the edge contains an edge_descriptor_impl and the property. The property of the edge for undirected graphs is stored as a pointer and shared between two sister edges, because edges will always be added in pairs and they will have to have the same property |
| Cvd_iterator | Vertex descriptor iterator. Dereferencing provides the vertex descriptor |
| Cvdata_iterator | Vertex data iterator to iterate over the vertex properties. Dereferencing provides the vertex property |
| Cvdg_base_int | Base class for vertex descriptor generators.This class will generate unique vertex descriptors, taking into account that the graph may auto generate them, as well as the users may specify them. This is used by vdg_storage_int to generate/delete/find vertices |
| Cvdg_base_list | A vertex descriptor generator class that generates the descriptors for the smart list storage, and tracks the version number of descriptors |
| Cvdg_base_vector | A vertex descriptor generator class that generates the descriptors for the smart vector storage, and tracks the version number of descriptors |
| Cvdg_map_int | An adjacency list using an std::map for storing vertices. Used inside the adjacency_list_model to store vertices |
| Cvdg_storage_int | An adjacency list using an std::vector for storing vertices. Used inside the adjacency_list_model to store vertices |
| Cvdg_storage_list | An adjacency list using an std::list for storing vertices. Used inside the adjacency_list_model to store vertices |
| Cvdg_storage_vector | An adjacency list using an std::vector for storing vertices. Used inside the adjacency_list_model to store vertices |
| Cve_view | Wrapper to provide an edge view for the adjacents of a vertex |
| Cvector_property_map | A specialized external property map class, which uses a vector as the container type |
| Cvertex_descriptor_list | Self-maintaining vertex descriptors.These descriptors implement versioning and keep an iterator to the vertex. They can be used by the versioned graphs to extract the vertex object in constant-time if their version matches the graph's |
| Cvertex_descriptor_vector | Self-maintaining vertex descriptors.These descriptors implement versioning and keep an iterator to the vertex. They can be used by the versioned graphs to extract the vertex object in constant-time if their version matches the graph's. Versioned graphs store additional versioning information that is updated whenever the graph performs operations that may invalidate iterators |
| Cvertex_impl | Vertex for adjacency list for the graph |
| Cvertex_iterator_adaptor | Class to provide an adaptor for the vertex iterator |
| Cvertex_pointer | Class to provide a pointer to a vertex object |
| Cvertex_property_impl | Vertex for adjacency list for the graph with property |
| Cvertex_property_map | The vertex property map class, which maps a set of vertices to a set of properties |
| Cvertex_reference | Class to provide a reference to a vertex object.Provides the interface of a graph vertex. This is the type returned when a vertex iterator is dereferenced |
| Cvisitor_back_edges | Finds the back edges in a graph |
| Cvisitor_cc | Add the current vertex to the connected component's vector of vertex descriptors |
| Cvisitor_cc_count | Count the number of vertices in the connected component |
| Cvisitor_compute_finish_time | Calculate the 'time' needed to finish computation on each vertex |
| Cvisitor_compute_scc | Add a discovered vertex to its strongly-connected component |
| Cvisitor_cycle | Checks for cycles in a directed graph. It does so by returning EARLY_QUIT if a visitor is visiting a node that has already been visited |
| Cvisitor_samecc | Determine which connected component the given vertex is in |
| Cvisitor_scc_back | Takes a vertex and marks it as discovered while moving backward |
| Cvisitor_scc_fwd | Takes a vertex and marks it as discovered while moving forward |
| Cwfunc_comp | Takes two vertex descriptors and compares their entries in a map |
| ►Nsgl | |
| ►Ndetail | |
| Cexecute_visitor | Helper to invoke the correct execution strategy based on the provided policy |
| Cmake_empty_frontier_impl | Implementation for making an empty frontier |
| Cmake_empty_frontier_impl< Container, frontier_type::bitmap, true > | Implementation for making an empty frontier |
| Cmake_empty_frontier_impl< Container, frontier_type::implied, HasContiguousDomain > | Implementation for making an empty frontier |
| Cmake_empty_frontier_impl< Container, frontier_type::unordered_set, HasContiguousDomain > | Implementation for making an empty frontier |
| Cpromotion_visitor | Helper class used to promote an execution policy |
| Casync_policy | Graph execution policy to execute a traversal asynchronously |
| Ccompute_gid_set_type | Compute the GID set storage type that is appropriate for a graph algorithm, based on the algorithm's ordering requirements and superstep occupancy information |
| Ccompute_gid_set_type< frontier_type::vector, ordering_type::interleaved, SuperstepOccupancy > | Specialization for when the algorithm requires that the frontier be a unique set and the requested GID set is a vector store. In such a case, it is necessary to use an unordered_set instead of a vector |
| Ccompute_gid_set_type< FrontierType, OrderingType, always_active_superstep_occupancy_type > | Specialization for when every superstep processes every vertex. In such a case, the implied GID set storage is the best choice |
| Cexecution_policy_base | Base class for all SGL execution policies |
| Cexecution_policy_builder | Builder class to build an execution policy instance |
| Cfirst_superstep_has_all_vertices | Metafunction to compute whether the given occupancy specification denotes that the first superstep contains all vertices |
| Cfrontier_function_apply | Work function to apply the user's initialization operator to every vertex in the graph and to add active vertices to the frontier |
| Chas_strong_concurrency_model | Metafunction to determine whether an SGL algorithm has a strong concurrency model based on its vertex operator |
| Ckla_policy | Graph execution policy to execute a traversal using the k-level-asynchronous strategy |
| Clevel_sync_policy | Graph execution policy to execute a traversal level-synchronously |
| Cnoop_vp_reducer | A dummy vertex-property reducer for algorithms that don't use the hubs policy |
| Coperator_concurrency_model | Metafunction to extract the concurrency model of an SGL algorithm based on its vertex operator |
| Coperator_concurrency_model< VertexOp, false > | Default value for when there is no concurrency model specifed |
| Csparse_frontier | Set of active vertices during a traversal |
| Cstrong_concurrency | Tag to specify a strong concurrency model |
| Cweak_concurrency | Tag to specify a weak concurrency model |
| ►Nskeletons | |
| ►Ndetail | |
| Cemit_flow | Emit inline flows for a skeleton, given a current state |
| Cemit_serial_part | Emit inline flows for a skeleton inside a ser_t |
| Cemit_state | Represents the current state of the emit flows computation |
| Cpar_fold | The binary operation used for emitting skeletons in a par_t as a fold |
| Crip_skels_impl | Helper struct to extract the skeletons as a tuple |
| Cser_fold | The binary operation used for emitting skeletons in a ser_t as a fold |
| Cshift_fold | The binary operation used for emitting skeletons in a shift_t as a fold |
| Cspread_to_par | Given an tuple of input phs and parallel skeletons, either zip them together or if there's only one input, use it for all |
| ►Nfilters | |
| Cfilter | Filters are used in the skeleton library in order to reduce the size of the coordinate vectors being passed around |
| Cfilters_wrapper | A wrapper class for value filter and should flow filter |
| ►Nflows | |
| ►Ncompose_flows | |
| Cinput_to_all | An input_to_all flow for a compose is similar to compose_flows::piped, but in addition it pipes the input flow of the compose to the rightP as well |
| Cinput_to_last | A very common flow used in many algorithms is when the last input is forked and passed to the last skeleton in the sequence. Examples of this flow can be seen in scan and sink |
| Clast_input_to_all | An last_input_to_all flow for a compose takes the first n-1 flows in the given flow tuple given as an input to the compose and connects it to the input flow of the first skeleton in the compose. It then pipes the output of each skeleton to its next skeleton, and in addition passes the last flow given to the compose to every enclosed skeleton |
| Cpiped | A piped flow for a compose, pipes the input flow of the compose to the in flow of the left skeleton. The output flow of the left skeleton to the input flow of right skeleton. Finally, it pipes the output flow of the right skeleton to the output flow of the compose |
| Cscan | A simplified compose flow for scans. The same flow can be written as compose<input_to_last>(compose(a, b), c). This is done to reduce compilation time while maintaining expressivity of this simple case |
| ►Ndo_while_flows | |
| Cpiped | A piped flow for a do_while skeleton, connects the out flow of each iteration to the input of the next iteration, and connects the input of the do_while skeleton to the first iteration of the while loop. It also connects the output of the do_while skeleton to the output of the last iteration |
| ►Nelem_f | |
| Cdoacross | Doacross elementary flow considers all elements inside of it as connectable entities in the dependence graph, whether each node is connected or not in the dependence graph, depends on the underlying skeleton |
| Cdoall | Doall elementary flow considers all elements inside of it as connectable entities in the dependence graph, whether each node is connected or not in the dependence graph, depends on the underlying skeleton |
| Celem_in_port | An elementary input port which is the default input port of elementary skeletons is a single dimension input port which allows simply redirects the consumer_count requests to its underlying parametric dependency |
| ►Nflows_impl | |
| Cwrap_domain | Wraps a domain in a domain_wrapper if it is not already wrapped by one with the same is_scalar template parameter |
| ►Ninline_flows | |
| ►Ndetail | |
| Ccompute_outputs_impl | Creates a map of placeholders to the list (tuple) of the skeleton placeholders that read from them and at which index |
| ►Nplaceholders | |
| Cinput | A placeholder for the inputs to a compose |
| Cis_input | A trait to detect if a given type is an input placeholder |
| Cx | A placeholder for the output of a composed skeleton |
| Cchange_tuple_element | Changes the type of a tuple at a given index |
| Ccompute_used_inputs | Computes a tuple of the input placeholders that are used from the result of compute_outputs_t |
| Cflow_tuple | Holds the placeholder names for the output of a skeleton and its inputs as well as a skeleton value |
| Cget_inputs_of | Gets the list of inputs for a given output in a tuple of ph_flow |
| Cinline_flow | A flows class that computes in and out flows based on the tuple of ph_flows parameter. The last skeleton is used as the output |
| Cinsert_into_multimap | Inserts a key-value pair or appends to the value if the key already exists in the map |
| Cinsert_into_multimap_at | Appends a value into a map (a tuple of pairs) at the given index or inserts a new key-value pair if index == -1 |
| Cph_flow | Holds an output placeholder and a list of its inputs |
| Cph_list | A list of placeholders that can be appended to with the comma operator |
| Cvalue_of_key | Computes the value of a key type in a map (a tuple of pairs) |
| ►Nrepeat_flows | |
| ►Nflows_impl | |
| Ccustom_flow | This is a customized flow over a an existing flow, that only converts the consumers_count request to 2D requests |
| Cinput_wrapper | An input_wrapper flow is used in various scan skeletons to convert a 1D input coordinate to a 2D coordinate by appending -1 to the coordinate it receives |
| ►Coutput_from_all | The output_from_all flow provides the output of each iteration not only to its next iteration but to the skeleton that comes after the repeat. In other words, all the tasks will provide data to the out flow, and the skeleton that comes after the current skeleton will be able to request reads from every element of this skeleton |
| Ccustom_flow | This is a customized flow over a repeat skeleton that accepts only 2D queries |
| Cpiped | A piped flow for a repeat skeleton, connects the out flow of each iteration to the input of the next iteration, and connects the input of the repeat skeleton to the first iteration of the while loop. It also connects the output of the repeat skeleton to the output of the last iteration |
| ►Cscan_broadcast | A scan_broadcast flow is a customized flow for a repeat skeleton. It connects the out flow of each iteration to the input of the next iteration, and in addition connects the first flow from the input flow to the repeat skeleton to the input flow of every iteration. For the last iteration it connects the last flow (back) of the input flow instead of the first flow |
| Ccustom_flow | This is a customized flow over a an existing flow, that only converts the consumers_count request to 2D requests. This is used for scan skeleton |
| ►Nview_flow_helpers | |
| Coffset_mapping_function | Mapping function used for redefining the view domains from zero |
| Coffset_mapping_function< indexed_domain< std::size_t, 1 > > | Mapping function used for redefining the view domains from zero, specification for 1 Dimension domains |
| Coffset_mapping_function< indexed_domain< std::size_t, n, T... > > | Mapping function used for redefining the view domains from zero, specification for N Dimensions domains |
| Cconstant_producer | A constant_producer is used as a wrapper for a constant value which is going to be passed to a task in a dependence graph. This class stores a copy of the value |
| Cdontcare_flow | You can think of a dontcare_flow as a flow that will discard any requests coming to it. If it is queried for consumers_count, it will return 0 and it also does not accept read requests |
| Cget_flow_modifier | A flow modifier that extracts the i'th flow from a flow tuple |
| Cindexed_flow< T, Domain, inter_pg, void > | An elementary flow representing the output of a single node in the dataflow graph corresponding to a single skeleton which allows a skeleton to be connected to all its underlying spawned tasks |
| Cindexed_producer | A indexed_producer is used as a wrapper for indexable producers in a dependence graph. This class offers the possibility of a filtered request from a producer |
| Cindexed_producers | A indexed_producers is used as a wrapper for indexable producers in a dependence graph. This class offers the possibility of a filtered request from a producer |
| Cmake_view_flow | Creates a view_flow over the given view |
| Cmake_view_flow< View, typename View::is_pg_port_view > | Specialization for flow backed by view backed by PARAGRAPH ports |
| Cnumbered_flow | Numbering the flows allows the user to identify each flow and perform the appropriate operations based on the given number |
| Cparagraph_producer | A paragraph_producer is used when the input view of the skeleton is a paragraph view(nested_pg_view_subview), which is the result of the execution of another paragraph being passed as input to this. The index of producer should be mapped since the given view is 1D for now. Furthermore we should keep the original index for computing the number of successors for each element in the view |
| Cpg_view_flow | Specialization when the flow is created over a view that is coming from a paragraph(nested_pg_view_subview) |
| Creflexive_producer | A reflexive_producer is used as a wrapper for using references as the producer to a task in a dependence graph. This producer is only used directly in do_while skeleton, and is not intended to be used often. This producer requires the task to be executed on the same memory space as the producer |
| Creflexive_producer< Element * > | A reflexive_producer is used as a wrapper for using references as the producer to a task in a dependence graph. This producer is only used directly in do_while skeleton, and is not intended to be used often. This producer requires the task to be executed on the same memory space as the producer. |
| Ctranspose_2d | AUTOMATICALLY GENERATED DOCUMENTATION |
| Cview_element_producer | A view_element_producer is used as a wrapper for view accesses by a task in a dependence graph. Therefore, it inherits from both indexed_producer and reflexive_producer. This producer is only used in do_while skeleton, and is not intended to be used often. This producer requires the task to be executed on the same memory space as the producer. Producer information is then used in various environments in order to create tasks, create visualization of dependence graphs, etc |
| Cview_element_producer< proxy< T, A > > | A view_element_producer is used as a wrapper for view accesses by a task in a dependence graph. Therefore, it inherits from both indexed_producer and reflexive_producer. This producer is only used in do_while skeleton, and is not intended to be used often. This producer requires the task to be executed on the same memory space as the producer. Producer information is then used in various environments in order to create tasks, create visualization of dependence graphs, etc. |
| Cview_flow | view_flow is a flow defined over a view in STAPL. It is used later on (upon the invocation of spawn_element) to retrieve an element from the enclosed view |
| Cview_flow< stapl::proxy< T, A > > | view_flow is a flow defined over a view in STAPL. It is used later on (upon the invocation of spawn_element) to retrieve an element from the enclosed view. |
| ►Noptimizers | |
| ►Nhelpers | |
| Cpack_has_iterator | Metafunction used to compute whether or not all of the views in a pack have a defined iterator type |
| Cincrement_by_one | Helper function to increment a single element |
| Coptimizer | A nested optimizer will spawn the skeleton in parallel allowing nested parallelism to be defined and exploited in a high level |
| Coptimizer< Tag, tags::nested_execution< true > > | An optimizer with the nested execution strategy, spawns the given skeleton (creates a data flow graph) |
| Coptimizer< tags::butterfly< B >, tags::sequential_execution > | A butterfly optimizer is used whenever the inputs are local. The knowledge of the inputs being local allows the usage of std::accumulate for a faster execution |
| Coptimizer< tags::reduce< Align >, tags::sequential_execution > | A reduce optimizer is used whenever the inputs are local to a nested execution which improves the performance |
| Coptimizer< tags::scan< Algorithm, tags::inclusive >, tags::sequential_execution > | A scan optimizer is used for the scan algorithm whenever the inputs are local to a location. This optimizer calls std::partial_sum to compute the results. You should notice that the allocation of space for the result value takes significant time for larger inputs and should be used with care |
| Coptimizer< tags::zip< Tag, arity >, tags::sequential_execution > | A zip optimizer is used in the cases that all views are local and their traversal would be fast which improves the performance. You have to notice that the inner vector creation takes some time and you have to consider it before using this optimizer |
| Coptimizer< tags::zip_reduce< arity >, tags::sequential_execution > | A zip_reduce optimizer is used in the cases that both views are local and their traversal would be fast which improves the performance |
| Coptimizer< tags::zip_reduce< arity >, tags::sequential_unroll< factor > > | A zip_reduce optimizer is used in the cases that both views are local and their traversal would be fast which improves the performance. Tagged with tags::sequential_unroll allows directs the optimizer to unroll the sequential loop with the specified factor |
| Cstatic_recurse_and_invoke | Helper class to iterate over a set of views one dimension at time, slicing at each dimension, and applying a function on view elements |
| Cstatic_recurse_and_invoke< 0, index_sequence< Indices... > > | Specialization for single dimension (last dimension) |
| Cstatic_recurse_and_invoke< Current, index_sequence< Indices... > > | |
| ►Czipper_domain | Zip optimizer traversal methods for when the views do not have iterators. Uses general domain traversal instead |
| Cnon_dynamic | Specialization of sequential execution when paragraph_view is not required by the zip operation |
| ►Czipper_iterator | Zip optimizer traversal methods for when the views have iterators |
| Cdynamic | Specialization of sequential execution when paragraph_view is required by the zip operation |
| ►Czipper_slice_loop_nest | Zip optimizer traversal methods for when the views do not have iterators, but are deep sliceable |
| Cnon_dynamic | Specialization of sequential execution when paragraph_view is not required by the zip operation |
| Czr_unroller | Helper recursive template that unrolls a zip_reduce loop (iterator based) by the specified factor |
| Czr_unroller< 1 > | Base case of the recurion. Call zip and reduction one more time |
| ►Nscan_helpers | |
| Cadd_to_all_op | This struct uses the Op and computes the result of the application of Op to the pair of an offset given by Value and elements of an input given by Values |
| Cback_op | This filter is used in naive coarsened version of scan to limit the size of data passed to the intermediate scan |
| Cfind_scan_update_phase_pd | The update phase in a coarsened scan adds the offset computed by the intermediate scan to the scan result of each chunk of data passed to it |
| Coffset_scan_copy_op< Op, tags::exclusive > | This operation is used in optimized version of coarsened exclusive scan. It computes the exclusive scan of an input, given an offset v and an input values, and immediately writes the result to a given output view |
| Coffset_scan_copy_op< Op, tags::inclusive > | This operation is used in optimized version of coarsened inclusive scan. It computes scan of an input, given an offset v and an input values, and immediately writes the result to a given output view |
| Coffset_scan_op | This operation is used in optimized coarsened scans. It computes scan of an input, given an offset v and an input values and returns the result of computation |
| Cpickfirst | This filter is used in naive coarsened scan to read the value which is filtered by back_op |
| ►Nskeletons_impl | This class abstracts the semantics of a reduce to location skeleton by exposing only the necessary information in its representation |
| ►Ngather_impl | |
| Cgather_op | The concatenation of input vectors used in the gather and allgather skeletons |
| ►Nscatter_impl | |
| Cscatter_filter | Filters the inputs in scatter tree into two halves. If the edge requesting the value from this filter is a downedge then the upper half of the input is returned. If not, the lower-half is returned |
| Cscatter_op | A scatter skeleton based on reverse_binary_tree is a no-op. The filtering of the input to this operation is done with the help of filters to reduce communication |
| Callgather | This class abstracts the semantics of an allgather skeleton by exposing only the necessary information in its representation |
| Callgather< T, Span, tags::reverse_butterfly< B > > | This class abstracts the semantics of an allgather skeleton by exposing only the necessary information in its representation |
| Callreduce | This class abstracts the semantics of an allreduce skeleton by exposing only the necessary information in its representation |
| Callreduce< Op, Span, tags::butterfly< false > > | This class abstracts the semantics of a butterfly-based allreduce skeleton by exposing only the necessary information in its representation |
| Callreduce< Op, Span, tags::reverse_butterfly< B > > | This class abstracts the semantics of a reverse-butterfly-based allreduce skeleton by exposing only the necessary information in its representation |
| Calltoall< T, Span, skeletons::tags::butterfly< false > > | This class abstracts the semantics of an alltoall skeleton by exposing only the necessary information in its representation |
| Calltoall< T, Span, tags::flat > | This class abstracts the semantics of a flat alltoall skeleton by exposing only the necessary information in its representation |
| Calltoall< T, Span, tags::hybrid > | This class abstracts the semantics of a hybrid alltoall skeleton by exposing only the necessary information in its representation |
| Calltoall< T, Span, tags::pairwise_exchange > | This class abstracts the semantics of a hybrid alltoall skeleton by exposing only the necessary information in its representation |
| Calltoall_filter | The filtering used in hybrid, flat, and pairwise exchange alltoalls for sending only the requested part to other participants |
| Calltoall_filter< T, tags::butterfly< B > > | A specific filtering used in recursive-doubling (butterfly) implementation of all_to_all |
| Calltoall_merge | The workfunction used in flat and hybrid alltoall for merging the incoming messages |
| Calltoall_merge< T, tags::butterfly< B > > | Merges the results from two given inputs by putting one chunk of size butterfly_size from the first and then the same size from the second until both inputs are exhausted |
| Calltoall_merge< T, tags::pairwise_exchange > | The workfunction used in pairwise exchange alltoall for merging the incoming messages |
| Calltoall_pd< T, tags::flat > | In a flat alltoall, parametric dependencies are defined in such a way that each node depends on every node in the producer |
| Calltoall_pd< T, tags::hybrid > | The hybrid alltoall parametric dependency is used for alltoall skeleton in the cases of having large messages. The parametric dependency in this case is defined as a hybrid of the flat and butterfly-based version of alltoall |
| Calltoall_pd< T, tags::pairwise_exchange > | In a pairwise exchange alltoall, parametric dependencies are defined in such a way that each node depends on every node in the producer |
| Cbinary_tree< Op, Flows, Span, Tag, false > | This class abstracts the semantics of a non-complete binary tree by exposing only the necessary information in its representation |
| Cbinary_tree< Op, Flows, Span, Tag, true > | This class abstracts the semantics of a complete binary tree by exposing only the necessary information in its representation |
| Cbinary_tree_pd | This binary tree parametric dependency is one of the several possible parametric dependencies that can be used in a binary tree. This parametric dependency is used with tree in order to create reduction trees. This parametric dependency can have different layouts which are determined by the given Tag |
| Cbinomial_tree_pd | This reduce parametric dependency is one of the several possible parametric dependencies that can be used in reduction |
| Cbitonic_sort_pd | The bitonicsort parametric dependency defines the dependencies for each point in the global bitonicsort skeleton. At each local point either a minimum or a maximum will be computed depending on where this point is located in the global skeleton. This will be described in the Op |
| Cbitreversal | This class abstracts the semantics of an bitreversal skeleton by exposing only the necessary information in its representation |
| Cbitreversal_pd | A bitreversal parametric dependency used in the bitreversal skeleton |
| Cbroadcast | This class abstracts the semantics of a broadcast skeleton by exposing only the necessary information in its representation |
| Cbutterfly | This class abstracts the semantics of a butterfly skeleton by exposing only the necessary information in its representation |
| Cbutterfly_pd | A butterfly parametric dependency defines the dependencies for each element in a big butterfly skeleton. Some algorithms that use butterfly_pd need to know the location of the element in the big butterfly skeleton. An example is DIT FFT algorithm that changes the computation based on the location of the parametric dependency. For the same reason is_position_aware should be specified by user in such cases. In addition, in some cases one would like to read partially from the inputs on a butterfly. That's when the the F (filter) can be used |
| Ccompose | Compose operator groups the given skeletons together and performs the spawning process in the order of composition (P0, P1, ... Pn). The spawning process starts from the first skeleton (P0) and continues until the last skeleton(Pn) is spawned |
| Ccompute_return_type | The return type to be determined for an optimizer by passing the fine-grain type |
| Cdefault_execution_params | Default execution parameters |
| Cdefault_skeleton_traits | Default skeleton traits |
| Cdo_while | Do-while is a composite skeleton that repeats a skeleton for a number of iterations. This number is determined by evaluating the ContinuationP after every iteration |
| Cdo_while_pd | A do_while parametric dependency represents an element in the dependence graph that controls if the next iteration of a do-while loop should be spawned or not. It does that by wrapping user's ContCond by do_while_stub with and sending memento_stack to it |
| Cdo_while_stubs | There are three elements pushed on the top of the memento when this method is invoked. Two of them stand for the current iteration and one is for the one that comes after this iteration |
| Celem | Every parametric dependency is wrapped by this class in order to represent an executable, expandable skeleton. This class has a generic interface for spawning parametric dependencies, and for accessing the flows connected to each node |
| Cexclusive_scan< Op, T, tags::blelloch > | Blelloch scan is an exclusive scan algorithm which is similar to the inclusive scan mentioned in Joseph Jaja's book ( |
| Cexecution_params | Stores the execution parameters to be used for running a a skeleton in STAPL. These parameters are currently: |
| Cexpand_from_pow_two | This class abstracts the semantics of an expansion skeleton by exposing only the necessary information in its representation |
| Cexpand_from_pow_two< Op, Span, pos_aware, stapl::use_default, SetResult > | This class abstracts the semantics of an expansion skeleton by exposing only the necessary information in its representation |
| Cexpand_from_pow_two_pd | This parametric dependency is used in the postprocessing phase of various algorithms that only accept power-of-two input sizes |
| Cfake_flow | A fake_flow is used for making the result_type computation possible for wrapped skeletons (wrapped_skeleton) |
| Cfake_flow< mix_view< V, I, CID >, true > | A fake_flow is used for making the result_type computation possible for wrapped skeletons (wrapped_skeleton) |
| Cfake_flow< nfast_view< V >, true > | A fake_flow is used for making the result_type computation possible for wrapped skeletons (wrapped_skeleton) |
| Cfake_flow< paragraph_impl::paragraph_view< V >, true > | A fake_flow is used for making the result_type computation possible for wrapped_skeletons |
| Cfarm_init | Wraps the user provided generator for a farm and passes the farm instance upon invocation to the generator |
| Cfarm_pd | This parametric dependency is used in farms skeleton to generate the initial seeds of computation |
| Cfarm_stub | Wraps the environment used in the current spawning process and provides farm functionality to the user workfunctions |
| Cfft | This class abstracts the semantics of an FFT skeleton by exposing only the necessary information in its representation |
| Cfft< T, Span, tags::dif > | This class abstracts the semantics of a Decimation In Frequency (DIF) FFT skeleton by exposing only the necessary information in its representation |
| Cfft< T, Span, tags::dit > | This class abstracts the semantics of a Decimation In Time (DIT) FFT skeleton by exposing only the necessary information in its representation |
| Cfft_dif_wf | This workfunction is used for Decimation In Frequency FFT (DIF) computation |
| Cfft_dit_wf | This workfunction is used for Decimation In Time FFT (DIT) computation |
| Cgather | This class abstracts the semantics of a gather skeleton by exposing only the necessary information in its representation |
| Chand_execute_impl | Execute a skeleton in place with a set of views |
| Chand_execute_impl< stapl::skeletons::skeletons_impl::zip_reduce< 1, ZipOp, ReduceOp >, View > | Execute a zip_reduce with one view in place |
| Cinclusive_scan< Op, tags::binomial > | Binomial scan is one of the common implementations of MPI_Scan |
| Cinclusive_scan< Op, tags::hillis_steele > | Hillis Steele scan skeleton is a pointer-jumping based inclusive scan algorithm which has half the height of the scan algorithm in Joseph Jaja's book, but it performs  operations and hence is not work optimal |
| Cinclusive_scan< Op, tags::jaja > | This scan skeleton is based on the algorithm given in An Introduction to Parallel Algorithms by Joseph Jaja, page 48. This algorithm's time complexity is  . It consists of a reduction tree followed by a modified broadcast skeleton. This scan skeleton is an inclusive scan |
| Cis_tgv | Check if the given view is a paragraph_view |
| Clocal_entry | Typed version of local_entry that holds the values that are stored in a local_env |
| Clocal_entry_base | The base class for the entities stored in a local_env that can hold heterogeneous types |
| Cmemento_element | Memento element is used in memento in order to reduce the compilation time by avoiding boost::bind |
| Cmemento_element_disposer | Function object implementing the disposer concept defined by Boost.Intrusive |
| Cnotify_map | This class abstracts the semantics of a notify_map skeleton by exposing only the necessary information in its representation |
| Cnotify_map_pd | A notify_map parametric dependency is similar to a map_pd, however, it waits for NotifCount notifications from the first NotifCount flows |
| Codd_even_merge_sort_pd | The oddevenmergesort parametric dependency defines the dependencies for each point in the global oddevenmergesort skeleton. At each local point either a minimum or a maximum will be computed depending on where this point is located in the global skeleton. This will be described in the Op |
| Cparagraph_skeleton_manager | This is a wrapper over the core skeleton_manager that allows the creating of tasks in STAPL task graphs |
| Cparam_deps_defaults | Provides the default implementation of methods required for all parametric dependencies in the framework |
| Cpointer_jumping | This class abstracts the semantics of pointer jumping skeleton by exposing only the necessary information in its representation |
| Cpointer_jumping_pd | A pointer-jumping parametric dependency can be used in various skeletons. One good example is hillis_steele_scan in which scan is done in a non-work optimal but smaller tree |
| Cpre_broadcast_pd | Creates a set_result parametric dependency given a op. Basically this parametric dependency is only used for sinking values of skeletons which couldn't currently set their results directly without using sink_value skeleton |
| Creduce | This class abstracts the semantics of a reduce skeleton by exposing only the necessary information in its representation |
| Creduce_to_pow_two | This class abstracts the semantics of a reduce to power-of-two skeleton by exposing only the necessary information in its representation |
| Creduce_to_pow_two_pd | This parametric dependency is used in the preprocessing phase of various algorithms that only accept power-of-two input sizes |
| Crepeat | A repeat skeleton spawns a single skeleton for the number of times specified by SizeF |
| Creverse_binary_tree< Op, Flows, Span, Tag, false, Filter, isPositionAware, SetResult > | This class abstracts the semantics of a non-complete binary tree by exposing only the necessary information in its representation |
| Creverse_binary_tree< Op, Flows, Span, Tag, true, Filter, isPositionAware, SetResult > | This class abstracts the semantics of a reverse binary tree by exposing only the necessary information in its representation |
| Creverse_binary_tree_pd | A simple broadcast parametric dependency is usually used in combination with reverse_tree to define broadcast and defines the parametric dependency for each element in a broadcast tree |
| Creverse_tree | This class abstracts the semantics of a reverse k-ary tree by exposing only the necessary information in its representation |
| Cscan< Op, tags::scan< Tag, tags::exclusive > > | Most of the exclusive scan skeletons cannot work directly on inputs with non-power-of-two sizes. As a result, we have to first convert the input to the closest power of two and then perform the scan operation |
| Cscan< Op, tags::scan< Tag, tags::inclusive > > | Most of the inclusive scan skeletons cannot work directly on inputs with non-power-of-two sizes. As a result, we have to first convert the input to the closest power of two and then perform the scan operation |
| Cscan_algorithm_tag_type | Determines the scan algorithm used |
| Cscan_blelloch_broadcast_pd | Tis parametric dependency is used in the broadcast tree of Blelloch scan, in which each element applies the operation on inputs from the previous level of the tree and inputs from the reduction tree. Blelloch scan is an exclusive scan algorithm |
| Cscan_broadcast_pd | One way to do an inclusive scan is to use the algorithm mentioned in An Introduction to Parallel Algorithms by Joseph Jaja, page 48. This parametric dependency represents the broadcast (top-down) traversal in the above mentioned algorithm |
| Cscan_expand_from_pow_two_pd | An parametric dependency used in the postprocessing phase of arbitrary size scan skeletons |
| Cscan_expand_from_pow_two_pd< Op, tags::scan< Tag, tags::exclusive > > | A scan expansion parametric dependency used for the postprocessing phase of exclusive scan skeletons |
| Cscan_expand_from_pow_two_pd< Op, tags::scan< Tag, tags::inclusive > > | A scan expansion parametric dependency used for the postprocessing phase of inclusive scan skeletons |
| Cscatter | This class abstracts the semantics of a scatter skeleton by exposing only the necessary information in its representation. A scatter skeleton is simply a reverse binary tree with an operation which splits the input into two halves |
| Cserial | This class abstracts the semantics of an serial skeleton by exposing only the necessary information in its representation |
| Cserial_pd | A serial_pd parametric dependency used in the serial skeleton |
| Cset_result_pd | Creates a set_result parametric dependency given a op. Basically this parametric dependency is only used for sinking values of skeletons which couldn't currently set their results directly without using sink_value skeleton |
| Cshifted_first_pd | This parametric dependency is used in the cases similar to the zip_pd, but whenever the reading from the first input flow is shifted by 1 |
| Csink_value | This class abstracts the semantics of a sink_value skeleton by exposing only the necessary information in its representation |
| Cskeleton_traits< tuple< OptionalPreParams... >, OptionalParams... > | Skeleton traits define configurable properties of a skeleton |
| Cspawn_visitor | spawn_visitor helps in spawning the elements of parametric dependencies by factoring out the task id and number of consumers of a task in this class |
| Cstencil_2d_pd | In a 2D stencil, parametric dependencies are defined in such a way that each node depends on every 9 node in its surroundings including itself from the previous timestep |
| Ctagged_skeleton | Tags a skeleton with a given Tag |
| Ctree | This class abstracts the semantics of a k-ary tree by exposing only the necessary information in its representation |
| Czip | This class abstracts the semantics of a filtered zip skeleton by exposing only the necessary information in its representation |
| Czip_pd | A zip parametric dependency is usually used in zip skeleton. It sends input with the same index of each flow to the given Op |
| Czip_reduce | This class abstracts the semantics of a zip_reduce skeleton by exposing only the necessary information in its representation |
| ►Nspans | |
| Cbalanced< 1 > | A balanced span which is used the most across the skeletons library. It assigns a balanced spawn load to each location. The load on each location is roughly  |
| Cbinomial_tree | A span for binomial trees which is used in algorithms such as binomial tree scan |
| Cbinomial_tree< OnSpan, tags::down_phase > | The down-phase span for the down-phase of a binomial tree |
| Cbinomial_tree< OnSpan, tags::up_phase > | The up-phase span for the up-phase of a binomial tree |
| Cblocked | A blocked span which is used the most across the skeletons library. It assigns a blocked spawn load to each location. The load on each location is roughly |
| Cnearest_pow_two | In some skeletons the number of elements to be spawned is less than the elements in the input size. One good example is in the reduction skeleton where the size of the leaves of the tree is less than or equal to the number of elements in the input |
| Cnest_blocked | A span which is used for skeletons with nested execution |
| Cnest_blocked< dims, 1, Op, level > | Specialization for 1D |
| Conly_nearest_pow_two | Spans only the nearest power two element to the domain size. It's only use currently is the pre_broadcast skeleton |
| Conly_once | A span that will just have one element on the location it was created on |
| Cper_location | A balanced span ( |
| Creduce_to_pow_two | In some skeletons it is required to spawn as many elements as the closest smaller power of two. This span defines that behavior |
| Creverse_tree< OnSpan, tags::left_aligned > | A span for a left-aligned reverse binary tree that look like the following: |
| Creverse_tree< OnSpan, tags::left_skewed > | A span for a left-skewed reverse binary tree that looks like the following: |
| Creverse_tree< OnSpan, tags::right_aligned > | A span for a right-aligned reverse binary tree that looks like the following: |
| Ctree< OnSpan, tags::left_aligned > | A span for a left-aligned reverse binary tree that looks like the following: |
| Ctree< OnSpan, tags::left_skewed > | This is a span for a left-skewed binary tree that looks like the following: |
| Ctree< OnSpan, tags::right_aligned > | A span for right-aligned binary tree that looks like the following: |
| ►Nstencil_impl | |
| Cpoint | Represents a point read by a stencil characterized by a signed offset in a given dimension |
| ►Ntags | |
| Callgather | Tag type to identify an allgather skeleton |
| Callreduce | Tag type to identify an allreduce skeleton |
| Calltoall | Tag type to identify an alltoall skeleton |
| Cbinary_tree | Tag type to identify a binary_tree skeleton |
| Cbinomial | Tag type to identify a binomial computation |
| Cbinomial_tree | Tag type to identify a binomial tree |
| Cbitonic_sort | Tag type to identify a bitonic sort |
| Cbitreversal | Tag type to identify a bitreversal skeleton |
| Cblelloch | Tag type to identify the type of scan skeletons as Blelloch |
| Cbroadcast | Tag type to identify a broadcast skeleton |
| Cbroadcast_to_locs | Tag type to identify a broadcast to locations skeleton |
| Cbutterfly | Tag type to identify a butterfly skeleton |
| Ccoarse | Tag type to identify the type of coarsening operation |
| Ccoarsening_tag | Tag type to identify a coarsening operation |
| Ccopy | Tag type to identify a copy skeleton |
| Cdif | Tag type to identify type of an fft skeleton as DIF |
| Cdit | Tag type to identify type of an fft skeleton as DIT |
| Cdo_while | Tag type to identify type of a do_while operator |
| Cdown_phase | Tag type to identify a down-phase tree in skeletons such as a binomial tree |
| Cexclusive | Tag type to identify exclusive operations such as in scan |
| Cexpand_from_pow_two | Tag type to identify an expand_from_pow_two skeleton |
| Cfft | Tag type to identify an fft skeleton |
| Cflat | Tag type to identify flat operations such as in a alltoall skeletons |
| Cgather | Tag type to identify an gather skeleton |
| Chillis_steele | Tag type to identify the type of scan skeleton as Hillis-Steele |
| Chybrid | Tag type to identify hybrid operations such as in a alltoall skeleton |
| Cinclusive | Tag type to identify inclusive operations such as in scan |
| Cinline_flow | Tag type to specify that the flow type of a skeleton is to be computed based on inputs |
| Cjaja | Tag type to identify the type of scan skeleton as the one listed in Joseph Jaja's parallel algorithm text |
| Cleft_skewed | Tag type to identify a left-skewed tree |
| Cmap | Tag type to identify a map skeleton |
| Cmap_reduce | Tag type to identify a map_reduce skeleton |
| Cmultipass_transform | Tag type to apply multiple transformations onto a skeleton |
| Cnaive | Tag type to identify a naive coarsening operation |
| Cnest | Tag type to identify a nesting transformation |
| Cnested_map_reduce | Tag type to identify the explicit nested map-reduce factory |
| Cno_coarsening | Tag type to identify a no-coarsening |
| Cnotify_map | Tag type to identify a notify_map skeleton |
| Codd_even_merge_sort | Tag type to identify a odd_even_merge_sort |
| Cpairwise_exchange | Tag type to identify a pairwise exchange operations such as in alltoall |
| Cpointer_jumping | Tag type to identify a pointer_jumping skeleton |
| Cpre_broadcast | Tag type to identify a pre_broadcast skeleton |
| Crecursive_nest | Tag type to identify a nesting transformation |
| Creduce | Tag type to identify a reduce skeleton |
| Creduce_to_locs | Tag type to identify a reduce_to_locs skeleton |
| Creduce_to_pow_two | Tag type to identify a reduce_to_pow_two skeleton |
| Crepeat_first_iter | Tag type to identify the first iteration of a repeat operator |
| Crepeat_iter | Tag type to identify the iterations of a repeat operator except the first and last one |
| Crepeat_last_iter | Tag type to identify the last iteration of a repeat operator |
| Creverse_binary_tree | Tag type to identify a reverse_binary_tree skeleton |
| Creverse_butterfly | Tag type to identify a reverse_butterfly skeleton |
| Creverse_tree | Tag type to identify a reverse_tree skeleton |
| Cright_aligned | Tag type to identify a right-aligned tree |
| Cright_skewed | Tag type to identify a right-skewed tree |
| Cscan | Tag type to identify a scan skeleton |
| Cscan_reduce | Tag type to identify a scan_reduce skeleton |
| Cscatter | Tag type to identify an scatter skeleton |
| Csequential_execution | Tag type to identify a sequential execution for wrapped_skeleton |
| Csequential_unroll | Tag type to refine sequential execution with a loop unroll directive to the optimizer |
| Cserial | Tag type to identify a serial skeleton |
| Cset_result | Tag type to identify an set_result skeleton |
| Csink | Tag type to identify a sink skeleton |
| Csink_value | Tag type to identify a sink_value skeleton |
| Csorted_inline_flow | Tag type to specify that the flow type of a skeleton is to be computed based on inputs and the internal skeletons are to be topologically sorted which ensures they can be executed in the order they are spawned. This also will stop compilation if a cycle is found |
| Ctranspose_2d | Tag type to identify a transpose_2d skeleton |
| Ctree | Tag type to identify a tree skeleton |
| Cup_phase | Tag type to identify an up-phase tree in skeletons such as a binomial tree |
| Cwhile_continuation | Tag type to identify the continuation skeleton of a do-while operator |
| Cwhile_iteration | Tag type to identify the iterations of a do-while operator |
| Cwhile_last_iter | Tag type to identify the last iteration of a do-while operator |
| Cwhile_red | Tag type to identify the reduction skeleton of a do-while operator |
| Cwith_coarsened_wf | Tag type to identify if a workfunction can handle coarsened input data |
| Czip | Tag type to identify a zip skeleton |
| Czip_fusion | Tag type to identify a zip-fusion transformation |
| Czip_reduce | Tag type to identify a zip_reduce skeleton |
| ►Ntransformations | |
| ►Ndetail | |
| Cdummy_value | A dummy value to represent to stand in for void results in |
| ►Ntransformations_impl | |
| Ctransform | A wrapper of the transformed skeleton that reduces symbol sizes used for a transformed skeleton. The real transformations are defined by specializing the transformations::transform class |
| ►Nzip_fusion_impl | |
| Cmake_fused | Transform a compose based on the computed clustering |
| Cmake_fused_part | Transform an individual cluster if needed |
| Cfused_wf | A work function that executes a dag of other work functions with the dependencies for each specified by an index_sequence |
| Ctransform | In order to define a new transformation, you need to define a partial template specialization of this class. Since there is no default transformation, this class is only declared here |
| Ctransform< S, SkeletonTag, tags::multipass_transform< Pass, Passes... > > | Apply a sequence of transformations on a skeleton identified by the tags in the |
| Ctransform< S, Tag, tags::nest > | In the default case, a transformation of a skeleton with the tags::nest tag should not modify the skeleton. For example, a nested skeletons::map or skeletons::zip can be executed without applying any transformations |
| Ctransform< S, tags::butterfly< B >, tags::coarse< CoarseTag, ExecutionTag > > | A coarse-grain butterfly can be created by first computing a butterfly skeleton with a coarsened operator on the coarsened input followed by a map of fine-grained butterfly skeletons on the produced results |
| Ctransform< S, tags::reduce< Tag >, tags::coarse< CoarseTag, ExecutionTag > > | A simple coarse-grain reduce can be created by first computing local reduction on each location and applying reduction on the outcome of those local reductions |
| Ctransform< S, tags::reduce< Tag >, tags::nest > | The transformation for a skeletons::reduce in a nested section (e.g., map(reduce)) transforms it to a skeletons::reduce_to_locs. In addition, for performance reasons it should also add a map(identity<T>) to avoid remote fetches from a view |
| Ctransform< S, tags::reduce_to_locs, tags::coarse< CoarseTag, ExecutionTag > > | A simple coarse-grain reduce to each location would use coarse_reduce and in addition propagates the value to each location |
| Ctransform< S, tags::reverse_butterfly< B >, tags::coarse< CoarseTag, ExecutionTag > > | A coarse-grain reverse-butterfly can be created by first computing a map of fine-grained butterfly skeletons followed by a coarse-grain reverse-butterfly with a coarsened operation on the produced results |
| Ctransform< S, tags::scan< Tag, Alg >, tags::coarse< CoarseTag, ExecutionTag > > | A coarsened version of scan algorithm. The type of the scan skeleton to be used is determined by Tag and Type |
| Ctransform< S, tags::scan< Tag, tags::exclusive >, tags::coarse< tags::naive, ExecutionTag > > | This version of coarse scan skeleton is only kept for comparison purposes. This is the slowest version of a coarsened scan skeleton, since it has 4N memory accesses (2N accesses in computing the divide phase scan and 2N accesses in t he update phase) |
| Ctransform< S, tags::scan_reduce< Tag, tags::exclusive >, tags::coarse< CoarseTag, ExecutionTag > > | Coarsened version of exclusive scan_reduce skeleton |
| Ctransform< S, tags::scan_reduce< Tag, tags::inclusive >, tags::coarse< CoarseTag, ExecutionTag > > | Coarsened version of inclusive scan_reduce skeleton |
| Ctransform< S, tags::serial< arity >, tags::coarse< CoarseTag, ExecutionTag > > | A simple coarse-grain zip can be created by creating a zip of zips. This is the perfect example of simple division of work |
| Ctransform< S, tags::zip< Tag, arity >, tags::coarse< CoarseTag, ExecutionTag > > | A simple coarse-grain zip can be created by creating a zip of zips. This is the perfect example of simple division of work |
| Ctransform< S, tags::zip< Tag, Arity >, tags::recursive_nest > | In the default case, a transformation of a skeleton with the tags::nest tag should not modify the skeleton. For example, a nested skeletons::map or skeletons::zip can be executed without applying any transformations |
| Ctransform< S, tags::zip_reduce< arity >, tags::coarse< CoarseTag, ExecutionTag > > | A coarse-grain zip_reduce can be created by sequencing a coarse-grain zip of zip_reduces with a reduce |
| Ctransform< S, tags::zip_reduce< i >, tags::nest > | The transformation for a skeletons::zip_reduce in a nested section (e.g., zip(reduce)) composes it with a broadcast_to_locs skeleton |
| Ctransform< skeletons_impl::compose< tuple< Skeletons... >, inline_flow< tuple< PhFlows... > > >, SkeletonTag, tags::zip_fusion > | Inspect a inline_flow compose skeleton and fuse candidate sub-DAGs of zips into single zips |
| Ctransform< stapl::skeletons::skeletons_impl::compose< stapl::tuple< S... >, Flows >, SkeletonTag, tags::coarse< CoarseTag, ExecutionTag > > | A coarsening transformation on a composed skeleton applies coarsening on each individual skeleton and composes them again using the flow specification of the original fine-grain composition |
| Ccoarse_identity_op | A workaround for the cases that a coarsened view is passed to stapl::identity<T>. This struct brings a coarsened view to PARAGRAPH environment |
| Ccombined_env | A combined_env is a collection of different environments. When a skeleton is spawned in a combined_env, the spawn_element or set_num_succs requests are passed down to each environment |
| Cdebug_env | This environment can be used to print the information about the generated task graph on the screen using std::cout |
| Cdefault_input_to_input_mapper | Default mapper when skeleton is consuming from the the parent paragraph results. it maps the result ids requested by the child, from the parent dimension (upper level) to child dimension |
| Cdefault_input_to_input_mapper< 1 > | Specialization for 1D dimension |
| Cdefault_output_to_input_mapper | Default mapper that maps the linearized index the consumer task to the corresponding linearized index of the producer task, basically just linearization |
| Cdefault_output_to_output_mapper | A mapper for mapping the result ids from the child skeleton to parent skeleton, for default case given the coordination of producer task, it will map to the new coordination in parent dimension |
| Cdefault_output_to_output_mapper< 1 > | Specialization for 1D dimension |
| Cdefine_dag_base | Base type for all define_dag nodes |
| Cempty_env | An empty_env is a dummy environment which ignores all the requests sent to it |
| Cfind_max_value | Compile time max function |
| Cgraphviz_env | Debug environment can be used along with an output stream such as std::cout in order to dump a GraphViz representation of the dependence graph in an output stream. Remember, in the cases that a dynamic (conditional ) dependence graphs such as do_while is used, you have to use this along with a real execution environment such as taskgraph_env |
| Cinput_lazysize | Log lazy size is used in skeletons where the size is defined as the logarithm of the inputs. A good example is an n-ary tree |
| Cis_domain_scalar | Finding the domain type of a factory |
| Cis_domain_scalar< Factory, ViewSet, false > | Specialization for the non-skeleton factory. In this case we check only if the factory has a domain type or not |
| Cis_domain_scalar< Sk, ViewSet, true > | Specialization for the case that factory is a skeleton. In this case we get the domain type from the output port of the skeleton |
| Cis_output_scalar | Finding if the output of a factory is reduced to an scalar value or is an aggregated value |
| Cis_skeleton | Checks if the given element is a skeleton |
| Clazy_divide_and_conquer_size | Lazy size evaluation for divide-and-conquer algorithms |
| Clazysize | The basic lazy size evaluator which returns a predefined size upon evaluation |
| Clocal_env | This environment tries to behave as a taskgraph_env on a single location. In other words, it runs the workfunctions instead of creating tasks, and stores the values produced by tasks and keeps them as long as they are needed (num_succs is not 0). You should consider this environment as the sequential version of the taskgraph_env |
| Clog_ceil_lazysize | Log ceiling lazy size is used in skeletons where the size is defined as the ceiling of the logarithm of the input size. Hillis Steele or any other pointer jumping algorithm use this lazy size evaluator |
| Clog_lazysize | Log lazy size is used in skeletons where the size is defined as the logarithm of the inputs. A good example is an n-ary tree |
| Cmappers | A wrapper class for mappers |
| Cmatrix_lazysize | The lazy size evaluator for matrix which returns a predefined size upon evaluation |
| Cmemento | memento is following Memento design skeleton and is responsible for keeping track of not-yet-spawned skeletons. Skeletons can ask a spawner to store their current state. The spawner in turn asks its skeleton_manager to store the state |
| Cpd_output_type | Computes the output type of a given parametric dependency by passing fine-grain value type of all input flows to the given Op |
| Crecursive_should_flow | Goes recursively into each nested level and uses the corresponding should flow for the skeleton on that level |
| Crecursive_should_flow< 1 > | Specialization for 1D dimension |
| Cshould_flow | The default should flow that flows all the elements to to the consumers |
| Cskeleton_loc_mapper | Define key to location mapping strategy used in the directory class based on the location of view element that the task is consuming from. If the task is not consuming from from a view element we use the default_key_mapper |
| Cskeleton_manager | skeleton_manager is the core entity of the skeleton framework. It uses an environment, a set of input views, and a skeleton to evaluate (spawn) a skeleton. An evaluated (spawned) skeleton can be represented differently in different environments. For example, a spawned skeleton in a taskgraph_env is a task graph. A spawned skeleton in a graphviz_env is a GraphViz representation of the dependence graph, etc |
| Cspawner | The spawner is used in conjunction with the skeleton_manager to create nodes in the given environment. It is the main interface between skeletons and skeleton_manager and also the environment being used. Therefore, it offers an interface for recording the state of a skeleton's spawning process, and provides spawn_element interface that would do different activities depending on the spawn_mode that the spawner is currently set as |
| Ctaskgraph_env | The main environment for spawning skeletons in STAPL and evaluating them as taskgraphs is taskgraph_env. It gets the workfunction, unwraps the inputs which are given as producer_info (indexed_producer, view_element_producer, etc.) and calls add_task or set_num_succs from the given PARAGRAPH via the given taskgraph view (TGV) |
| CTraverse | Traverses the skeleton tree to find the depth of tree. It is used for finding the number of levels to pass to the nest_blocked span |
| Cunwrap | Unwraps the underlying skeleton in a wrapped skeleton |
| Cwrapped_skeleton | A wrapped_skeleton is used in the nested execution of skeletons |
| ►Nsssp_algo_detail | |
| Csssp_init_wf | Vertex-initializer functor for sssp() |
| Csssp_wf | Work-function for sssp() |
| Cupdate_func | Visitor functor sssp() |
| ►Nstream_impl | |
| Cstream_wrapper_impl | A wrapper around a stream that is a p_object. A pointer to an instance is stored in stapl::stream instances provided to work functions to allow access to the stream on the location |
| ►Ntuple_ops | |
| ►Ndetail | |
| Cdiscard_impl | Implementation of both |
| Cexpand_and_copy_impl | Implementation of |
| Cindex_of_max_impl | Helper metafunction to compute the index of maximum value |
| ►Nresult_of | |
| ►Ndetail | |
| Cdifference_impl | Implementation of difference metafunction. Recursive case |
| Cdifference_impl< LastIndex, LastIndex, Larger, Smaller, Running, Check > | Implementation of difference metafunction. Base case |
| Cdifference | Metafunction to compute the result of set difference between two tuples |
| Cdiscard | Metafunction that reflects the type of the |
| Censure_tuple | Metafunction that wraps a non-tuple type into a tuple of size one. If the type is already a tuple, it acts as an identity |
| Censure_tuple< stapl::tuple< Args... > > | Specialization when T is already a tuple |
| Cfilter | Metafunction that reflects the type of the |
| Cheterogeneous_discard | Metafunction that reflects the type of the |
| Cheterogeneous_filter | Metafunction that filters a d-dimensional tuple by selecting out only the indices specified in a tuple of compile-time integer constants |
| Crearrange | Rearrange the contents of a compile-time tuple based on the indicies specified in another compile-time tuple |
| Cfilter_types | Filter the types in a tuple based on a predicate metafunction |
| Cfold_types | Perform a left fold over the types in a tuple |
| Cfrom_array_impl< Array, index_sequence< Indices... > > | Convert an std::array to a tuple of homogeneous types |
| Cfrom_index_sequence | Creates a tuple of std::integral_constant from a given index_sequence |
| Cindex_of_max | Metafunction to compute the index of the maximum integral value in a compile-time tuple |
| Cnot_tuple_contains_type | Metafunction that computes if a type does not appear in a tuple |
| Cto_index_sequence | Creates an index_sequence from a tuple of std::integral_constant |
| Ctuple_contains | Metafunction that computes whether an integral type appears in a tuple of integral types |
| Ctuple_contains_type | Metafunction that computes if a type appears in a tuple |
| ►Nutility | |
| Cidentity | Helper unary function object that returns input value |
| ►Nvector_impl | |
| Ccompute_vector_traits | Metafunction to compute traits class for vector container. For primary template, some optional parameters are defined, but no customized traits. Use vector_traits |
| Ccompute_vector_traits< T > | Specialization when none of the optional parameters are provided at template instantiation. Use vector_traits, with default partition and mapper argument types |
| Ccompute_vector_traits< T, Partition, Mapper, Traits > | Specialization when traits is actually passed at class |
| ►Nview_coarsen_impl | |
| Ccoarsen_container | Defines a container used to produce subviews with extra information about locality (mix_views), based on the given the metadata information (metadata container) |
| Cselect_coarsen_container_domain< D, false > | Metafunction to compute the type of the sliced view's domain. Specialization for the one-dimensional case |
| ►Nview_impl | |
| Cadd_value | Static functor that adds initial value to the index provided to the counting_container, forming the return value (either a tuple or a single integral value, based on dimension). Signatures for both receiving the index as a tuple or a variadic pack of constituent indices are provided, to back operator[] and operator() of the counting_container, respectively |
| Caddition_assignment_map_wf | Work function to add value elt1 to elt0, updating elt0 in the process (elt0 += elt1) |
| Caddition_map_wf | Work function to add two values (elt0, elt1), assigning the result to the given reference result |
| Cbasic_counting_container_distribution | Minimal distribution class used by counting_container when no partition is provided |
| Ccompute_distribution | Small type metafunction to reflect the correct distribution and locality extraction types for a counting_container to use |
| Ccompute_domain_type | Type metafunction to use default traversal in the domain type when dimensionality is greater than one |
| Ccontainer_has_gethandle_type | Functor that checks if given container is a p_object |
| Ccontainer_has_gethandle_type< Container, false > | Functor that checks if given container is a p_object |
| Ccontainer_storage | Base class of Segmented, which optionally stores the underlying view/container, allowing it to implement the same ownership capabilities of other views |
| Ccounting_base_container_manager | Minimal base container manager class used by counting_container when there is a need to mimic a provided partition of elements to locations |
| Ccounting_container | Container that represents an increasing sequence of elements |
| Ccounting_container_base_container | Minimal base container class used by counting_container that holds no elements but is able to provide a component id and associated domain as well as a pointer to the counting_container which provide elements on the fly |
| Ccreate_native_view | Static functor to construct a native view using the native partition |
| Cdefault_container | Use to generate the sequence of numbers. (Unidimensional) |
| Cdefault_subview_creator | Functor used to create a subview for a given index in segmented_view |
| Cdimension_helper | Helper metafunction to return a nested dimension_type trait, if it exists |
| Cdimension_helper< void > | Helper metafunction to return a nested dimension_type trait, if it exists. |
| Cdomain_container | Defines a container that exposes the view's domain as a container |
| Cdomain_view | Functor to define a view over a view's domain that behaves as an array_view ( |
| Cemulated_counting_container_distribution | Minimal distribution class used by counting_container when there is a need to mimic a provided partition of elements to locations |
| Cf_stride_helper | Helper metafunction that computes the mapping function type needed for an n-dimensional strided view |
| Cfunctor_container_distribution | Minimal distribution class used by functor_container |
| Cgid_accessor< transform_view< View, Functor > > | Specialization of gid_accessor over transform_view to allow application of the transformation functor over the element referenced |
| Chas_enable_view_reference | Type metafunction returning true_ if Traits reflects the type enable_view_reference |
| Cinfinite_locality_metadata | Functor to return a locality metadata that knows how to return metadata for an infinite set of elements |
| Cmultiplication_assignment_map_wf | Work function to multiply value elt0 by elt1, updating elt0 in the process (elt0 *= elt1) |
| Cmultiplication_map_wf | Work function to multiply two values (elt0, elt1), assigning the result to the given reference result |
| Cnative_partition | Represent a collection of domains that matches how the data in distributed on the underlying container associated with the given view |
| Cobject_holder | Class to store the container* and provide reference counting via shared_ptr, and determine when a container should be destroyed for views which have taken ownership of the container. boost::shared_ptr is being used in place of std::shared_ptr in order to minimize the number of conflicts caused by ADL. Performance was shown to be comparable |
| Coverlap_view_builder | Functor to construct a segmented view using an overlap partitioner |
| Cpart_balance_view | Functor to construct a partitioned view using a balanced partitioner |
| Crepeat_container | Defines the container to represent an infinite collection of elements |
| Crepeat_container< Q, 1, true, true > | Specialization when repeated element is a view |
| Creverse_view | Defines a reverse view over the specified View |
| Cselect_sv_base_view_type | Type metafunction to select underlying view type used to implement Segmented. Partial specialization in place of std::conditional avoids both view templates being instantiated |
| Cstore_in_frame | Tag type used by the segmented views framework to annotate that the underlying view should be held in frame |
| Cstrided_domain_helper | Function object that generates a domain from (0,0,..0) to (size_1/step_1-1, .. size_n/step_n-1) |
| Cstrided_view_type_helper | Helper metafunction that computes the type of a strided view |
| Csubtraction_assignment_map_wf | Work function to subtract value elt1 from elt0, updating elt0 in the process (elt0 -= elt1) |
| Csubtraction_map_wf | Work function to subtract two values (elt0 - elt1), assigning the result to the given reference result |
| Cuse_view_as_reference | Reflecting whether for a given type T, a view should be used as a reference to it (in place of a proxy). True if T is a container and its traits class reflects enable_view_reference |
| Cvalidator | Primary validator template |
| Cvalidator< T, false, false, is_view_container > | Validator for versioning of objects that are not p_objects |
| Cvalidator< T, true, is_view, true > | Validator for versioning of STAPL view_impl::view_container |
| Cvalidator< T, true, true, false > | Validator for versioning of STAPL views |
| Cversioner | Versioner for versioning. Templates allow p_objects to be versioned and non_p_objects, like stl objects, to ignore versioning |
| Cview_container | Define a container of views, specified by a partition function and a mapping function generator |
| Cview_container_has_gethandle_type | Functor that checks if the underlying container of given view is a p_object |
| Cview_container_has_gethandle_type< View, false > | Functor that checks if the underlying container of given non-nested view is a p_object |
| Cview_container_size | Helper static polymorphic function to compute view container size based on either size() or dimensions() call, based on the the dimensionality of the partitioned data it represents |
| Czip_container | Defines a container to zip together a set of views |
| ►Nview_operations | |
| Ccompute_local_domain | Helper function for computing the local domain that by default is partition agnostic of the underlying container distribution. Specializations of the class template addresses cases where we do better given what we know about the distribution (ideally we would like the local domain to be that of the elements stored on this affinity) |
| Cdomain_equal | Performs pieceise comparison of first and last elements of two indexed_domain objects to determine if they are equivalent |
| Cmulti_dimensional_subscript | Defines the operations to access elements using multiple dimensions via operator() |
| Cparagraph_required_operation | Defines the operations expected by the PARAGRAPH during task creation |
| Cread | Defines operations to read values from the underlying container |
| Csequence | Defines the operation found in sequence containers (e.g. list) used to traverse the elements |
| Cset_elements_impl | Enables set_elements method in Array for aggregate assignments |
| Csubscript | Defines the operations to access the elements of a one-dimensional container using the random access operator ( |
| C_Hashtable_const_iterator | Iterator over the hashtable. |
| C_Hashtable_iterator | Iterator over the hashtable |
| Caccessor_base | Accessor base class. Provides the basic operation for read and write values |
| Caccessor_core_access | Helper class to access the private methods of the given accessor |
| Caccessor_traits | Metafunction that defines traits for accessors |
| Cadd_edge_aggregator | Adds edges to the graph |
| Cadd_edge_aggregator< Cont, true > | Adds edges with properties to the graph |
| Cadd_edge_helper | Helper to infer the property of the base class based on the current edge descriptor and adaptor and add an edge |
| Cadd_edge_helper< OVGraph, typename OVGraph::edge_descriptor, use_default > | Helper to infer the property of the base class based on the current edge descriptor and adaptor and add an edge |
| Cadd_edge_profiler | |
| Cadd_edge_profiler_bgl | |
| Cadd_svertex_wf | Add a super vertex to a hierarchical graph |
| Cadd_task_helper | Functor used to call paragraph_impl::paragraph_view::add_task() from PARAGRAPH factories |
| Cadd_task_helper< WF, true > | Specialization for dynamic work functions that adds the paragraph_impl::paragraph_view as the first view in the task specification |
| Cadd_to_supervertex | Functor adding a vertex to a super-vertex |
| Cadd_vertex_helper | Helper to infer the property of the base class based on the current property and adaptor and add a vertex |
| Cadd_vertex_helper< OVGraph, use_default > | Helper to infer the property of the base class based on the current property and adaptor and add a vertex |
| Cadd_vertex_profiler_bgl | |
| Cadjacency_graph_view | A graph view using adaptors for vertex and edge properties |
| Cadjacency_list_hashmap_storage | An adjacency list using an unordered map for storing vertices.Used inside the adjacency_list_model to store vertices |
| Cadjacency_list_impl | Adjacency list of a vertex implemented as a vector of edges.Used inside the vertex_adj_list_impl to store adjacent edges |
| Cadjacency_list_model | This model describes operations on a graph that is modeled as an adjacency-list. Adjacency-lists store a list of vertices where each vertex has a list of edges to its adjacents |
| Cadjacency_list_vector_storage | An adjacency list using an std::vector for storing vertices.Used inside the adjacency_list_model to store vertices |
| Caffinity_tag | Describes the affinity of a location |
| Caggregated_edge_subview | View that provides access to an aggregated collection of task data flow values from the edge_container |
| Caggregated_edge_view | Provides access to a dynamically selected group of values in the edge_container. The index type of the view, instead of being a single task identifier is logically a sequence of task identifiers |
| Caggregator | Applies Elem::operator() to vertex-property of Elem.target() |
| Caggregator_apply | Applies WF::operator() to a pointer to the graph on the target location and an Elem |
| Caggregator_apply_impl | Aggregates requests to apply a functor (WF) on the element (Elem) |
| Caggregator_base | Base class for aggregators |
| Call_locations_t | Tag type to represent all locations of a gang |
| Canonymous_executor | Provides support for getting a p_object on the gang of stapl_main() |
| Capply_functor | Work function which applies the given functor to its argument |
| Carbitrary_mesh_collapser | Functor partitioning an arbitrary mesh by projecting its cells on axes and then calling a 1D balanced partitioner |
| Carbitrary_partition_info | Representation of a partition in the specification of an arbitrary distribution |
| Carbitrary_priority_scheduler | Arbitrary priority scheduler that supports any type of priority |
| Care_basic | Returns if the types T are basic types |
| Carray | Parallel array container.Parallel sequence container with fixed size. By default, its GID type is a std::size_t, which represents the position of values in the array |
| Carray_base_container | The base container used for array |
| Carray_base_container_traits | Default traits for the array base container. Specifies customizable type parameters that could be changed on a per-container basis |
| Carray_ro_view | One dimensional read only array view |
| ►Carray_traits | Default traits for the array container. Specifies customizable type parameters that could be changed on a per-container basis |
| Cconstruct_distribution | Metafunction to compute the distribution type based on a container type |
| Carray_view | One dimensional array view |
| Cassign | Work function which assigns the value of the first argument to the second |
| Cassociative_sequence | Generates a sequence of std::pair<K, V> elements |
| Casync_transmitter | Transmitter for Directory that sends requests using async_rmi() |
| Caux_info | Struct used to as temporary storage for the information required to compute list ranking over the list of base containers |
| Caux_info_wrapper | Defines a wrapper over the auxiliary information to provide the interface required for the execution of tasks |
| Cbalance_map | Computes a balanced mapping of ids to partitions |
| Cbalance_map< 1, GID, Index, ContainerGID, CID > | Computes a balanced mapping of ids to partitions in a one dimensional space. This is a specialization of the multi-dimension map function |
| Cbalance_ndim_to_linear_map | Computes the mapping of an n-dimensional component id to a linear location id in a balanced manner |
| ►Cbalance_neighbor_partitions_wf | Work function to balance 2 neighboring partitions in a diffusive fashion according to the independent set |
| Cadd_partition_weight | Increment partition weight with a weight |
| Ccheck_contains | Helper functor which calls contains on a vertex in a graph with passed descriptor as parameter |
| Cedge_cut_cmp | Compare edge-cut of 2 vertices |
| Cis_source | Return true if the 'elt' edge has 'source' as source |
| Cis_target | Return true if the 'elt' edge has 'target' as target |
| Cbalanced_partition | Partition a one-dimensional domain into balanced subdomains |
| Cband_partition | Partition to construct reference the elements in a band matrix |
| Cbase_container_metadata | Class for computing the metadata of base-containers. This class contains information needed to determine the locality metadata information for a base container |
| Cbase_container_ordering | Defines an object that keeps track of the ordering of base containers in a pContainer |
| Cbase_view | Base class to tag views |
| Cbasic_array_base_container | A basic base container for array. This class differs from array_base_container in that it cannot be modified through traits. Its domain is indexed_domain |
| Cbasic_manager | Implementation of common manager with balanced partition and block mapper. Implemented directly in terms of general manager, but reduces symbol length, compilation effort. Used in static_array implementation |
| Cbc_base | Common base class for all base containers in the container framework. Use for single pointer type in base_container_ordering |
| Cbfs_internal_profiler | |
| Cbfs_internal_profiler_bgl | |
| Cbfs_profiler | |
| Cbfs_profiler_bgl | |
| Cbinary_negate | Function which returns whether its arguments were not matched by the given predicate |
| Cbinder1st | Functor representing the result of binding the first argument of the given operation to the stored value |
| Cbinder2nd | Functor representing the result of binding the second argument of the given operation to the stored value |
| Cbinder3rd | Functor representing the result of binding the third argument of the given operation to the stored value |
| Cbit_and | Function which returns the bitwise and of its arguments |
| Cbit_or | Function which returns the bitwise or of its arguments |
| Cbit_xor | Function which returns the bitwise xor of its arguments |
| Cbitreverse | Given a value this functor computes its bitreversed value by considering the least signficant bits specified by ceil(log2(max)) |
| Cbitreverse_map_function | Mapping function used for views over bitreversed containers |
| Cbitwise_wrapper | Wrapper class for a bitwise packed members |
| Cblk_cyclic_part | Partition a one-dimensional domain cyclically into subdomains with a fixed block size |
| Cblock_map | Computes a block mapping of ids to partitions |
| Cblock_partitioner | Partition a one-dimensional domain into subdomains with a fixed block size |
| Cblock_sequence | Generates a repeating sequence of values |
| Cbuild_centroids_wf | Functor to compute the centroid of a cell |
| Ccallable_traits | Callable introspection class |
| Ccallback | Registers the given function as a callback to be called when a primitive is called in the registering context |
| Ccast_container_view | Helper class to change the container type and mapping function of the given View to the base container type C and the composition of all mapping functions encountered in the View containers |
| Ccast_container_view< array_ro_view< OldC, Params... >, NewC > | Specialization ensures container transform for variadic based optionals is used |
| Ccast_container_view< array_view< OldC, Params... >, NewC > | Specialization ensures container transform for variadic based optionals is used |
| Ccast_container_view< graph_view< OldC >, NewC > | Specialization ensures container transform |
| Ccast_container_view< hgraph_view< OldC >, NewC > | Specialization ensures container transform |
| Ccast_container_view< overlap_view< View >, NewC > | Specialization for changing the container used for an overlap segmented view |
| Ccast_container_view< repeat_view< OldC >, NewC > | Specialization ensures container transform for variadic based optionals is used |
| Ccast_container_view< segmented_view< C, P, MFG, SVC >, NewC > | Specialization for changing the container used for a segmented view |
| Ccast_container_view< use_default, C > | Specialization of cast_container_view when the given view is tagged to be default |
| Ccast_container_view< vector_view< OldC, Params... >, NewC > | Specialization ensures container transform for variadic based optionals is used |
| Ccast_container_view_preserve_mapfunc< View< OldC, OptionalParams... >, NewC > | Specialization of cast_container_view that preserves the mapping function of the original view (doesn't compose it with the mapping functions of the underlying views) |
| Ccell_property | Default property for a mesh cell |
| Cchoose_wf | Default implementation of a functor to choose between fine-grain and coarse-grain work functions when specifying the tasks of a PARAGRAPH |
| Cchoose_wf< composition::map_view< T > > | Specialization for factories that receive a composition::map_view for which they will specify tasks |
| Cchoose_wf< detail::row_slice_view< MTLRowSlice > > | Specialization for factories that receive a detail::row_slice_view for which they will specify tasks |
| Cchoose_wf< partitioned_mix_view< View, Part >, false > | Specialization for factories that receive coarsened views for which they will specify tasks |
| Cchoose_wf< View, true > | Default implementation of a functor to choose between fine-grain and coarse-grain work functions when specifying the tasks of a PARAGRAPH |
| ►Cchunker | Support class for the sliding window implementation |
| Centry_type | Sliding window entry type |
| Ccircular_lifeline_steal | Steal in a circular way (always advance to the right neighbor of the last victim stealing policy. Avoids stealing from the same location if it didn't have anything the last time |
| Ccircular_steal | Steal in a circular way (always advance to the right neighbor of the last victim stealing policy |
| Cclock_gettime_timer | Time counter that uses clock_gettime() in POSIX systems |
| Ccmr_base | Work function that uses the fine-grain map and reduce operations provided to stapl::map_reduce to implement a coarse-grain operation that aggregates multiple calls with a for loop into a single result |
| Ccmr_base< Map, ::stapl::logical_and< bool > > | Specialization of the coarsened map-reduce operation for logical_and as the reduce operation. If the fine-grain map operation returns false the coarsened operation returns false immediately without applying the map operation to the remaining sets of elements from the views |
| Ccmr_base< Map, ::stapl::logical_or< bool > > | Specialization of the coarsened map-reduce operation for stapl::logical_or as the reduce operation. If the fine-grain map operation returns true the coarsened operation returns true immediately without applying the map operation to the remaining sets of elements from the views |
| Ccoarse_assign | Performs assignment of all values from one view to the elements of another |
| Ccoarse_assign_helper | Based on boolean parameter, dispatch logical invocation of the assignment operator on two view ranges either to a simple for loop or the destination view's set_elements member function |
| Ccoarse_identity | A workaround for the cases that a multidimensional coarsened view is passed to stapl::identity<T>. This struct brings a multidimensional coarsened view to PARAGRAPH environment |
| Ccoarse_map_reduce_wf | Work function that implements the coarsened map reduce operation and reflects the result_type defined by the fine-grain reduce operation |
| ►Ccoarse_map_reduce_wf< Map, Reduce, false > | Work function that implements the coarsened map reduce operation and uses the struct result to determine the result_type because the fine-grain reduce operation does not reflect a result_type |
| Cresult< coarse_map_reduce_wf(V...)> | Compute the type of result of the operation for the given view types |
| Ccoarse_map_wf | Work function that wraps a fine-grain map operation in a loop in order to process coarse-grain view elements provided to PARAGRAPHs that are instances of map computations |
| Ccoarse_swap_ranges | Work function that swaps the values between two views |
| Ccoarsen_all_but_last | Functor to coarsen a set of given views, where the last view in the given set of views is coarsened using the null_coarsener |
| Ccoarsen_views_native | Helper functor to construct the coarsened view (partitioned_mix_view) for each view in the given set of views, using the native coarsen metadata partition |
| Ccoarsened_wf | Wrapper class around workfunction that a factory can detect, signaling that workfunction is designed to work on coarsened view data |
| Ccolocation | Initial implementation of view colocation strategy that copies readonly data to the task's execution location to avoid excessive, fine grain communication. Assume a dense read pattern of these views.This implementation exists to fix performance problem with stapl::copy, currently the only user of the interface. (Hence only two view version of function operator) |
| Ccommon_view | This class contains functionality that EVERY view must provide |
| Ccompose_func | Mapping functions composition. Compose two given mapping functions f(g(x)) |
| Ccompose_func< F, f_ident< T > > | Specialization when the inner mapping function is identity |
| Ccompose_func< f_ident< T >, f_ident< T > > | Specialization when the two mapping functions are identity |
| Ccompose_func< f_ident< T >, G > | Specialization when only the outer mapping function is identity |
| Ccompute_array_bc_traits | Metafunction to detect whether the no_initialization type flag was passed during container template instantiation and reflect the appropriate base container traits |
| Ccompute_level_offset | Functor computing the vertex descriptor offset for the level above a given one |
| Ccompute_mf_type | Type metafunction to reflect identity mapping function if the passed view type parameter is actually a container, and hence does not define this type (and is by definition identity) |
| Ccompute_rank_wf | Work function used to compute the base container ranking |
| Ccompute_type_parameters | Metafunction that returns a tuple of types to a template instantiation that should be used for a set of optional template parameters. This allows writers to avoid use of default template parameters, reducing error message and symbol table sizes |
| Cconditonal_inherit | Helper class that conditionally inherits from another class based on a compile-time condition |
| Cconfidence_interval_controller | Base class to built upon by programs that want to collect profile information about certain functions |
| Cconst_container_accessor | Const_accessor for global proxies over pContainers |
| Cconst_container_iterator | Const_iterator that is used to globally traverse a container |
| Cconst_ea_iterator | Edge Iterator Adaptor for filtering out specific edge properties (const).The property adaptor used in this iterator is default constructed |
| Cconst_graph_accessor | Accessor for vertices of a graph |
| Cconst_index_iterator | Definition of the iterator used for the View |
| Cconst_local_accessor | Accessor for local proxies over base containers |
| Cconst_local_accessor_graph | Local accessor for pGraph's vertices.Derives from local_accessor and adds methods for property |
| Cconst_local_iterator | Iterator that is used to locally traverse a base container |
| Cconst_local_property_reference_constructor | Functor creates a reference either as a proxy or a view, based on use_view_as_reference metafunction |
| Cconst_property_accessor | Accessor for the property on vertices of a graph providing read-only access |
| Cconst_property_reference_constructor | Functor creates a reference either as a proxy or a view, based on use_view_as_reference metafunction |
| Cconst_property_reference_constructor< T, Container, GID, true > | |
| Cconst_va_iterator | Specialized iterator with property adaptor to filter particular members of the property (const).The property adaptor used in this iterator is default constructed |
| Cconst_va_iterator< VertexIterator, EdgeIter, use_default > | Specialized vertex iterator for when only the edge is adapted (const).The property adaptor used in this iterator is default constructed |
| Ccontainer | Base-class for pContainers that implements general functionality needed by containers |
| Ccontainer< C, true > | Specialization when this is a nested container |
| Ccontainer_accessor | Accessor for global proxies over pContainers |
| Ccontainer_directory | The container directory is responsible for distributed metadata for GIDs. It knows in which location GIDs reside. It also provides methods to invoke arbitrary functors on the location of GIDs without requiring external entities to know exact locality information |
| Ccontainer_iterator | Iterator that is used to traverse a container |
| Ccontainer_levels | Metafunction to determine how many containers are nested within the value_types of a given type |
| Ccontainer_levels< T, true > | Specialization of container_levels for the case when T is a container, effectively adding one more to the running total |
| Ccontainer_manager | The container manager is responsible for local metadata for GIDs. It knows in which local base containers GIDs reside. It also provides methods to invoke base container methods on specific GIDs, abstracting out the need for external classes to know exactly in which base container a GID is |
| Ccontainer_manager_dynamic_graph | Base-container manager for the dynamic_graph |
| Ccontainer_manager_static | Container manager for static containers that disallow migration and allows at most one base container per location |
| Ccontainer_manager_static_graph | Base-container manager for the stapl::graph |
| Ccontainer_profiler | |
| Ccontainer_traits | Metafunction to retrieve associated types for containers. This class is similar in spirit to the STL's iterator_traits |
| Ccontainer_traits< adjacency_list_model< Traits > > | Specialization of container_traits for adjacency_list_model |
| Ccontainer_traits< array< T, OptionalParams... > > | Specialization of container_traits for array |
| Ccontainer_traits< directed_graph< D, M, OptionalParams... > > | Specialization of container_traits for directed_graph |
| Ccontainer_traits< dynamic_graph< D, M, OptionalParams... > > | Specialization of container_traits for stapl::dynamic_graph |
| Ccontainer_traits< dynamic_graph_base_container< Traits > > | Specialization of container_traits for dynamic_graph_base_container |
| Ccontainer_traits< graph< D, M, OptionalParams... > > | Specialization of container_traits for stapl::graph |
| Ccontainer_traits< graph_base_container_base< D, M, VertexP, EdgeP, Traits >> | |
| Ccontainer_traits< identity_container< T > > | Specialization of container_traits for identity_container |
| Ccontainer_traits< lightweight_vector< T > > | Specialization for lightweight_multiarray_base |
| Ccontainer_traits< proxy< std::vector< T >, Accessor > > | Specialization for proxy<std::vector<T>, Accessor>> |
| Ccontainer_traits< static_array< T, OptionalNoInitParam... > > | Specialization of container_traits for static_array |
| Ccontainer_traits< std::list< T > > | Specialization for std::list |
| Ccontainer_traits< std::vector< T > > | Specialization for std::vector |
| Ccontainer_traits< undirected_graph< D, M, OptionalParams... > > | Specialization of container_traits for undirected_graph |
| Ccontainer_traits< vector< T, OptionalParams... > > | Specialization of container_traits for vector |
| Ccontainer_wrapper_ref | A wrapper for storing containers as the value_type of another container. This is needed because we want to store a reference to the container as a p_object in a base container |
| Ccontinuous_domain | Defines a domain where the indexes are continuous and not numerable (e.g., float, string), but there is an order relation among the indexes (e.g., lexicographical order) |
| Cconvert_to_md_vec | Defines the coarsen metadata view type for the given container type |
| Cconvert_to_md_vec_array | Defines the coarsen metadata view type for the given container type |
| Ccopyable_intrusive_list | Wrapper class that provides a copy constructor to boost::intrusive::slist |
| Ccore_view | Main class to define a pView, composed of a reference to a collection of elements, a domain and a mapping function |
| Ccount_static_votes_impl | Counts the number of LQ_DONTCARE votes known at compile time |
| Ccount_static_votes_impl< tuple< RuntimeViews const &... > > | Base case when all views have been inspected. Return the number of static LQ_DONTCARE votes and the tuple of views that must be queried at runtime |
| Ccount_static_votes_impl< tuple< RuntimeViews const &... >, View0, Views... > | Recursive case. Inspect View0 and either increment static vote count or add to tuple of views requiring runtime evaluation |
| Ccounter | Implements a configurable counter |
| Ccounter_group | Controls enabling/disabling a specific group of counter objects at runtime |
| Ccreate_submesh_file_wf | Functor creating a silo multimesh file storing a partition of a mesh |
| Ccref_accessor | Defines a read only accessor that references a local element |
| Ccsr_base_container_traits | Default traits for the csr_graph 's base container |
| Ccsr_edgelist_impl | The edgelist for a CSR graph, implemented as a vector of edges |
| Ccsr_graph | Implementation for a Compressed Sparse-Row (CSR) graph.CSR graphs do not allow addition and deletion of vertices or edges once the graph has been "committed". All edges must be added before calling the commit() method, which finalizes the graph. Inherits all methods from stapl::graph and adds method to commit |
| Ccsr_graph_traits | Default traits for the csr_graph container. Specifies customizable type parameters that could be changed on a per-container basis |
| Ccsr_model | This model describes operations on a graph that is modeled as a Compressed Sparse-Row (CSR) graph. CSRs store a list of vertices and a separate list of edges. Each vertex points to its adjacent edges in the list of edges |
| Ccsr_short_edge_base_container_traits | Base container traits for a CSR with short edges |
| Ccsr_short_edge_graph_traits | Traits for the short_csr_graph |
| Ccsr_vector_storage | An CSR using an std::vector for storing vertices. Used inside the csr_model to store vertices |
| Ccycle_map | Computes a cyclic mapping of ids to partitions |
| Cdecompose_largest_dim | Functor to set up the mesh decomposition, partitioning the mesh along the dimension with the highest number of cells |
| Cdecompose_largest_dim<-1 > | Functor to set up the mesh decomposition, partitioning the mesh along the dimension with the highest number of cells |
| Cdecomposition_tuple_type | Specify types of tuple variables used in the decomposition. The type depends on the number of projections |
| Cdecomposition_tuple_type< Dim, 1, Precision > | Specify types of tuple variables used in the decomposition. The type depends on the number of projections |
| Cdecomposition_tuple_type< Dim, 2, Precision > | Specify types of tuple variables used in the decomposition. The type depends on the number of projections |
| Cdecomposition_tuple_type< Dim, 3, Precision > | Specify types of tuple variables used in the decomposition. The type depends on the number of projections |
| Cdefault_info | Default scheduling information |
| Cdefault_pin_location_mapper | Default mapping function used by port based dataflow protocol to decide where a producer pin is flowed to in the consuming PARAGRAPH. Based on the hash-based key mapper of the Directory, it's used if no custom mapper is provided by user |
| Cdefault_task_placement_impl | Default policy for initially mapping a task to a PARAGRAPH location for execution |
| Cdefault_traversal | Metafunction to compute a the default traversal for an n-dimensional space |
| Cdefault_view_traits | Reflects common trait types based on explicitly passed container, domain, mapping function, and derived parameter types |
| Cdeferred_domain | A domain that has been constructed without knowledge of the number of locations across which it will be distributed |
| Cdeferred_map | Captures a mapping function that has been constructed without knowledge of the number of locations and a factory that is invoked to reinitialize the mapping function when the number of locations is available |
| Cdefine_type_provider | Transforms an object of type T to an object of type U that has a U::define_type(stapl::typer&) function through the apply() function |
| Cdefine_value_type | Metafunction to compute the stored value of an element in a container. In the cases of nested containers, it is necessary to store a reference to the container, as it is a p_object |
| Cdelete_edge_profiler | |
| Cdelete_edge_profiler_bgl | |
| Cdelete_vertex_profiler | |
| Cdelete_vertex_profiler_bgl | |
| Cderived_types | Provide traits for RMIs with arbitrary types |
| Cdf_stored_type | Type metafunction computing the actual type that will be stored for a requested edge type.Internally, it is useful to modify the type for some special cases outlined below in the various partial specializations of the class |
| Cdf_stored_type< proxy< T, A > > | Specialization for proxy edge types.Proxies' assignment operators are overloaded to behave like a real reference (i.e., redirect to reference object). We use a proxy_holder to give us a proper assignment operator to use |
| Cdf_stored_type< std::pair< proxy< T1, A1 >, proxy< T2, A2 > > > | Specialization for pairs of proxies.Some algorithms use pairs of proxies to denote ranges and transmit these through the edge container. Use a proxy_pair_holder for the same reason discussed in simple proxy specialization of df_stored_type |
| Cdf_stored_type< void > | Specialization for void edge types (i.e., signals).Internally pass an int to simplify code paths that expect to receive a parameter (can't pass void) |
| Cdfs_internal_profiler | |
| Cdfs_profiler | |
| Cdfs_profiler_bgl | |
| Cdgraph_param_selector | Class for selecting between default and optional template parameters for dynamic_graph |
| Cdiffusive_steal | Diffusive stealing policy |
| Cdigraph | Creates a DIRECTED, NONMULTIEDGES graph.Static graphs do not allow addition or deletion of vertices. The number of vertices must be known at construction. Edges may be added/deleted |
| Cdijkstra_profiler | |
| Cdimension_traits | Metafunction to compute a compile-time constant representing the number of dimensions of a particular type (container, domain, size, etc.) |
| Cdimension_traits< tuple< T... > > | Specialization for tuples |
| Cdirected_graph | Parallel directed-graph container. Inherits all functionality from directed_graph_base |
| Cdirected_graph_base | Base-class for graph that implements all functionality needed for a directed static graph. Deriving classes may over-write functionality for adding/deleting edges (for Undirectedness) |
| Cdirectory | Provides basic functionality to forward computation (via a generic functor) to a location determined by the distributed registration of key values. The class handles heterogeneous work requests and supports relaxed consistency, placing no synchronization requirements on the registration of key and functor forwarding requests employing that key |
| Cdirectory< Key, Transmitter, Mapper, Registry, true > | Specialization with migration support |
| Cdirectory_registry | This class is used to store directory entries in the container_directory class and subsequently, its base class directory. It models the map concept. For most pContainers, it is a safe assumption to expect that most GIDs will be mapped to the home location and that there will be only a small amount of GIDs that differ from this closed-form solution (through migration, etc.) |
| Cdisable_group_counter | Disables a specific counter group at compile-time |
| Cdistributed_domain | Defines a domain using a Distribution to support the query methods |
| Cdistributed_value | A bool that has a representative on all locations and can perform an allreduce to AND / OR across all locations |
| Cdistribution | Base distribution class for the pContainers. Provides the base functionality for all distributions |
| Cdistribution_spec_view | One dimensional read only view used to specify data distribution |
| Cdistribution_traits | Metafunction to retrieve associated types for container distributions. This class is similar in spirit to the STL's iterator_traits. and container_traits |
| Cdistribution_traits< DistributionType< C > > | Specialization used when distribution is customized by inheriting from distribution base. Type is incomplete, reflect types from the container_traits of the distribution's container |
| Cdistribution_traits< DistributionType< C, Op1, Op2, Op3, Op4 > > | Specialization used when distribution uses distribution, optionally passing operation template template parameters. Type is incomplete, reflect types from the container_traits of the distribution's container |
| Cdistribution_traits< vector_distribution< C > > | Specialization for distribution_traits over vector_distribution |
| Cdivides | Function which returns the result of dividing the first argument by the second |
| Cdom1D | One dimensional domain |
| Cdom1Dbc | One dimensional block-cyclic domain |
| Cdom2D | Two dimensional domain implemented as a tuple of one-dimensional domains |
| Cdomain_retype | Helper class to change the domain type of the given |
| Cdomain_retype< V< C, D, M, De >, NewDom > | Specialization for domain_retype to change the domain from the given |
| Cdomain_selector | Default domains for the graph_distribution. Specifies domain and metadata domain types |
| Cdomain_selector< Distribution, hgraph_traits< D, M, VertexPx, EdgePx, PSx, Mapx > > | Default domains for the graph_distribution, specialized for the hierarchical_graph. Specifies domain and metadata domain types |
| Cdomainset1D | Defines a one dimensional distributed domain for indexes that are not necessarily consecutive |
| Cdomset1D | Defines an one dimensional domain composed of a set of intervals of consecutive indexes |
| Cdont_care | Tag to represent that a particular item in an option will not change the overall choice |
| Cdpg_view | View providing predecessor info for graphs. Specialization when the underlying view/graph is DPG.In general there are two cases; one where this view is defined over a DPG graph, in which case the view is just a wrapper; and second where the underlying graph/view is not DPG and then we have to keep extra storage to keep track of predecessors in the view separate from the graph. These two cases are implemented using different partial specializations |
| Cdsssp_in_profiler | |
| Cdsssp_in_profiler_bgl | |
| Cdynamic_graph | Implementation of dynamic graph that supports addition and deletion of vertices and edges.Inherits from stapl::graph and adds functionality to add/delete vertices |
| Cdynamic_graph_base_container | Base-container for dynamic_graph. Inherits all functionality from graph_base_container |
| Cdynamic_graph_base_container_traits | Traits class for dynamic_graph_base_container |
| ►Cdynamic_graph_traits | Default traits for the dynamic_graph container. Specifies customizable type parameters that could be changed on a per-container basis |
| Cconstruct_distribution | Metafunction to compute the distribution type based on a container type |
| Cdynamic_graph_view | A dynamic graph view using adaptors for vertex and edge properties |
| Cdynamic_wf | Used to indicate that a work function deriving from this class should be provided the paragraph_impl::paragraph_view as the first argument to its function operator to allow it to add additional tasks to the PARAGRAPH |
| Ce_selector | Selector for extracting the vertex descriptor, given either a vertex descriptor or a vertex reference.Used by the pGraph external property map, where property is stored externally. Assumes descriptor based random-access in container |
| Ce_selector< G, typename G::edge_descriptor > | Selector for extracting the edge descriptor, given either an edge descriptor or an edge reference, specialized for descriptor.Used by the pGraph external edge property map, where property is stored externally. Assumes id based random-access in container |
| Ce_selector< G, typename G::edge_reference > | Selector for extracting the edge descriptor, given either an edge descriptor or an edge reference, specialized for reference.Used by the pGraph external edge property map, where property is stored externally. Assumes id based random-access in container |
| Ce_selector< G, typename G::vertex_descriptor > | Selector for extracting the vertex descriptor, given either a vertex descriptor or a vertex reference, specialized for descriptor.Used by the pGraph external property map, where property is stored externally. Assumes descriptor based random-access in container |
| Cea_iterator | Edge Iterator Adaptor for filtering out specific edge properties.The property adaptor used in this iterator is default constructed |
| Cedge_accessor | Underlying access mechanism for proxies of values stored in the PARAGRAPH edge_container |
| Cedge_container | The edge container maintains a distributed representation of the dependence (edges) for the PARAGRAPH and the various data flows they represent. It is the primary container for the PARAGRAPH infrastructure which is traversed during PARAGRAPH execution as tasks complete execution and notify the edge_container of their return value (if any), triggering data flow to all specified successors in the system |
| Cedge_descriptor_impl | Implementation of the edge descriptor |
| Cedge_source_comp | Helper class to compare two edges based on their source vertex-descriptors |
| Cedge_target_comp | Helper class to compare two edges based on their target vertex-descriptors |
| Cedge_target_equal | Helper class to equate two edges based on their target vertex-descriptors |
| Cedge_view | Provides a view over the edge_container allowing PARAGRAPH tasks to create data flow value consumption |
| Cempty_class | Empty class |
| Ceq_ed | Finds an edge with the specified edge id, source and destination |
| Ceq_eid | Finds an edge with the specified edge id |
| Ceq_property | Finds an edge with the specified user property |
| Ceq_target | Finds an edge with the specified target |
| Cequal_to | Function which returns whether its arguments are equal |
| Cexecute_all_t | Tag type to execute all scheduled entries |
| Cexecutor | Executor for scheduling runnable tasks with specific scheduling information |
| Cexecutor_base | Executor base class |
| Cexit_code | Class to return exit codes from STAPL applications |
| Cexplicit_domain | Defines an explicit one dimensional domain composed of indexes. The order of the indexes in the domain is given by the user. Each index that is valid in this domain must be explicitly enumerated |
| Cexplicit_partition | Partition a one-dimensional domain explicitly into subdomains that are stored in a container |
| Cexternal_descriptor_generator | An empty vertex descriptor generator. The vertex descriptors will be controlled externally by the user |
| Cextract_closed_domain_type | Struct extracting the closed-form domain type of a graph view if any, otherwise domset1D type is picked |
| Cextracted_closed_domain_type | Struct extracting the closed-form domain type of a graph view if any, otherwise domset1D type is used |
| Cextracted_closed_domain_type< false, GraphVw > | Struct extracting the closed-form domain type of a graph view if any, otherwise domset1D type is picked |
| Cf_ident | Defines an identity mapping function |
| Cface_property | Default face property for a cell face |
| Cfactory_wf | Concept base class used by factory workfunctions to denote that they are factory classes |
| Cfifo_scheduler | FIFO scheduler |
| Cfilter_view | Defines a filter view over the specified View |
| Cfind_edge_profiler | |
| Cfind_first_indices | Metafunction to find the indices of values in one tuple in another tuple |
| Cfind_vertex_profiler | |
| Cfirst_finite_domain_index | Type metafunction returning the index of the first element (i.e., view) of the tuple parameter Views which has a finite domain |
| Cfrontier_view | View over a subset of a graph based on the set of active vertices |
| Cfunction | A general-purpose polymorphic function wrapper |
| Cfunctor_container | Generator container whose value for the element at an index is the application of a functor on the index itself |
| Cfunctor_view_type | Defines a nested trait type that is the type of a functor view parameterized with a functor type |
| Cfuture | Provides a mechanism to access the result of asynchronous operations |
| Cfutures | Provides a mechanism to access the result of asynchronous operations |
| Cgang | Creates a new gang by partitioning the existing one from which the gang construction is invoked |
| Cgang_executor | Gang associated executor |
| Cgeneric_metadata_extraction | Functor used to return the locality metadata information of a general container (container that does not provide a metadata locality extractor functor) |
| Cgeom_vector | N-dimensional geometric vector |
| Cgeom_vector< 2, ELEMENT > | 2D geometric vector |
| Cgeom_vector< 3, ELEMENT > | 3D geometric vector |
| Cget_base_iterator | Metafunction used to compute the iterator type reflected by a base container |
| Cget_base_iterator< std::valarray< T > > | Specialization for valarray, where the iterator type is a raw pointer |
| Cget_descriptor | Class for extracting descriptor from an iterator |
| Cget_fast_view_type | Computes view type used if view localization (i.e. is_local()) succeeds during PARAGRAPH task creation |
| Cget_partition_domains | Compute the cell domains of mesh partitions |
| Cget_partition_weights | Functor to get and store partition weights in a property map |
| Cget_partitioner | Helper to extract the partition type used for the given partitioned view (Base case) |
| Cget_partitioner< overlap_view< View > > | Helper to extract the partition type used for the given Overlap |
| Cget_partitioner< segmented_view< C, PS, MFG, SVC > > | Helper to extract the partition type used for the given Segmented |
| Cget_vertex_weight | Functor extracting a vertex-weight in a property map |
| Cgetrusage_timer | Counter that uses getrusage() in POSIX systems |
| Cgettickcount_timer | Time counter that uses GetTickCount() in Windows systems |
| Cgettimeofday_timer | Time counter that uses gettimeofday() in POSIX systems. / |
| Cgpartition | Class representing a graph partition. The class provides queries to retrieve the partitions and measure its quality |
| Cgraph | Parallel static graph container. Inherits all functionality from either undirected_graph or directed_graph.Static graphs do not allow addition or deletion of vertices. The number of vertices must be known at construction. Edges may be added/deleted. Uses directedness selector to inherit from correct directed/undirected base |
| Cgraph_accessor | Accessor for vertices of a graph |
| Cgraph_base_container | Graph's base-container. Inherits all functionality from either graph_base_container_base or graph_base_container_NME class |
| Cgraph_base_container_base | Base class for the graph's base-container. Provides functionality of the graph API for local storage |
| Cgraph_base_container_NME | Class for Non-Multiedged graph's base-container. Derives from the graph_base_container_base class and overloads add_edge method for checking multiple edges |
| Cgraph_base_container_storage | Graph's base-container. Inherits all functionality from either graph_base_container_storage_base or graph_base_container_storage_NME class |
| ►Cgraph_base_container_storage_base | Base class for the graph's base-container. Provides functionality of the graph API for local storage |
| Ccached_vertex_impl_type | Write-back cache for hub-vertices |
| Ctriple | Class for storing a triplet |
| Cgraph_base_container_storage_NME | Class for Non-Multiedged graph's base-container. Derives from the graph_base_container_base class and overloads add_edge method for checking multiple edges |
| Cgraph_base_container_traits | Traits class for static graph_base_container |
| Cgraph_color | A color interface class for Breadth-First Search, Depth-First Search and Dijkstra's algorithm |
| Cgraph_color< size_t > | A default specialization of the graph_color class with size_t chosen as the value type to represent the colors |
| Cgraph_commit_log | Container for an ordered log of commits, which can be flushed later. Used by the lazy_graph_view_container to store log of deferred commits, as well as apply them to the appropriate pGraph at a suitable time |
| Cgraph_directedness_container_selector | Class for selecting between directed and undirected graphs |
| Cgraph_directedness_container_selector< DIRECTED, M, OptionalParams... > | Specialization of graph_directedness_container_selector for DIRECTED graph |
| Cgraph_directedness_container_selector< UNDIRECTED, M, OptionalParams... > | Specialization of graph_directedness_container_selector for UNDIRECTED graph |
| Cgraph_distribution | Distribution class for the dynamic_graph container |
| Cgraph_distribution_static | Distribution class for the stapl::graph container |
| Cgraph_distribution_traits | Default traits for the graph_distribution. Specifies distribution, domain and metadata types |
| Cgraph_edge_property_map | Internal property map to access edge properties stored on graph edges |
| Cgraph_external_edge_property_map | External property map to store edge properties |
| Cgraph_external_property_map | External property map to store vertex properties |
| Cgraph_internal_property_map | Internal property map to access vertex properties stored on graph vertices |
| Cgraph_metadata | Class for computing the metadata of graph_distribution |
| Cgraph_multiplicity_base_container_selector | Class for selecting between multi-edged and non-multi-edged graphs |
| Cgraph_multiplicity_base_container_selector< Traits, MULTIEDGES > | Specialization of graph_multiplicity_base_container_selector for MULTIEDGES graph |
| Cgraph_multiplicity_base_container_selector< Traits, NONMULTIEDGES > | Specialization of graph_multiplicity_base_container_selector for NONMULTIEDGES graph |
| Cgraph_param_selector | Class for selecting between default and optional template parameters |
| Cgraph_storage_multiplicity_base_container_selector | Class for selecting between multi-edged and non-multi-edged graphs |
| Cgraph_storage_multiplicity_base_container_selector< Traits, MULTIEDGES > | Specialization of graph_storage_multiplicity_base_container_selector for MULTIEDGES graph |
| Cgraph_storage_multiplicity_base_container_selector< Traits, NONMULTIEDGES > | Specialization of graph_multiplicity_base_container_selector for NONMULTIEDGES graph |
| Cgraph_view | View for the pGraph. Reflects all operations of a graph |
| Cgreater | Function which returns whether the first argument is greater than the second |
| Cgreater_equal | Function which returns whether the first argument is greater than or equal to the second |
| Chandle_accessor | Defines an accessor over a p_object, keeping a rmi_handle reference to perform rmi communications |
| Chandle_both_op | Helper function to evaluate the given binary operation Op when both input parameters are proxies |
| Chandle_both_op< Op, V, A1, A2, E1, typename A2::deferred_evaluation_accessor_ > | Helper function to evaluate the given binary operation Op when both input parameters are proxies but the right hand side proxy supports deferred evaluation (it does not necessarily reference a concrete value yet) |
| Chandle_both_op< Op, V, A1, A2, typename A1::deferred_evaluation_accessor_, E2 > | Helper function to evaluate the given binary operation Op when both input parameters are proxies but the left hand side proxy supports deferred evaluation (it does not necessarily reference a concrete value yet) |
| Chandle_both_op< Op, V, A1, A2, typename A1::deferred_evaluation_accessor_, typename A2::deferred_evaluation_accessor_ > | Helper function to evaluate the given binary operation Op when both input parameters are proxies both proxies support deferred evaluation (it does not necessarily reference a concrete value yet) |
| Chandle_both_op_convert | Helper function to evaluate the given binary operation Op when both input parameters are proxies and the value types differ |
| Chandle_left_op | Helper function to evaluate the given binary operation Op when the left hand side input parameter is a proxy |
| Chandle_left_op< Op, V, A, typename A::deferred_evaluation_accessor_ > | Helper function to evaluate the given binary operation Op when the left hand side input parameter is a proxy with support for deferred evaluation (it does not necessarily reference a concrete value yet) |
| Chandle_right_op | Helper function to evaluate the given binary operation Op when the right hand side input parameter is a proxy |
| Chandle_right_op< Op, V, A, typename A::deferred_evaluation_accessor_ > | Helper function to evaluate the given binary operation Op when the right hand side input parameter is a proxy with support for deferred evaluation (it does not necessarily reference a concrete value yet) |
| Chas_contiguous_edges | Metafunction to determine if a vertex's edge list is stored contiguously |
| Chas_finite_domain | Type metafunction returning true if View parameter has a domain type other than infinite |
| Chas_finite_domain_impl | Implementation metafunction for has_finite_domain, which guards inspection of a domain_type typedef to views that define it |
| Chas_identity_mf | Metafunction to determine if a view has an identity mapping function. Differs from has_identity in that if the type is not a view, it defaults to false_type |
| Chas_identity_mf< View, true > | Specialization for views |
| Chash | Default hash function for sequential hash containers |
| Chash< tuple< Args... > > | Specialization of hash for tuple. Use boost::hash_combine() to incorporate all elements of tuple into hash value |
| Chash_map | Container that stores key-value pairs by hashing the key to determine the position in the container where the elements will be stored |
| Chashtable | The Hashtable containing all the elements |
| Chelper_get_property | Helper to extract the property of a vertex/edge |
| Chelper_get_property< Iterator, properties::no_property > | Helper to extract the property of a vertex/edge. Specialized for when the vertex/edge does not have a property |
| Cheterogeneous_composed_dist_spec | Structure holding a composition of distribution specification views, each of which whose specification type and gid type maybe be different |
| Chgraph_view | PView providing specific methods for hierarchical graphs |
| Chomogeneous_tuple_to_array | Convert a tuple of homogeneous types to an std::array |
| Chomogeneous_tuple_type | Type metafunction return tuple type of length N with with all elements of type T |
| Ci_edge_selector | Selector for extracting the edge, given either an edge descriptor or an edge reference.Used by the pGraph internal edge property map, where property is stored internally on the edge by the pGraph, providing efficient storage and constant-time access to the edge property |
| Ci_edge_selector< G, typename G::edge_descriptor > | Selector for extracting the edge, given either an edge descriptor or an edge reference, specialized for descriptor.Used by the pGraph internal edge property map, where property is stored internally on the edge by the pGraph, providing efficient storage and constant-time access to the edge property |
| Ci_vertex_selector | Selector for extracting the vertex, given either a vertex descriptor or a vertex reference.Used by the pGraph internal property map, where property is stored internally on the vertex by the pGraph, providing efficient storage and constant-time access to the vertex property |
| Ci_vertex_selector< G, typename G::vertex_descriptor > | Selector for extracting the vertex, given either a vertex descriptor or a vertex reference, specialized for descriptor.Used by the pGraph internal property map, where property is stored internally on the vertex by the pGraph, providing efficient storage and constant-time access to the vertex property |
| Cident_prop_func | The identity functor for graph property maps |
| Cidentity | Function which returns its argument |
| Cidentity_container | Generator container whose value for the element at an index is the index itself |
| Cidentity_map | Computes an identity mapping of ids to partitions |
| Cidentity_op | Function which returns its argument |
| Cidentity_selector | An identity workfunction used in the skeleton framework can be both typed and typeless. In most of the cases if the workfunction used in a parametric dependency is strictly typed, meaning that it has defined result_type, the corresponding identity workfunction should be typed with the same type |
| Cidentity_value | Reflects the identity value for the given operation and operand types |
| Cimmutable_range_wrapper | Wraps a reference to a temporarily immutable range of objects |
| Cimmutable_reference_wrapper | Wraps a reference to a temporarily immutable object |
| Cimmutable_shared | Describes an immutable object |
| Cimplicit_regular_mesh_container | Implicit container representing a regular mesh |
| Cimplicit_regular_mesh_domain | Implicit domain representing the cells of a regular mesh |
| Cimplicit_regular_mesh_metadata | Functor returning the locality metadata information of the mesh container |
| Cimplicit_regular_mesh_view_type | Helper struct to get the type of a graph view over a mesh |
| Cimplicit_vertex | Implicit mesh cell built on-the-fly |
| Cimport_silo_file | Functor importing a mesh from a silo file |
| Cincremental_wf | Concept base class used by factory workfunctions to denote that they may not complete their work of creating tasks during a single invocation of the function operator and hence must be queried to check for required reinvocation |
| Cindex_bounds | Class to determine the bounds (min, max, error) of an index or GID |
| Cindex_bounds< stapl::tuple< T... > > | Specialization when the index or GID is a std::pair of different types |
| Cindex_bounds< std::pair< T, T > > | Specialization when the index or GID is a std::pair of the same type |
| Cindex_bounds< std::string > | Specialization when the index or GID is a std::string |
| Cindex_iterator | Definition of the iterator used for the View |
| Cindexed_domain | Defines a multi-dimensional domain where the indexes are consecutive and enumerable in each dimension |
| Cindexed_domain< T, 1 > | Specialization for a one-dimensional domain where the indexes are consecutive and numerable |
| Cinfinite | Represents a one dimensional infinite domain |
| Cinfinite_nd | Represents an n-dimensional infinite domain |
| Cinherit_retype | Helper class to change the derived type of the given |
| Cinherit_retype< VT< C, D, F, Derived >, Child > | Specialization to change the derived type of the given view |
| Cinitialize_parameter | Intercept optional parameters passed with an object of type use_default. If this occurs, return a default constructed instance of type Q. Otherwise, forward on the passed parameter |
| Cinteger_sequence | A compile-time sequence of integers |
| Cinternal_adj_edge_iterator_selector | Selector to infer adjacent edge iterator/property |
| Cinternal_adj_edge_iterator_selector< VGraph, use_default > | Selector to infer adjacent edge iterator/property |
| Cinternal_edge_iterator_selector | Selector to infer edge iterator/property |
| Cinternal_edge_iterator_selector< VGraph, use_default > | Selector to infer edge iterator/property |
| Cinternal_vertex_iterator_selector | Selector to infer vertex iterator/property |
| Cinternal_vertex_iterator_selector< VGraph, EAdaptor, use_default > | Selector to infer vertex iterator/property |
| Cinternal_vertex_iterator_selector< VGraph, use_default, use_default > | Selector to infer vertex iterator/property |
| Cinterval_container_registry | Base container storage that internally uses intervals based off the GID to perform loopkups |
| Cinterval_registry | This class is used to store directory entries in the container_directory class and subsequently, its base class directory. It models the map concept. For most pContainers, it is a safe assumption to expect that most GIDs will be mapped to the home location and that there will be only a small amount of GIDs that differ from this closed-form solution (through migration, etc.) |
| Cinvoke_arg | Wrapper used to specify the argument type during a function call declaration |
| Cis_arbitrary_view_based | Used to determine if the view is defined over a container that is distributed using an arbitrary distribution |
| Cis_arbitrary_view_based< view_based_partition< DistributionView, int > > | Used to determine if the view is defined over a container that is distributed using an arbitrary distribution |
| Cis_arbitrary_view_based< view_based_partition< DistributionView, PartitionInfoContainer > > | Used to determine if the view is defined over a container that is distributed using an arbitrary distribution |
| Cis_basic | Returns if T is a basic type |
| Cis_basic_impl | Detects if a type is basic or not |
| Cis_basic_impl_or | Returns if T is a basic type |
| Cis_bijective | Metafunction to determine if a mapping function is bijective. A mapping function is bijective if it reflects a true is_bijective trait, or it is both injective and surjective |
| Cis_container | Metafunction to determine if a given type is a STAPL container. The criteria for modeling a container is based on the existence of a nested distribution_type in T |
| Cis_container_wrapper_ref | Metafunction to determine if a given type is a container_wrapper_ref |
| Cis_contiguous | |
| Cis_contiguous_domain | Metafunction to compute whether or not a domain represents a contiguous chunk of GIDs |
| Cis_contiguous_domain< indexed_domain< T, N, OptionalTraversal... > > | Specialization for indexed_domain |
| Cis_csr | Metafunction to determine whether a graph is a CSR graph |
| Cis_csr< csr_graph< D, M, VP, EP, PS, Map, Traits > > | Specialization for CSR graphs |
| Cis_distribution_view | Used to determine if a type is an instantiation of a view-based distribution specification |
| Cis_distribution_view< V, false > | Used to determine if a type is an instantiation of a view-based distribution specification |
| Cis_distribution_view< V, true > | Used to determine if a type is an instantiation of a view-based distribution specification |
| Cis_domain_sparse | Type checker to determine if a domain is a sparse domain |
| Cis_domain_sparse< domainset1D< Distribution > > | Specialization of type checker to determine if domainset1D represents a sparse domain |
| Cis_domain_sparse< implicit_regular_mesh_domain< Coordinates, Traversal > > | Make implicit regular mesh domain a sparse domain |
| Cis_factory | Boolean type metafunction to detect if template parameter WF is a factory |
| Cis_identity | Type checker to determine if a mapping function is an identity mapping function |
| Cis_implied_gid_set | A metafunction that computes whether or not a GID set is an implied GID set |
| Cis_implied_gid_set< cm_impl::multi_implied_gid_set< Registry > > | Specialization for the multi-base-container implied GID set |
| Cis_implied_gid_set< cm_impl::single_implied_gid_set< Registry > > | Specialization for the single-base-container implied GID set |
| Cis_index_sequence | Metafunction to compute whether or not a type is an index_sequence |
| Cis_injective | Metafunction to determine if a mapping function is injective |
| Cis_invalid_gid | Functor checking if a gid tuple is invalid |
| Cis_invalid_gid<-1 > | Functor checking if a gid tuple is invalid |
| Cis_invertible_view | Metafunction to determine if a view has an inverse function defined for its mapping function and a finite domain |
| Cis_known_basic | Detects known basic types |
| Cis_local_iterator | Small type metafunction to detect whether given parameter is an instance of the local_iterator template |
| Cis_native_partition | Type checker to determine if a partition is a native_partition type |
| Cis_nested_container | Metafunction to determine if a given type is a STAPL container. The criteria for modeling a container is based on the existence of a nested distribution_type in T |
| Cis_nested_container< std::pair< T, U > > | Metafunction to determine if a given type is a STAPL container. This is a specialization used for map elements. The criteria for modeling a container is based on the existence of a nested distribution_type in T |
| Cis_non_commutative | Detects if BinaryOperation is a non-commutative operation |
| Cis_non_commutative_impl | Detects if BinaryOperation is non-commutative |
| Cis_p_object | Detects if T is a p_object |
| Cis_p_object_pointer | Detects if T is a pointer to a p_object |
| Cis_p_object_reference | Detects if T is a reference to a p_object |
| Cis_proxy | Type checker to determine if a variable is an instantiation of proxy |
| Cis_segmented_view | Type checker to determine if the given View type is an instantiation of segmented_view |
| Cis_SLICED_view | Type checker to determine if the given View type is an instantiation of SLICED_view |
| Cis_static | Class for differentiating static and dynamic graphs based on domain-type of the graph |
| Cis_static< iterator_domain< C, D > > | Class for differentiating static and dynamic graphs based on domain-type of the graph |
| Cis_static_dontcare | Metafunction returns true if View type parameter is statically known to have an LQ_DONTCARE vote. Primary template covers case when task_placement_dontcare typedef is not reflected in class |
| Cis_static_dontcare< View, true > | Specialization covers when task_placement_dontcare is defined |
| Cis_surjective | Metafunction to determine if a mapping function is surjective |
| Cis_view | Type checker to determine if a variable is an instantiation of view |
| Cis_view_based | Used to determine if the partition and mapper classes of a container's distribution use a view-based distribution specification |
| Cis_view_based< view_based_mapper< DistributionView > > | Used to determine if the partition and mapper classes of a container's distribution use a view-based distribution specification |
| Cis_view_based< view_based_partition< DistributionView, PartitionInfoContainer > > | Used to determine if the partition and mapper classes of a container's distribution use a view-based distribution specification |
| Citerator_core_access | Helper class to access the core members functions that are derived from iterator_facade |
| Citerator_domain | Domains based on iterators |
| Ck_way_multilevel | Parallel k-way multilevel graph partitioner partitioning a graph into k pieces using the multilevel scheme |
| Ckla_params | Optional parameters that controls the behavior of KLA, including enabling hub avoidance and providing post/pre execute functors |
| Clazy_edge_reference | Reference object by edge_view when creating a task. Delays the creation of edge_accessor until the address of the flowed value is available (i.e., is it directly in edge_entry managed storage or available via cross-location, immutable sharing |
| Clazy_graph_view | PGraph View for deferring pGraph operations which can be flushed later |
| Clazy_graph_view_container | Container for deferring pGraph operations which can be flushed later. Used by the lazy_graph_view to defer commits, as well as apply them to the appropriate pGraph at a suitable time |
| Clazy_ref_release_func | Helper functor to conditionally call release on a task's view members if they are a lazy_edge_reference. This functor is for use in ephemeral paragraphs and few call sites where lazy references are transiently created |
| Clazy_ref_release_persistent_func | Helper functor to conditionally call release on a task's view members if they are a lazy_edge_reference. This functor is for use in persistent paragraphs |
| Clazy_reference_wrapper | std::reference_wrapper -like class for distributed objects |
| Clazy_storage | Provides lazy construction of objects with automatic storage |
| Cless | Function which returns whether the first argument is less than the second |
| Cless_equal | Function which returns whether the first argument is less than or equal to the second |
| Clevel | Tag type to describe which level of the hierarchy is requested |
| Clightweight_multiarray_base | A base class for lightweight sequential containers used in the skeleton framework applications such as the NAS IS and FT benchmarks. This class wraps an std::vector and keeps a shared_ptr to the underlying std::vector |
| Clightweight_multiarray_storage | Basic linear storage class used by lightweight_multiarray_base to avoid initialization scan if desired |
| Clightweight_vector | This container is lightweight wrapper around std::vector and keeps a shared_ptr to the underlying std::vector |
| Clocal_accessor | Accessor for local proxies over base containers |
| Clocal_accessor_graph | Local accessor for pGraph's vertices.Derives from local_accessor and adds methods for property |
| Clocal_accessor_traits | Type metafunction to allow base containers to specify a different iterator type than their basic reflected type. Used in matrix base container when immediate iterator is a row iterator |
| Clocal_iterator | Iterator that is used to locally traverse a base container |
| Clocal_property_reference_constructor | Functor creates a reference either as a proxy or a view, based on use_view_as_reference metafunction |
| Clocality_dist_metadata | Helper to determine the metadata extractor type based on the given container (C) type |
| Clocality_dist_metadata< C, true > | Helper to determine the metadata extractor type based on the given container (C) type |
| Clocality_info | Locality information class used by the containers and views to coarsen data and provide information to tasks placement policies of a given PARAGRAPH's scheduler |
| Clocalize_element | Defines an object that provides the same interface as std::pair |
| Clocation_range_wrapper | Range of location ids |
| Clocation_specific_storage | Supports global objects in the presence of locations |
| Clogical_and | Function which returns the logical and of its arguments |
| Clogical_not | Function which returns the logical not of its argument |
| Cmain_wf | Function object that is used with execute() to initiate a STAPL application |
| Cmake_index_sequence_impl | Implementation of make_index_sequence |
| Cmake_traversal | Metafunction to compute a traveral type based on an integral variadic pack of indices |
| Cmap_factory | Factory that generates the tasks needed for a map operation. A map operation applies the work function provided on each set of elements of the input views that have the same offset from the beginning of their respective view |
| Cmap_fun_gen | Mapping function generator without state |
| Cmap_fun_gen1 | Mapping function generator where every mapping function generated is constructed passing the index as input argument |
| Cmap_manager | Responsible for determining the home location for elements of the map container, specifically for non-discrete GID types |
| Cmap_manager< Partition, Mapper, true, false > | Responsible for determining the home location for elements of the map container, specifically for discrete GID types |
| Cmap_manager< Partition, Mapper, true, true > | Responsible for determining the home location for elements of the map container, specifically for discrete GID types |
| ►Cmap_reduce_factory | Factory that generates the tasks needed for a map reduce operation. A map reduce operation applies the map work function provided on each set of elements of the input views that have the same offset from the beginning of their respective view. The map operations return values that are combined using the reduce operation provided to form a single result value. The result value is returned to each location in the gang executing the map_reduce call |
| Cresult | Computes the type of the result of the map_reduce PARAGRAPH for the set of views, map operation, and reduce operation provided |
| Cmapfunc_retype | Helper class to change the mapping function type of the given |
| Cmapfunc_retype< VT< C, D, F, Derived >, NF > | Specialization for mapfunc_retype to change the mapping function from the given |
| Cmapper | A container's mapper is responsible for mapping base container IDs (essentially subdomains) to locations |
| Cmember_accessor | Accessor used to reference struct/class member through the struct/class Accessor |
| Cmember_iterator | Defines an iterator used to reference data member elements directly through a pointer |
| Cmember_referencer | Functor creates a reference either as a proxy or a view for a member of another proxy, based on is_container metafunction |
| Cmemory_used | Returns an estimation of size of the passed object |
| Cmemory_used< adjacency_list_impl< Edge > > | Specialization of memory_used for adjacency_list_impl |
| Cmemory_used< std::list< T > > | Specialization used when the type is an std::list<> |
| Cmemory_used< std::map< Key, T > > | Specialization used when the type is an std::map<> |
| Cmemory_used< vertex_adj_list_impl< VD, Property, AdjList > > | Specialization of memory_used for vertex_adj_list_impl |
| Cmesh_partition_1d | Partition a mesh along one dimension |
| Cmetadata_entry | Defines the metadata entry that is used as value_type of a coarsen metadata container (e.g. metadata::growable_container) |
| Cmetadata_from_container | Helper functor to extract the locality metadata for each view in the given ViewSet |
| Cmin | Work function which returns the minimum of two values |
| Cminus | Function which returns the difference of its arguments |
| Cmix_view | Defines a view that behaves as the given View type but has information about data locality specified by the given locality information (Info) |
| Cmodulus | Function which returns the modulus of its arguments |
| Cmove_vertex_wf | Functor to move a vertex id from a partition to a target partition |
| Cmpi_wtime_timer | Time counter that uses MPI_Wtime() for systems with MPI |
| Cmultidigraph | Creates an DIRECTED, MULTIEDGES graph.Static graphs do not allow addition or deletion of vertices. The number of vertices must be known at construction. Edges may be added/deleted |
| Cmultidimensional_mapper | Maps multidimensional subdomains to locations in blocked manner in each dimension |
| Cmultigraph | Creates an UNDIRECTED, MULTIEDGES graph.Static graphs do not allow addition or deletion of vertices. The number of vertices must be known at construction. Edges may be added/deleted |
| Cmultiplies | Function which returns the product of its arguments |
| Cmultiview_coarsener | Functor to coarsen a set of given views |
| Cnative_ef | Functor to specify the super-edges for the hierarchy level representing the current distribution |
| Cnative_partitioner | Functor to specify the creation of super-vertices representing the actual distribution of a new level of hierarchy |
| Cnd_globalize< GID, index_sequence< Indices... > > | |
| Cnd_globalize< size_t > | |
| Cnd_linearize | Translates an n-dimensional gid to a 1-dimensional linearization, based on the given Traversal order |
| Cnd_linearize< size_t, Traversal > | Base case for nd_linearize for 1-dimensional GID |
| Cnd_localize< size_t > | |
| Cnd_partition | Defines a multidimensional partition, where Traversal specifies the traversal order defined over the generated partitioned domains |
| Cnd_reverse_linearize | Translates a 1-dimensional linearized GID to its n-dimensional GID, based on the given Traversal order |
| Cnd_reverse_linearize< size_t, Traversal > | Base case for nd_reverse_linearize for 1-dimensional GID |
| Cndom1D | One dimensional domain |
| Cndom2D | Two dimensional domain with ovelap information support |
| Cnegate | Function which returns the negation of its argument |
| Cneighbor_locations_t | Tag type to represent the neighbor locations of the current location |
| Cneighbor_random_hybrid_steal | Random neighbor stealing policy |
| Cnested_parent_pg_view | Lightweight view class created by consume and passed to add_task to facilitate setup dataflow from a parent's input port to a child PARAGRAPH |
| Cnested_parent_pg_view_subview | View class used as input to a nested paragraph created via add_task to setup dataflow from a parent's input port to a child PARAGRAPH |
| Cnested_pg_view | Lightweight view class created by consume and passed to add_task to facilitate setup of inter paragraph, port-based dataflow |
| Cnested_pg_view_subview | View class used as input to a nested paragraph created via add_task to setup dataflow from a producer, sibling paragraph |
| Cnew_cast_container_view | Container transformation meta-function with same purpose as cast_container_view but employing variadic based optional parameter support |
| Cnew_cast_container_view< View< OldC, Params... >, NewC, typename std::enable_if< !is_segmented_view< View< OldC, Params... > >::value &&!preserve_composition< View< OldC, Params... > >::value >::type > | new_cast_container_view specialization for the case when view composition should be flattened |
| Cnew_cast_container_view< View< OldC, Params... >, NewC, typename std::enable_if< !is_segmented_view< View< OldC, Params... > >::value &&preserve_composition< View< OldC, Params... > >::value >::type > | new_cast_container_view specialization for the case when view composition should be preserved |
| Cnew_upcast_view | Domain and mapping function transformation metafunction with purpose same as cast_container_view but employing variadic based optional parameter support |
| Cnfast_view | A view that has the same behavior as the given View type, but uses a base container as underlying container to provide fast access over the data |
| Cnfast_view< mix_view< repeat_view< view_impl::repeat_container< T, 1, true, true > >, Info, CID > > | Specialization for mix_view of repeat_view when a local copy might be fetched. Customized localization to be based on whether the local copy was fetched. Localize to a repeat view over this local copy |
| Cnfast_view< mix_view< transform_view< View, Functor >, Info, CID > > | Specialization to construct a fast_view over a transform_view |
| Cnfast_view< mix_view< view_impl::reverse_view< View >, Info, CID > > | Specialization for fast_view for reverse_view |
| Cnfast_view< mix_view< zip_view< Views... >, Info, CID > > | Specialization for fast_view for zip_view |
| Cno_comm_guard | Registers the given context as a no communication section of code |
| Cno_init_array_base_container_traits | Traits for the array base container that use an underlying container_type (lightweight_multiarray_storage), that avoids default initialization of values when possible (for now, when the stored datatype is fundamental) |
| Cno_initialization | Instruct the base container to attempt to use underlying sequential storage that does not default initialize elements during construction (unless a default value is defined by the user) |
| Cnon_commutative_wrapper | Wrapper class for a non-commutative binary operator |
| Cnone_t | Tag type for an invalid argument |
| Cnormal_partition | Partition in which domains created form a standard normal distribution |
| Cnot_equal_to | Function which returns whether its arguments are not equal |
| Cnot_matched | Tag class that is returned if a choice is not found for a static_match |
| Cnot_same | Negation of std::is_same |
| Cnull_coarsener | Identity coarsener. The same input views are returned as result of the coarsener |
| Cnull_reference | Tagging class used to define null references |
| Cnull_sequence | Functor to generate a sequence of default-constructed values |
| Cnull_sequence< int > | Functor to generate a sequence of default-constructed values |
| Coffset_gen | Wrapper around a generator functor that calls the generator's constructor to update its state to a specified offset, if the generator has implemented the method |
| Coption | Used to create a list of options |
| Coutput_graph_to_file | Work-function to print a native-view of the input graph to the given file |
| Coverlap_partition | Overlapping partition for one dimensional domains |
| Coverlap_view | An overlap view is a segmented view whose segments overlap by some number of elements in each dimension as specified by the user |
| Cp_object | Implements the base class for distributed objects |
| Cp_object_delete | Deletes a distributed object |
| Cpack_ref | Functor which serializes a reference |
| Cpack_ref< false > | Functor which serializes a reference using a given typer |
| Cpackage | Class which deconstructs a view into its constituent parts so that it can be serialized. For general views, extract and store the container pointer, domain, and mapping function. If it's a mix view, also extract and store the id and metadata info members |
| Cpackage< mix_view< repeat_view< Container >, Info, CID > > | Specialization of package for mix_view over repeat_view Must be treated differently due to fake container underlying that view |
| Cpackage< mix_view< View, Info, CID > > | Specialization of package for mix_view |
| Cpackage< repeat_view< Container > > | Specialization of package for repeated view. Only store the underlying, repeatedly referenced value. Then, reconstruct using this value on destination |
| Cpackage_container_storage | Class which abstract storage of container for package, storing a pointer for a p_object container type and by value for other container types (i.e., proxy) |
| Cpair_wise_tuple_comparison | Functor comparing 2 tuples pair-wise |
| Cpair_wise_tuple_comparison< Op,-1 > | Functor comparing 2 tuples pair-wise |
| Cpapi_counter | Counter that uses PAPI to measure different events |
| Cpapi_cycle_counter | Processor cycle counter that uses PAPI |
| Cpapi_timer | Time counter that uses PAPI |
| ►Cpapi_timer_n_counter | Counter that uses PAPI to measure both time and different events |
| Craw_value_type | Counter return type that stores time and requested counters |
| Cparagraph_location_metadata | Object held in location_specific_storage (one instance per location), tracking various pieces of low level information about the PARAGRAPHs executing on the location |
| Cparallel_reader | Work-function to read a graph from the given input file.Uses the user-provided reader to read each line and add the edges from the line to the graph |
| Cparent_pg_notifier | Notifier used to wire pin from parent input port to child input port if handle resolution failed (i.e., the parent isn't initialized on the child PG affinity). Uses child input port's handle, location, and pin id |
| Cpart_id_size | Helper class template that dispatches call to get_num_local_subviews to the first view parameter that has a finite domain |
| Cpartition_view_type | Helper to have the partition hierarchical view type |
| ►Cpartitioned_mix_view | Represents a view over the partitioned distributed locality metadata used to specify the data used in the tasks |
| Cloc_dist_metadata | Functor to extract locality metadata from the partitioned mix view |
| Cpersistent_scheduler | Persistent scheduler that extends from default_scheduler |
| Cpg_aware_multiview_coarsener | Coarsening that doesn't apply coarsener on the views coming from paragraph results |
| Cpg_edge_initialize | Implementation functor of pg_edge_unpackager using partial specialization to call initialize_flow() on objects from instances of the class template nested_pg_view_subview |
| Cpg_edge_unpackager | Called in view initialization of PARAGRAPH constructor to initialize inter-paragraph dataflow with producer paragraphs |
| Cpg_edge_view | Provides a view over the input ports of an inter-paragraph dataflow backed view argument, so that point to point dataflow to tasks within a consuming paragraph can be initiated |
| Cpg_lazy_edge_reference | Refinement of lazy_edge_reference concept for inter-paragraph port based dataflow. Holds pointer to associated edge_container to attempt evictions, instead of using task_graph reference provided by callers of release() |
| Cplus | Function which returns the sum of its arguments |
| Cpointer_wrapper | std::reference_wrapper -like class for pointers to objects |
| ►Cpool_allocator | Pool backed allocator |
| Crebind | Provides a way to obtain an allocator for a different type |
| Cpopulate_graph_from_shards | Work function that reads in a single shard and populates the graph |
| Cpreserve_composition | Meta-function providing a public member value which is true if given view composition ViewComp should be preserved during view casting |
| Cprint_property_struct | Functor to print the property on a vertex/edge (if it has one) |
| Cprint_property_struct< properties::no_property > | Specialization for functor to print the property on a vertex/edge when it does not exist (stapl::properties::no_property) |
| Cprint_tuple_impl | Static functor that uses template recursion to print all elements of a tuple with a comma delimiter |
| Cpriority_scheduler | Priority scheduler that supports integer priority |
| Cprobe | The probe is used to profile sections of code and dump the measurements to std::cout |
| Cprocess_memory_usage_counter | Memory usage counter that uses get_used_physical_memory() |
| Cprofile_config | |
| Cproject_cells | Functor to project a cell centroid on an axis |
| Cpromise | Provides a means of setting a result asynchronously, which may be retrieved through an instance of future |
| Cpromise_notifier | Function object encapsulating promised based notification. It is a notifier which holds the promise to be fulfilled and receives but ignores parameters used for rmi based data flow |
| Cpromise_notifier_adder | Function object encapsulating promise_notifier initialization via the Directory at the producer location |
| CProperty | This class is a (specialization of) proxy for sequential::graph_property_edge |
| Cproperty_accessor | Accessor for the property on vertices of a graph |
| Cproperty_reference_constructor | Functor creates a reference either as a proxy or a view, based on use_view_as_reference metafunction |
| Cproperty_reference_constructor< T, Container, GID, true > | |
| Cproxy | Defines a basic proxy over the element of type T |
| Cproxy< aux_info, Accessor > | Specialization of a proxy over aux_info |
| Cproxy< dynamic_graph< D, M, OptionalParams... >, Accessor > | This class is a (specialization of) proxy for dynamic_graph |
| Cproxy< graph< D, M, OptionalParams... >, Accessor > | Specialization of proxy for static stapl::graph |
| Cproxy< graph_edge_property_map< PG, Functor >, Accessor > | Specialization of proxy for graph_edge_property_map |
| Cproxy< graph_external_edge_property_map< PG, Property, View >, Accessor > | Specialization of proxy for graph_external_edge_property_map |
| Cproxy< graph_external_property_map< PG, Property, View >, Accessor > | Specialization of proxy for graph_external_property_map |
| Cproxy< graph_internal_property_map< PG, Functor >, Accessor > | Specialization of proxy for graph_internal_property_map |
| Cproxy< paragraph< Scheduler, Factory, Views... >, Accessor > | proxy specialization for PARAGRAPH type signature |
| Cproxy< sequential::graph_edge, VD > | This class is a (specialization of) proxy for sequential::graph_edge |
| Cproxy< sequential::short_graph_edge, VD > | This class is a (specialization of) proxy for sequential::short_graph_edge |
| Cproxy< stapl::array< T, OptionalParams... >, Accessor > | Specialization used when the type is an array. Refer to array for proper use of the container itself |
| Cproxy< stapl::static_array< T >, Accessor > | Specialization used when the type is a static_array. Refer to static_array for proper use of the container itself |
| Cproxy< stapl::vector< T, OptionalParams... >, Accessor > | Specialization of proxy for the vector container |
| Cproxy< vertex_adj_list_impl< VD, Property, AdjList >, Accessor > | Specialization of proxy for vertex_adj_list_impl |
| Cproxy< vertex_adj_list_impl< VD, Property, AdjList >, local_accessor_graph< Container > > | Specialization of proxy for vertex_adj_list_impl, specialized for local_accessor_graph, which lets us use a faster iterator over the edges than the member_iterator needed for the container_accessor |
| Cproxy< vertex_csr_impl< VD, Property, AdjList >, Accessor > | Specialization of proxy for vertex_csr_impl |
| Cproxy< vertex_csr_impl< VD, Property, AdjList >, local_accessor_graph< Container > > | Specialization of proxy for vertex_csr_impl, specialized for local_accessor_graph, which lets us use a faster iterator over the edges than the member_iterator needed for the container_accessor |
| Cproxy_core_access | Helper class used to access the proxy's accessor |
| Cproxy_holder | Custom PARAGRAPH edge storage a proxy |
| Cproxy_pair_holder | Custom PARAGRAPH edge storage for pairs of proxies |
| Cptr_wrapper | Wraps a view object with a interface that makes it behave as a pointer to a view of the same type would.This is used for PARAGRAPH edge views passed to add_task calls via consume calls, where there is not a view copy held/owned by the PARAGRAPH (i.e., those passed by user at PARAGRAPH creation) |
| Crandom_lifeline_steal | Stealing policy from one random neighbor |
| Crandom_location_generator | Random location id generator |
| Crandom_sequence | Generates a sequence of random values |
| Crange_wrapper | Describes a range of const objects |
| Cread_adj_list_line | Adjacency-list line-reader functor for the graph_reader().Reads a vertex and its adjacencies from the input line (stream). format: |
| Cread_dimacs_header | Dimacs header-reader for the graph_reader().Reads the header lines from the input file-stream. Skips over comment lines and reads number of vertices. format: |
| Cread_dimacs_line | Dimacs line-reader for the graph_reader().Reads an edge (source and target) from the input line (stream). format: |
| Cread_edge_list_line | Edge-list line-reader functor for the graph_reader().Reads an edge (source and target) from the input line (stream). EdgeList format: #edge-source #edge-target format: |
| Cread_edge_list_line_shuffle | Edge-list line-reader functor for the graph_reader().Reads an edge (source and target) from the input line (stream). Randomly shuffle the vertex IDs but maintain the right edges. This is useful when a bad locality for the vertices has to be broken EdgeList format: #edge-source #edge-target #weight format: |
| Cread_matrix_market_header | Matrix Market header-reader for the graph_reader().Reads the header lines from the input file-stream. Skips over comment lines and reads number of vertices. format: |
| Cread_matrix_market_line | Matrix Market line-reader functor for the graph_reader(). The file format is described at http://math.nist.gov/MatrixMarket/formats.html. Note that the vertex numbering is one based |
| Cread_weighted_edge_list_line | Weighted edge list line-reader functor for the graph_reader().Reads an edge (source target weight) from the input line (stream). EdgeList format: #edge-source #edge-target #weight format: |
| Cref_accessor | Defines the accessor that references a local element |
| Creferencer | Functor creates a reference either as a proxy or a view, based on use_view_as_reference metafunction |
| Cregular_face_property | Cell face of a regular mesh |
| Cregular_mesh_cell_neighbor | Functor that computes the index of a neighboring cell and the direction in which it lies from the cell provided |
| Cregular_mesh_cell_neighbor< DOM,-1 > | Functor getting a cell neighbor |
| Cregular_mesh_edge_func | Regular mesh edge functor creating the edges of a cell on-the-fly |
| Cremap_slices | Metafunction used when creating nested deep slices views to remap the slices received in a .slice<> operation |
| Cremote_notifier_adder | Function object encapsulating remote_notifier initialization via the Directory at the producer location |
| Crepeat_view | A view that can provide infinite copies of the same element |
| Crepetitive_sequence | A sequence that repeats itself every 'repeat' elements |
| Creplicated_cid | This code encapsulates a view index (previously call cid) used in cases when computation has been transparently replicated on portions of the system to avoid unnecessary communication |
| Cretype_ct_mf | Type metafunction used by new_cast_container_view to substitute a new container and mapfunc type in a given view type |
| Cretype_ct_mf_impl | Type metafunction which is implementation of retype_ct_mf. Receives original view, new container type, and new mapping function type. A boolean stating whether mapping function type has changed and a count of the number of optional params passed to view are used to dispatch to an appropriate partial specialization of the class template |
| Cretype_ct_mf_impl< View< OldC >, NewC, NewMF, false, 0 > | Specialization for case when only container view type parameter was specified and new mapping function is not the same as old mapping function |
| Cretype_ct_mf_impl< View< OldC >, NewC, NewMF, true, 0 > | Specialization for case when only container view type parameter was specified and new mapping function is the same as old mapping function |
| Cretype_ct_mf_impl< View< OldC, OldDom >, NewC, NewMF, false, 1 > | Specialization for case when container and domain view type parameter were specified and new mapping function is not the same as old mapping function |
| Cretype_ct_mf_impl< View< OldC, OldDom >, NewC, NewMF, true, 1 > | Specialization for case when container and domain view type parameter were specified and new mapping function is the same as old mapping function |
| Cretype_ct_mf_impl< View< OldC, OldDom, OldMF, OptionalArgs... >, NewC, NewMF, b_same_mf, num_optional > | Specialization for case when at least container, domain, and mapping function view type parameter were specified |
| Creversed_domain | Represents a one dimensional reversed domain over the given domain Dom |
| Crk_rk_steal | Random-k random-k stealing policy |
| Crk_steal | Random-k stealing policy |
| ►Crmi_handle | Provides a registration mechanism for RMI communication |
| Cconst_light_reference | Const light reference to an object that was registered through rmi_handle |
| Clight_reference | Light reference to an object that was registered through rmi_handle |
| Cro_binary_function | Represent a read-only binary functor, which provides typedefs for the argument and return types. Mimics the equivalent STL construct to allow for compatibility |
| Cro_unary_function | Represent a read-only unary functor, which provides typedefs for the argument and return types. Mimics the equivalent STL construct to allow for compatibility |
| Croot_location_t | Tag type to represent the root of a collective operation |
| Crows_partition | Partition in rows the given 2D domain |
| Crunnable_base | Common base for all entries that can be scheduled and executed, such as tasks and executors |
| Csafe_tuple_element | Metafunction that acts like tuple_element except when the index is -1, in which case it gives a default type instead |
| Csched_entry | Base scheduler entry class for entries that can know their scheduling information |
| Cscoped_counter | Function object to start and stop a counter object in a specific scope |
| Csegmented_view | Define a view over a virtual container of views (view_container) |
| Csegmented_view_base | Base class of segmented views |
| Cselect_derived | Determine the most derived class based on the given Derived type |
| Cselect_graph_edge | Helper for selecting the edge implementation based on property on edge and directedness of graph. Specializations for edges with no property are below |
| Cselect_parameter | Type metafunction used by class templates with default template parameters that might be lengthy in type / name. Shortens symbol names for better debug output and compile times |
| Cselect_parameter< use_default, Default > | Specialization when Passed parameter to metafunction is use_default |
| Cselect_stub | Helper to determine which stub to use based on the type of partition PS |
| Cseq_graph_traits | Traits class for adjacency_list_model based on dynamic storage |
| Csequence | Generates a sequence of consecutive values |
| Csequence_element | Get the I'th element in an |
| Cset_geom_vector | Functor to set the coordinates of a geometric vector |
| Cset_geom_vector<-1 > | Functor to set the coordinates of a geometric vector. Template specialization to stop the recursion on the coordinates |
| Cset_kba_like_partition_domains | Functor to compute a final partition after the partitioning of each dimension |
| Cset_kba_like_partition_domains< Dim, 1, Precision > | Functor to compute a final partition after the partitioning of each dimension |
| Cset_kba_like_partition_domains< Dim, 2, Precision > | Functor to compute a final partition after the partitioning of each dimension |
| Cset_kba_like_partition_domains< Dim, 3, Precision > | Functor to compute a final partition after the partitioning of each dimension |
| Cset_supervertex_domain | Functor setting the children domain of a super-vertex of a hierarchical view |
| Csharded_description | Representation of how an input graph is sharded on disk |
| Cshould_preserve | Helper meta-function providing a public member value which is true if the composition containing the provided view type View should be preserved during view casting |
| Csingle_container | Generator container that returns the same element for every access |
| Csingle_container_registry | Base container storage for pContainers that are guaranteed to have only one base container per location |
| Csingle_element_range | A range over a single element that can be used in a range-based for loop |
| Csize_tuple | Struct helper to select tuple type with the dimension |
| Csize_tuple< 2 > | Struct helper to select tuple type with the dimension |
| Csize_tuple< 3 > | Struct helper to select tuple type with the dimension |
| Csliced_balance_map | Computes a balanced mapping of ids to partitions using a subset of the elements in gid, as defined by the list of indices in PartitionIndexTuple |
| Csliced_partition | Partitioner that slices off dimensions of a d-dimensional domain to produce subdomains of dimension d-|Slices| |
| Csparse_interval_container_registry | Base container storage that internally uses sets of intervals based off the GID to perform loopkups |
| Cspatial_decomposition | Collapser decomposing a regular mesh into decomp partitions |
| Cspatial_regular_domain_decompose | Partition a domain representing a regular mesh |
| Csplitter_partition | Partition a one-dimensional domain explicitly into subdomains based on a fixed set of splitter GIDs |
| Cstart_computation_wf | Work function to start the base container ranking computation |
| Cstatic_array | Parallel non-migratable array container.This container provides fast access, but is limited in numerous ways: this container cannot be migrated; the distribution is fixed to a balanced partition with one base container per location |
| Cstatic_array_metadata | Class for computing the metadata of static_array container that uses container_manager_static that inherits from the base-container, and thus, is the base-container itself. This type of container manager has only one component per location |
| ►Cstatic_array_traits | Default traits for the static_array container. Specifies customizable type parameters that could be changed on a per-container basis |
| Cconstruct_distribution | Metafunction to compute the distribution type based on a container type |
| ►Cstatic_graph_traits | Default traits for the stapl::graph container. Specifies customizable type parameters that could be changed on a per-container basis |
| Cconstruct_distribution | Metafunction to compute the distribution type based on a container type |
| Cstatic_graph_view | A static graph view using adaptors for vertex and edge properties |
| Cstatic_match | Statically choose a type from a list of options |
| Cstatic_registry | This class is used to store directory entries in the container_directory class and subsequently, its base class directory. It models the map concept |
| Csteal_from_previous | Steal from left neighbor stealing policy |
| Csteal_policy_base | Base class for stealing policies |
| Cstl_vector_accessor | Defines an accessor for std::vector |
| Cstl_vector_const_accessor | Defines a const_accessor for std::vector |
| Cstream | A wrapper around a stream whose instances can be kept as data members of work functions. The wrapper allows work functions to access to the stream any location to which they may be sent via RMI invocation |
| Cstrided_view | A view over a container where elements are chosen based on a specified stride |
| Cstub | Stub class to provide -> access on a locally fetched copy of a remote object |
| Cstub_dontcare | Defines an object that provides the methods for data localization required for the task |
| Cstub_localize | Defines an object that provides the methods for data localization required for the task |
| Cstub_localize_nat_view | Defines an object that provides the methods for data localization required for the task |
| Cstub_self_element | Defines a view that behaves as the given View and provides the methods for data localization required for the task |
| Ctask_factory_base | Intermediate class of the task factory hierarchy that provides the edge_mf_type for all factories that derive from it |
| Ctautology | Default functor that accepts everything |
| Ctbb_range_adaptor | Adaptor that allows creation of a TBB compatible range from a view |
| Cterminator | General termination detection |
| Cterminator_base | Base class for termination detection |
| Ctg_callback | Callback to PARAGRAPH used by tasks to inform it of task completion, migration requests, etc.Tasks can be migrated to execute at locations outside where the associated PARAGRAPH is defined. This class generalizes task access to the PARAGRAPH to support such cases |
| Ctg_initializer | Allows the PARAGRAPH infrastructure to detect if an PARAGRAPH initialization is currently in progress. Aids in reference counting of cross PARAGRAPH data consumption when in non blocking execution mode |
| Cthis_location_t | Tag type to represent the current location |
| Ctransform_assign | Function which applies given functor to its first argument(s), and assigns the result to its last argument |
| Ctransform_view | Defines a view that behaves as the given View but applies the given functor to the elements when they are returned by get data methods |
| Ctransporter_packager | Functor used by to create serialized views for an out of PARAGRAPH task placement via executor_rmi |
| Ctransporter_packager_impl | Support class of transport_packager polymorphic functor. If the specified argument is a view, store its constituent parts in package and return the package. Otherwise, just return the argument |
| Ctransporter_unpackager | Functor used by transporter to unpack views sent out of PARAGRAPH gang by the task placement policy |
| Ctransporter_unpackager_impl | Support class of transporter_unpackager polymorphic functor. If the specified argument is a package, invoke the function operator. Otherwise, just return the argument |
| Ctraversal_profiler | |
| Ctraversal_profiler_bgl | |
| Ctrivial_accessor | Defines an accessor over a constant value |
| Ctry_transmitter | Transmitter for Directory that sends requests with try_rmi() |
| Ctunnel_aggregator | Aggregates requests to apply a functor (Func) on elements of a container |
| Ctuple_element | Wrap std::tuple_element and fix deficiency in libstdc++, which doesn't remove cv qualifications |
| Ctuple_size | Wrap std::tuple_size and fix deficiency in libstdc++, which doesn't remove cv qualifications.This wrapper also reflects value_type and type, and implements value_type(). All of these interfaces are specified in the standard, but are not yet provided by libstd++ |
| Ctype_constant_equal | Boost.MPL conforming metafunction to check that the passed compile-time constant is equal to N, regardless of whether it is a boost::mpl::int_ or std::integral_constant |
| Ctype_id_impl | Returns the type id of a non-polymorphic type |
| Ctype_printer | Prints the given type through the apply(std::ostream&) function |
| Ctypelist_printer | Prints the given list of types to the std::ostream |
| ►Ctyper | typer class is used for packing, unpacking and copying objects |
| Cbase_type_wrapper | Helper function used to disable implicit conversions |
| Ctyper_traits | Provides methods for assisting in packing and unpacking objects |
| Ctyper_traits_specialization | Traits class to detect which typer_traits is a specialization and which is the default |
| Cunary_negate | Function which returns whether its argument was not matched by the given predicate |
| Cunconditional_flow | Simple filter to pass to general consume_pg so that all indices in the output port are flowed to the consumer |
| Cunderlying_container< T, false > | Specialization for non-views |
| Cundirected_graph | Class for undirected-graph.Inherits all functionality from directed_graph_base, over-writing edge-related methods to provide undirected behaviour |
| Cundirected_view_type | Helper struct to get the type for undirected_view |
| Cuniform_ndim_to_linear_map | Computes the mapping of an n-dimensional component id to a linear location id in a uniform manner |
| Cunique_sorted_sequence | Generates a sequence of unique random sorted values |
| Cunordered_async_transmitter | Transmitter for Directory that sends requests using unordered::async_rmi() |
| Cunordered_map_adjacency_list_impl | Adjacency list of a vertex implemented as an unordered map of edges.Used inside the vertex_adj_list_impl to store adjacent edges |
| Cunordered_registry | |
| Cunstructured_mesh | Implementation of n-dimensional unstructured mesh. Inherits from stapl::dynamic_graph and adds functionality to manage cells, faces and mesh vertices |
| Cupcast_view | Helper class to change the domain and mapping function type of the given View to the specified new domain type Dom and mapping function type MF |
| Cupcast_view< array_ro_view< C >, Dom, MF > | Specialization ensures container domain and mapping function transform |
| Cupcast_view< array_view< C >, Dom, MF > | Specialization ensures container domain and mapping function transform |
| Cupcast_view< graph_view< C >, Dom, MF > | Specialization ensures container domain and mapping function transform |
| Cupcast_view< hgraph_view< C >, Dom, MF > | Specialization ensures container domain and mapping function transform |
| Cupcast_view< repeat_view< C >, Dom, MF > | Specialization ensures container domain and mapping function transform for variadic based optionals is used |
| Cupcast_view< segmented_view< C, P, MFG, SVC >, NewDom, NewMF > | Specialization of upcast_view (used to change mapping function and domain type of a view) for segmented_view. This has non standard template parameters (i.e., not C, D, MF, Derived) and furthermore is assumed to inherit domain from partition and have an identity mapping function. Assert that these have not been changed and reflect the original type passed to it |
| Cupcast_view< vector_view< C >, Dom, MF > | Specialization ensures container domain and mapping function transform |
| Cupcast_view_helper | Helper metafunction for new_upcast_view that dispatches based on presence of optional parameters and domain / mapping function changes to compute a view with possibly different domain and mapping function type parameters |
| Cupcast_view_helper< View, Dom, MF, true, true > | Specialization handling case that no domain or mapping function provided in original's view instantiation and new domain and mapping function are the same |
| Cupcast_view_helper< View< C >, Dom, MF, false, false > | Specialization handling case that no domain or mapping function provided in original's view instantiation and new domain and the mapping fucntion are the same |
| Cupcast_view_helper< View< C >, Dom, MF, false, true > | Specialization handling case that no domain or mapping function provided in original's view instantiation and new domain is not the same but the mapping function is the same |
| Cupcast_view_helper< View< C, OldDom >, Dom, MF, false, true > | Specialization handling case that domain is provided in original's view instantiation and new domain is not the same but the mapping function is the same |
| Cupcast_view_helper< View< C, OldDom, OldMF >, Dom, MF, same_dom, same_mf > | Specialization handling case that domain and mapping function are provided in original's view instantiation |
| Cupcast_view_helper< View< C, OldDom, OldMF >, Dom, MF, true, true > | Specialization handling case that domain and mapping function are provided in original's view instantiation and match the new domain and mapping function |
| Cuse_coarse | Implements the function operator to return the coarse-grained work function that will be used in a task specified by a factory |
| Cuse_default | Tag type detected by select_parameter metafunction to detect if a class template is specified by user or if default param is used |
| Cva_iterator | Specialized iterator with property adaptor to filter particular members of the property.The property adaptor used in this iterator is default constructed |
| Cva_iterator< VertexIterator, EdgeIter, use_default > | Specialized vertex iterator for when only the edge is adapted./The property adaptor used in this iterator is default constructed |
| Cvdg_strided | Class for generating vertex descriptors with a strided pattern.Used by the dynamic graph to add vertices when descriptors are not provided by users |
| Cvector | Parallel Vector container |
| Cvector_base_container | The base container used for vector |
| Cvector_base_container_traits | Default traits for the vector base container. These traits can be changed to customize base containers |
| Cvector_container_manager | Container manager used for the vector container |
| Cvector_directory | The container directory is responsible for distributed metadata for GIDs. It knows in which location GIDs reside. It also provides methods to invoke arbitrary functors on the location of GIDs without requiring external entities to know exact locality information |
| Cvector_distribution | Defines the vector distribution |
| Cvector_traits | Collection of types for vector |
| Cvector_view | Defines a view that provides the interface of a vector abstract data type. ( |
| Cvertex_adj_list_impl | Vertex for adjacency list for the graph |
| Cvertex_csr_impl | Vertex for a Compressed Sparse-Row (CSR) graph |
| Cvertex_descriptor_generator | A generator for vertex descriptors.This class will generate unique vertex descriptors, taking into account that the graph may auto generate them, as well as the users may specify them. This is specialized for different types of vertex descriptors |
| Cvertex_descriptor_generator< size_t > | A generator for vertex descriptors, specialized for size_t.This class will generate unique vertex descriptors, taking into account that the graph may auto generate them, as well as the users may specify them |
| Cvertex_to_adjlist_func | A functor to print a vertex and its adjacencies |
| Cvertex_to_adjlist_prop_func | A functor to print a vertex and its adjacencies |
| Cvertex_to_DOT_func | A functor to print a vertex and its adjacencies in DOT format |
| Cvertex_to_edgelist_1based_func | A functor to print a vertex and its adjacencies in 1-based form |
| Cvertex_to_edgelist_func | A functor to print a vertex and its adjacencies |
| Cview_based_mapper | Mapper which takes the functor mapping partition ids to locations from the distribution_view provided to the pContainer constructor |
| Cview_based_partition | Partition which takes the functor mapping pContainer GIDs to partition ids from the distribution_view provided to the pContainer constructor |
| Cview_container_base | Base class of view containers, which are containers that store subviews for segmented views |
| Cview_index_iterator | Iterator that traverses a disjoint partition of the indices of a view's elements |
| Cview_index_iterator_base | Base class used to allow view_index_iterator instances over different view types to be stored in an std::vector in a factory that performs incremental task generation |
| Cview_traits | Helper structure to extract the types provided by the given view type |
| Cview_traits< array_ro_view< C > > | Specialization for when only container type parameter is specified |
| Cview_traits< array_ro_view< C, D > > | Specialization for when container and domain type parameters are specified |
| Cview_traits< array_ro_view< C, D, F > > | Specialization for when container, domain, and mapping function type parameters are specified |
| Cview_traits< array_ro_view< C, D, F, Derived > > | Specialization for when all four type parameters are specified |
| Cview_traits< array_view< C > > | Specialization for when only container type parameter is specified |
| Cview_traits< array_view< C, D > > | Specialization for when container and domain type parameters are specified |
| Cview_traits< array_view< C, D, F > > | Specialization for when container, domain, and mapping function type parameters are specified |
| Cview_traits< array_view< C, D, F, Derived > > | Specialization for when all four type parameters are specified |
| Cview_traits< distribution_spec_view< C, D, GID, CID > > | Specialization for when container, domain, and mapping function type parameters are specified |
| Cview_traits< frontier_view< PG, Frontier > > | Specialization for when only container type parameter is specified |
| Cview_traits< frontier_view< PG, Frontier, D > > | Specialization for when container and domain type parameters are specified |
| Cview_traits< frontier_view< PG, Frontier, D, F > > | Specialization for when container, domain, and mapping function type parameters are specified |
| Cview_traits< frontier_view< PG, Frontier, D, F, Derived > > | Specialization for when all five type parameters are specified |
| Cview_traits< graph_view< C > > | Specialization for when only container type parameter is specified |
| Cview_traits< graph_view< C, D > > | Specialization for when container and domain type parameters are specified |
| Cview_traits< graph_view< C, D, F > > | Specialization for when container, domain, and mapping function type parameters are specified |
| Cview_traits< graph_view< C, D, F, Derived > > | Specialization for when all four type parameters are specified |
| Cview_traits< hgraph_view< C > > | Specialization for when only container type parameter is specified |
| Cview_traits< hgraph_view< C, D > > | Specialization for when container and domain type parameters are specified |
| Cview_traits< hgraph_view< C, D, F > > | Specialization for when container, domain, and mapping function type parameters are specified |
| Cview_traits< hgraph_view< C, D, F, Derived > > | Specialization for when all four type parameters are specified |
| Cview_traits< lazy_graph_view< C > > | Specialization of for the lazy_graph_view |
| Cview_traits< partitioned_mix_view< View, Part, CC > > | Specialization for view_traits to expose the types provided for partitioned_mix_view |
| Cview_traits< segmented_view< Container, Partition, MFG, SVC > > | Specialization for view_traits to expose the types provided for segmented_view |
| Cview_traits< transform_view< View, Functor > > | Specialization of view_traits for transform_view |
| Cview_traits< vector_view< C > > | Specialization for when only container type parameter is specified |
| Cview_traits< vector_view< C, D > > | Specialization for when container and domain type parameters are specified |
| Cview_traits< vector_view< C, D, F > > | Specialization for when container, domain, and mapping function type parameters are specified |
| Cview_traits< vector_view< C, D, F, Derived > > | Specialization for when all four type parameters are specified |
| Cview_traits< view_impl::reverse_view< View > > | Specialization of view_traits for reverse_view |
| Cview_traits< VT< C, D, F, Derived >, typename std::enable_if<!stapl::is_view< D >::value and !stapl::is_container< D >::value > > | Helper structure to extract the types provided by the given view type. Conditional inheritance guards against templates matching this signature that aren't views and enable_if prevents views accepting variadic number of views, and hence don't conform to their template parameter convention (i.e., Zip) |
| Cview_traits< zip_view< Views... > > | Specialization of view_traits for zip_view |
| Cview_traits_impl | Define traits for views and containers that do not conform to the V<C,D,F,Derived> template parameter convention |
| Cvisitor_base | A base class to be inherited by every visitor class |
| Cvisitor_predecessors_base | A base class to be inherited by every visitor predecessors class |
| Cvs_map_helper | Helper method for vs_map that does most of the actual work. Is passed the size of the tuples and this is used by the preprocessing below to create size specific specialization of this class template. Each specialization defines a static function with corresponding arity and repetition of operations |
| Cvs_map_reduce_helper | Helper method for vs_map_reduce that does most of the actual work. Is passed the size of the tuples and this is used by preprocessing below to create size specific specialization of this class template. Each specialization defines a static function with corresponding arity and repetition of operations |
| Cwatchdog_timer | Allows the creation of a watchdog timer that invokes the given function every interval milliseconds |
| Cweight_balanced_refiner | Refiner to balance partitions in a diffusive fashion. The diffusion is done pair-wise and each diffusion phase considers an independent set of partition pairs (2 pairs which do not have a partition in common) |
| Cwf_iter_compare | Helper class template that performs iterator comparison against an end iterator. The iterators are selected from a single view of a list of input views. The first view with a finite domain is selected for use in the comparison |
| Cwork_stealing_sched_entry | Wrapper class for entries in a work-stealing scheduler |
| Cwork_stealing_sched_info | Work-stealing scheduling information |
| Cwork_stealing_scheduler | Scheduler that provides work stealing support |
| Cwrap_ref | Functor which returns its argument (which is a reference) |
| Cwrap_ref< false > | Functor which wraps its argument in a stapl::proxy using a cref_accessor |
| Cxc30_energy_counter | Counter that measures energy consumption in Joules for the Cray XC30 platform |
| Czip_view | Defines a one dimensional view over a zipped set of views |
| ►Nstd | STL namespace |
| Chash< stapl::runtime::comparable_proxy > | Hash value creation functor for stapl::runtime::comparable_proxy |
| Chash< stapl::runtime::context_id > | Hash value creation functor for stapl::runtime::context_id |
| Chash< stapl::runtime::full_location > | Hash value creation functor for stapl::runtime::full_location |
| Chash< stapl::runtime::object_virtual_address > | Hasher for stapl::runtime::object_virtual_address |
1.8.13