| STAPL API Reference |
Modules Classes |
|
A compose operator puts a series of skeletons one after another. With the help of various compose_flows, one can customize the way these skeletons are connected. The most common flow for the compose operator is a piped flow. In fact, a compose with a piped flow is known as a pipeline in the literature.
More...
Typedefs | |
| template<typename T , typename Tag , typename Span > | |
| using | allgather = skeletons_impl::allgather< T, Span, stapl::default_type< Tag, tags::left_aligned > > |
| template<typename Tag , typename Span , typename Op > | |
| using | allreduce = skeletons_impl::allreduce< typename std::decay< Op >::type, stapl::default_type< Span, spans::balanced<> >, stapl::default_type< Tag, tags::left_aligned > > |
| template<typename T , typename Tag , typename Span > | |
| using | alltoall = skeletons_impl::alltoall< T, Span, stapl::default_type< Tag, tags::hybrid > > |
| template<typename Tag , typename Flows , typename Span , bool isComplete, typename Op > | |
| using | binary_tree = skeletons_impl::binary_tree< typename std::decay< Op >::type, Flows, stapl::default_type< Span, spans::balanced<> >, stapl::default_type< Tag, tags::left_aligned >, isComplete > |
| template<typename Span > | |
| using | bitreversal = skeletons_impl::bitreversal< Span > |
| template<typename Tag , typename Flows , typename Span , typename Op , bool SetResult> | |
| using | broadcast = skeletons_impl::broadcast< typename std::decay< Op >::type, Flows, stapl::default_type< Span, spans::balanced<> >, stapl::default_type< Tag, tags::left_aligned >, SetResult > |
| template<typename Tag , typename Flows , bool SetResult> | |
| using | broadcast_to_locs = skeletons_impl::broadcast_to_locs< Flows, Tag, SetResult > |
| template<bool is_pos_aware, typename Flows , typename Span , typename Op , typename Filter > | |
| using | butterfly = skeletons_impl::butterfly< typename std::decay< Op >::type, is_pos_aware, false, typename std::decay< Filter >::type, Flows, Span > |
| template<bool is_pos_aware, typename Flows , typename Span , typename Op , typename Filter > | |
| using | reverse_butterfly = skeletons_impl::butterfly< typename std::decay< Op >::type, is_pos_aware, true, typename std::decay< Filter >::type, Flows, Span > |
| template<typename ValueType , typename SkeletonTraits > | |
| using | copy = skeletons_impl::zip< 2, stapl::assign< ValueType >, SkeletonTraits > |
| template<typename Span , bool pos_aware, typename Op , typename Filter , bool SetResult> | |
| using | expand_from_pow_two = skeletons_impl::expand_from_pow_two< typename std::decay< Op >::type, stapl::default_type< Span, spans::balanced<> >, pos_aware, typename std::decay< Filter >::type, SetResult > |
| template<typename T , typename Span , typename Tag > | |
| using | fft = skeletons_impl::fft< T, stapl::default_type< Span, spans::balanced<> >, stapl::default_type< Tag, tags::dit > > |
| template<typename T , typename Tag , typename Span > | |
| using | gather = skeletons_impl::gather< T, Span, stapl::default_type< Tag, tags::left_aligned > > |
| template<typename ValueType > | |
| using | inner_product = result_of::zip_reduce< 2, stapl::multiplies< ValueType >, stapl::plus< ValueType > > |
| template<typename Op , typename SkeletonTraits > | |
| using | map = result_of::zip< 1, Op, SkeletonTraits > |
| template<typename MapOp , typename RedOp > | |
| using | map_reduce = result_of::zip_reduce< 1, MapOp, RedOp > |
| template<int NotifCount, typename Span , typename Flows , typename Op , typename Filter > | |
| using | notify_map = skeletons_impl::notify_map< typename std::decay< Op >::type, NotifCount, Span, Flows, typename std::decay< Filter >::type > |
| template<typename Flows , typename Op > | |
| using | pointer_jumping = skeletons_impl::pointer_jumping< typename std::decay< Op >::type, Flows > |
| template<std::size_t Arity, typename Op , typename SkeletonTraits > | |
| using | pre_broadcast = skeletons_impl::pre_broadcast< Arity, typename std::decay< Op >::type, typename std::decay< SkeletonTraits >::type > |
| template<typename Tag , typename Flows , typename Span , typename Op > | |
| using | reduce = skeletons_impl::reduce< typename std::decay< Op >::type, Flows, stapl::default_type< Span, spans::balanced<> >, stapl::default_type< Tag, tags::left_aligned > > |
| template<typename Tag , typename Flows , typename Span , typename Op , bool SetResult> | |
| using | reduce_to_locs = skeletons_impl::reduce_to_locs< typename std::decay< Op >::type, Flows, Span, Tag, SetResult > |
| template<typename Span , typename Op > | |
| using | reduce_to_pow_two = skeletons_impl::reduce_to_pow_two< typename std::decay< Op >::type, spans::reduce_to_pow_two< stapl::default_type< Span, spans::balanced<> >> > |
| template<typename Tag , typename Flows , typename Span , bool isComplete, bool isPositionAware, typename Op , typename Filter , bool SetResult> | |
| using | reverse_binary_tree = skeletons_impl::reverse_binary_tree< typename std::decay< Op >::type, Flows, stapl::default_type< Span, spans::balanced<> >, stapl::default_type< Tag, tags::left_aligned >, isComplete, typename std::decay< Filter >::type, isPositionAware, SetResult > |
| template<typename Tag , typename Op > | |
| using | inclusive_scan = skeletons_impl::inclusive_scan< Op, Tag > |
| template<typename Tag , typename Op , typename T > | |
| using | exclusive_scan = skeletons_impl::exclusive_scan< Op, T, Tag > |
| template<typename Tag , typename Op > | |
| using | scan = typename std::conditional< std::is_same< tags::binomial, typename skeletons_impl::scan_algorithm_tag_type< Tag >::type >::value||std::is_same< tags::hillis_steele, typename skeletons_impl::scan_algorithm_tag_type< Tag >::type >::value, skeletons_impl::inclusive_scan< typename std::decay< Op >::type, typename skeletons_impl::scan_algorithm_tag_type< Tag >::type >, skeletons_impl::scan< typename std::decay< Op >::type, Tag > >::type |
| Hillis-Steele scan can work on inputs with non-power-of-two sizes, therefore, we do not need to wrap it with extra steps. | |
| template<typename ValueType , typename Tag , typename Alg , typename Op > | |
| using | scan_reduce = skeletons_impl::scan_reduce< ValueType, Tag, Alg, Op > |
| template<typename T , typename Tag , typename Span > | |
| using | scatter = skeletons_impl::scatter< T, Span, stapl::default_type< Tag, tags::left_aligned > > |
| template<int i, typename Op > | |
| using | serial = skeletons_impl::serial< typename std::decay< Op >::type, i > |
| template<std::size_t Arity, typename Op , typename SkeletonTraits > | |
| using | set_result = skeletons_impl::set_result< Arity, typename std::decay< Op >::type, typename std::decay< SkeletonTraits >::type > |
| template<typename ValueType , typename SrcSkeleton , typename DestSkeleton > | |
| using | sink = decltype(skeletons::compose< flows::compose_flows::last_input_to_all >(std::declval< SrcSkeleton >(), std::declval< DestSkeleton >())) |
| template<typename ValueType , typename SkeletonTraits , typename Skeleton > | |
| using | sink_value = skeletons_impl::sink_value< typename std::decay< Skeleton >::type, ValueType, typename std::decay< SkeletonTraits >::type > |
| template<int Arity, typename Flows , typename Span , typename PD > | |
| using | tree = skeletons_impl::tree< typename std::decay< PD >::type, Arity, Flows, stapl::default_type< Span, spans::tree< spans::balanced<>, tags::left_aligned > >> |
| template<int Arity, typename Flows , typename Span , typename PD > | |
| using | reverse_tree = skeletons_impl::reverse_tree< typename std::decay< PD >::type, Arity, Flows, stapl::default_type< Span, spans::reverse_tree< spans::balanced<>, tags::left_aligned > >> |
| template<int Arity, typename Op , typename SkeletonTraits > | |
| using | zip = skeletons_impl::zip< Arity, typename std::decay< Op >::type, typename std::decay< SkeletonTraits >::type > |
| template<int Arity, typename ZipOp , typename RedOp > | |
| using | zip_reduce = skeletons_impl::zip_reduce< Arity, typename std::decay< ZipOp >::type, typename std::decay< RedOp >::type > |
| template<typename Flows , typename Skeletons > | |
| using | compose = typename compose_impl< Flows, Skeletons >::type |
| template<typename Flows , typename Body , typename Reduce , typename ContCond > | |
| using | do_while = skeletons_impl::do_while< typename std::decay< Body >::type, typename std::decay< Reduce >::type, typename result_of::elem< spans::per_location, stapl::use_default, skeletons_impl::do_while_pd< typename std::decay< ContCond >::type > >, stapl::default_type< Flows, flows::do_while_flows::piped > > |
| template<typename Span , typename Flows , typename PD > | |
| using | elem = skeletons_impl::elem< typename std::decay< PD >::type, typename span_default_type< typename std::decay< Span >::type, typename std::decay< PD >::type >::type, stapl::default_type< Flows, flows::elem_f::doall > > |
| template<typename Generator , typename Span > | |
| using | farm = result_of::elem< stapl::default_type< Span, spans::only_once >, stapl::use_default, skeletons_impl::farm_pd< typename std::decay< Generator >::type > > |
| template<typename Flows , typename S , typename SizeF > | |
| using | repeat = skeletons_impl::repeat< typename std::decay< S >::type, typename std::decay< SizeF >::type, stapl::default_type< Flows, flows::repeat_flows::piped > > |
A compose operator puts a series of skeletons one after another. With the help of various compose_flows, one can customize the way these skeletons are connected. The most common flow for the compose operator is a piped flow. In fact, a compose with a piped flow is known as a pipeline in the literature.
| Flows | the flow to be used for the compose. Some skeletons need a special flow than the default one. The default flow for a compose is piped flow. If tags::inline_flow is passed, the flow will be computed based on annotations added to the skeleton parameters. |
1.8.13