| ▼pContainers | |
| ►Parallel Container Framework | Base classes that facilitate the development of new parallel containers |
| Traits Component Customization | Classes that specify customizable types that control container behavior, and may be changed for a given container instance |
| Element Manipulation | Base classes that implement element manipulation capabilities of a container |
| Data Distribution Management | Base classes that implement data distribution policies |
| Distributed Object Access | Base classes that implement remote access of a container instance |
| ►Array | |
| Array Traits | Specification of the customizable types of a container that can be changed for a given container instance |
| Distributed Object Access | Specializations of stapl::proxy that provide a remote reference for the container |
| Memory and Domain Management | Internal classes implementing functionality related to data distribution |
| ►Vector | |
| Vector Traits | Specification of the customizable types of a container that can be changed for a given container instance |
| Distributed Object Access | Specializations of stapl::proxy that provide a remote reference for the container |
| Memory and Domain Management | Internal classes implementing functionality related to data distribution |
| ▼pViews | |
| Base Parallel View | |
| ►Parallel View Framework | Base classes that facilitate the development of new parallel views |
| Traits Component Customization | Classes that specify customizable types that control view behavior, and may be changed for a given view instance |
| Validators for versioning | Validators used for view versioning |
| Core | |
| ►Model abstract data types | Model common abstract data types |
| Array | |
| Vector | |
| ArrayRO | |
| Model graph abstract data types | Model graph abstract data types |
| ►Use no storage | Present data without using concrete storage |
| Overlap | |
| Repeated | |
| Counting | |
| Functor | |
| ►Modify values of containers | Modify values retrieved from underlying view or container |
| Strided | |
| Reverse | |
| Filter | |
| Transform | |
| ►Compose views | Compose views with other views |
| Zip | |
| ►Specify a data distribution | Allow specification of an arbitrary data distribution |
| System | A set of location ids on to which partition ids may be mapped |
| Mapping | View to map partitions to location ids |
| Partitioning | View that maps element ids to partition ids |
| Distribution Specifications | A collection of functions that create view-based specifications of common data distributions |
| ►Modify distributions of containers | Modify distributions of underlying container |
| Native | |
| Balance | |
| Explicit | |
| Segmented | |
| ▼pAlgorithms | |
| ►Non-modifying Sequence Operations | Search and query view elements |
| Search Operations | Search for elements in view(s) that meet the specified criteria (e.g. stapl::find()). Defined in stapl/algorithms/algorithm.hpp |
| Summary Operations | Summarize the entire set of elements in the view(s) (e.g., stapl::equal()) |
| Extrema Operations | Find the extreme values in the view provided (e.g., stapl::min_element()). Defined in stapl/algorithms/algorithm.hpp |
| Counting Operations | Summarize the number of elements in the view(s) that meet the specified criteria. Defined in stapl/algorithms/algorithm.hpp |
| ►Mutating Sequence Operations | Modify the elements in a view |
| Generating Operations | Initialize the elements in a view (e.g., stapl::generate()). Defined in stapl/algorithms/algorithm.hpp |
| Removing Operations | Remove elements from the input view that meet a specified criteria (e.g., stapl::remove(), stapl::unique()). Defined in stapl/algorithms/algorithm.hpp |
| Reordering Operations | Reorder the elements in the input view (e.g., stapl::reverse(), stapl::rotate()). Defined in stapl/algorithms/algorithm.hpp |
| ►Sorting and Related Operations | Sort elements in a view or perform operations on sorted sequences |
| Sorting Operations | Sort the elements in a view. Defined in stapl/algorithms/sorting.hpp |
| Permuting Operations | Reorder the elements in a view. Defined in stapl/algorithms/sorting.hpp |
| Binary Search Operations | Search the elements of a view using binary search. Defined in stapl/algorithms/sorting.hpp |
| Sorting Related Operations | Algorithms related to sorting elements in views. Defined in stapl/algorithms/sorting.hpp |
| Generalized Numeric Algorithms | Algorithms for numeric operations on view elements. Defined in stapl/algorithms/numeric.hpp |
| ►Function Objects | A collection of element-wise operations commonly used to process view elements in a pAlgorithm. Defined in stapl/algorithms/functional.hpp |
| Base Function Objects | Base classes used to simplify the development of new operators that will be used in pAlgorithms. Defined in stapl/algorithms/functional.hpp |
| Comparator Function Objects | Function objects that implement element-wise comparison. Defined in stapl/algorithms/functional.hpp |
| Mutating Function Objects | Function objects that mutate one or both or their arguments. Defined in stapl/algorithms/functional.hpp |
| Numeric Function Objects | Function objects implement numeric operations. Defined in stapl/algorithms/functional.hpp |
| Logical Function Objects | Function objects implement logic operations. Defined in stapl/algorithms/functional.hpp |
| Bit-wise Function Objects | Function objects implement bit-wise operations on view elements. Defined in stapl/algorithms/functional.hpp |
| Reference Function Objects | Function objects that manipulate references to view elements. Defined in stapl/algorithms/functional.hpp |
| Binding Function Objects | Function objects that bind a value to one or more parameters of another function object. Defined in stapl/algorithms/functional.hpp |
| ▼The STAPL Skeletons Framework | The STAPL Skeletons Framework is a high-level skeletal approach for parallel programming |
| ►Spawning Environments | Environments define the representation of nodes and edges in the dataflow graphs generated from skeletons |
| Spawning Environments Internal | |
| ►Skeleton Execution | Entities to facilitate the execution of skeletons in STAPL |
| Skeleton Execution Internal | |
| ►Explicit Factories | The existing hand-written factories used prior to the existence of the Skeleton Framework |
| Explicit Factories Internal | |
| ►Flows | Flows are used to customize skeleton compositional operators by modifying input and output dependencies between their underlying skeletons |
| Flows Producer Classes | Helper classes to specify source of flows |
| Customized Compose Operator Flows | |
| Customized Repeat Operator Flows | |
| Customized Elem Operator Flows | |
| Customized Do-While Operator Flows | |
| Inline Specified Flows | |
| ►Functional Definition of Skeletons | The functional definition of skeletons which can be composed and transformed in the Skeletons Framework |
| Functional Definition of | |
| Functional Definition of | |
| Functional Definition of | |
| Functional Definition of | |
| Functional Definition of | |
| ►Compositional Operators | Compositional operators allow new skeletons to be defined from existing skeletons |
| Producer-Consumer | |
| Compositional Operators Internal | |
| ►Parametric Dependencies | Parametric dependencies define the finest-grain component of the Skeletons Framework. These entities are represented as nodes in the generated dataflow graphs in a given environment |
| Parametric Dependencies Internal | |
| Parametric Dependencies of | |
| Algorithm Specific Parametric | |
| Input Resizing Parametric | |
| Elementary Operator Spans | Spans define the dimensions of the parametric dependencies in an elementary skeleton based on the given input sizes |
| ►Transformation Operators | Transform the skeletons to other skeletons for various reasons (e.g., faster execution, nested execution, etc.) |
| Transformation Operators | |
| Utility Methods | |
| ►Executable Skeletons | Executable skeletons change functional skeletons from higher-order functions to regular functions by providing access to the input data |
| Executable Skeletons Internal | |
| ►Skeleton Tags | Tags are used to identify skeletons throughout the Skeletons Framework. Identifying skeletons using their tags allows transformations and optimizations to be simply defined over skeletons |
| Repeat Operator Tags | Sequence tags are used in customizing repeat flows |
| Do-While Operator Tags | Do-While tags are used in customizing do-while flows |
| Composed Skeletons Tags | These tags are generally used in the spawning process to identify various skeletons and to apply optimizations/transformations on them |
| Coarse Transformation | The coarsening operator transform skeletons which generate very fine-grained dataflow graphs to the skeletons which can handle data with larger granularity |
| ▼PARAGRAPH | The PARAGRAPH is the dependence graph representation of programs in STAPL |
| ►Edge Container | |
| Edge Container Entry and Supporting Code | |
| Edge Notifiers | |
| Edge Container Views | |
| Paragraph View Operations | |
| Paragraph Task Classes | |
| Paragraph View and Supporting Code | |
| Paragraph Result View and Supporting Code | |
| Paragraph Utility Files | |
| ▼Runtime System | The STAPL Runtime System (RTS) is the runtime system of STAPL that provides platform abstraction and portable performance for the rest of the components of STAPL |
| ►Adaptive Remote Method Invocation (ARMI) | Parallelism, communication and synchronization support |
| ARMI Tags | ARMI primitives tags |
| ARMI Type traits | Type traits related to ARMI |
| Distributed objects | Distributed object creation, registration, retrieval and destruction |
| ARMI One-sided primitives | One-sided (point-to-point or point-to-many) communication primitives |
| ARMI Collective primitives | Collective communication primitives |
| ARMI Synchronization primitives | Synchronization primitives |
| ARMI Unordered primitives | Communication primitives with relaxed consistency |
| Request aggregation control | Primitives that control aggregation |
| ARMI Utilities | Utility classes and variables |
| Serialization | Support for packing/unpacking of arbitrary types |
| ►Executors | stapl::paragraph_impl::paragraph task execution support |
| Scheduling information | Scheduling information support |
| Work Stealing | Work stealing support |
| Counters | Hardware counters support |
| Instrumentation | Runtime System and application instrumentation support |
| ►Runtime System implementation | Support functions and classes for the STAPL Runtime System (RTS) |
| Runtime Configuration | Compile-time configuration components of the Runtime System |
| Runtime Utilities | Support functions and classes for the Runtime System |
| Runtime Metadata | Runtime System metadata managing functions and classes |
| Distributed Memory Communication | Support functions and classes for communicating on distributed memory for the Runtime System |
| Collective Operations support | Support functions and classes for collective operations of the Runtime System |
| Threading Support | Support functions and classes for threads and mixed-mode for the Runtime System |
| ARMI Requests Building Blocks | Support functions and class for Adaptive Remote Method Invocation (ARMI) |
| ARMI Type traits implementation | Support functions and classes for ARMI Type traits |
| Serialization implementation | Support functions and classes for Serialization |
| Executors implementation | Support functions and classes for Executors |
| Instrumentation implementation | Support functions and classes for Instrumentation |
| ▼Utilities | STAPL utility files shared by multiple components |
| Directory | The directory used for message routing in the PARAGRAPH and pContainers |
| Boost/C++11 Tuple Wrapper | |
| Tags of Tree-type Skeletons | These tags are used in the Skeletons Framework to identify the various types of tree-based skeletons such as reduce, broadcast |
| Coarsening Transformation Tags | These tags are used in the coarsening process in order to specify algorithm transformation on skeletons |
| Tags specifying the execution | Tag type to identify a nest execution for wrapped_skeleton |
| Explicit Factories Tags | These tags are used to tag explicit factories in order to specify customized termination detection for them |
| Specializations for stand-alone begin. | The specializations for stand-alone iterator operations such as begin and end |
| SGLReferenceGenerators | Generate a scale-free network based on the Barabasi-Albert preferential attachment model |
1.8.13