list_skeletons Class Reference

#include <list_skeletons.h>

List of all members.

Static Public Member Functions
template<typename F, typename A>
static dist_list< typename F::result_type > *	map (const F &f, const dist_list< A > *as)
	Map skeleton applies the function to each element.
template<typename F, typename A>
static void	map (const F &f, const dist_list< A > *as, dist_list< typename F::first_argument_type > *bs)
	Map skeleton applies the function to each element.
template<typename F, typename A>
static void	map_ow (const F &f, dist_list< A > *as)
	Map skeleton applies the function to each element.
template<typename F, typename A>
static dist_list< typename F::result_type > *	mapindex (const F &f, const dist_list< A > *as)
	Mapindex skeleton applies the function to each element. The function takes the index of the element for an argument.
template<typename F, typename A>
static void	mapindex (const F &f, const dist_list< A > *as, dist_list< typename F::first_argument_type > *bs)
	Mapindex skeleton applies the function to each element. The function takes the index of the element for an argument.
template<typename F, typename A>
static void	mapindex_ow (const F &f, dist_list< A > *as)
	Mapindex skeleton applies the function to each element. The function takes the index of the element for an argument.
template<typename OPLUS, typename A>
static A	reduce (const OPLUS &oplus, const A &e, const dist_list< A > *as)
	Reduce skeleton reduces the list into one element by applying a binary operator.
template<typename OPLUS, typename A>
static void	reduce (const OPLUS &oplus, const A *e, const dist_list< A > *as, A *retval)
	Reduce skeleton reduces the list into one element by applying a binary operator.
template<typename A, typename OPLUS>
static dist_list< A > *	scan (const OPLUS &oplus, const A &e, const dist_list< A > *as)
	Scan skeleton performs the prefix-sum like computation by applying a binary operator.
template<typename OPLUS, typename A>
static void	scan (const OPLUS &oplus, const A *e, const dist_list< A > *as, dist_list< A > *bs)
	Scan skeleton performs the prefix-sum like computation by applying a binary operator.
template<typename A, typename OPLUS>
static dist_list< A > *	scanr (const OPLUS &oplus, const A &e, const dist_list< A > *as)
	Scanr skeleton performs the postfix-sum like computation by applying a binary operator in the opposed way against scan.
template<typename OPLUS, typename A>
static void	scanr (const OPLUS &oplus, const A *e, const dist_list< A > *as, dist_list< A > *bs)
	Scanr skeleton performs the postfix-sum like computation by applying a binary operator in the opposed way against scan.
template<typename A, typename OPLUS>
static dist_list< A > *	prescan (const OPLUS &oplus, const A &e, const dist_list< A > *as)
	Prescan skeleton performs the prefix-sum like computation by applying a binary operator.
template<typename OPLUS, typename A>
static void	prescan (const OPLUS &oplus, const A *e, const dist_list< A > *as, dist_list< A > *bs)
	Prescan skeleton performs the prefix-sum like computation by applying a binary operator.
template<typename A, typename OPLUS>
static void	prescan_ow (const OPLUS &oplus, const A &e, dist_list< A > *as)
	Prescan skeleton performs the prefix-sum like computation by applying a binary operator.
template<typename A, typename OPLUS>
static dist_list< A > *	prescanr (const OPLUS &oplus, const A &e, const dist_list< A > *as)
	Prescanr skeleton performs the prefix-sum like computation by applying a binary operator in the oppsed way ageinst prescan.
template<typename OPLUS, typename A>
static void	prescanr (const OPLUS &oplus, const A *e, const dist_list< A > *as, dist_list< A > *bs)
	Prescanr skeleton performs the prefix-sum like computation by applying a binary operator in the oppsed way ageinst prescan.
template<typename A, typename OPLUS>
static void	prescanr_ow (const OPLUS &oplus, const A &e, dist_list< A > *as)
	Prescanr skeleton performs the prefix-sum like computation by applying a binary operator in the oppsed way ageinst prescan.
template<typename A, typename B>
static dist_list< std::pair< A, B > > *	zip (const dist_list< A > *as, const dist_list< B > *bs)
	Zip skeleton accepts two list and returns an list whose elements are pairs.
template<typename A, typename B>
static void	zip (const dist_list< A > *as, const dist_list< B > *bs, dist_list< std::pair< A, B > > *cs)
	Zip skeleton accepts two list and returns an list whose elements are pairs.
template<typename F, typename A, typename B>
static dist_list< typename F::result_type > *	zipwith (const F &f, const dist_list< A > *as, const dist_list< B > *bs)
	Zipwith skeleton applies the function to each pair of two lists, and is equivalent to the map skeleton after zip skeleton.
template<typename F, typename A, typename B>
static void	zipwith (const F &f, const dist_list< A > *as, const dist_list< B > *bs, dist_list< typename F::first_argument_type > *cs)
	Zipwith skeleton applies the function to each pair of two lists, and is equivalent to the map skeleton after zip skeleton.
template<typename F, typename A, typename B>
static dist_list< typename F::result_type > *	zipwithindex (const F &f, const dist_list< A > *as, const dist_list< B > *bs)
	Zipwithindex skeleton applies the function to each corresponding pair of two lists, furthermore, the function takes the index of the pair for the first argument.
template<typename F, typename A, typename B>
static void	zipwithindex (const F &f, const dist_list< A > *as, const dist_list< B > *bs, dist_list< typename F::first_argument_type > *cs)
	Zipwithindex skeleton applies the function to each corresponding pair of two lists, furthermore, the function takes the index of the pair for the first argument.
template<typename A>
static dist_list< A > *	shiftr (const A &firstval, const dist_list< A > *as)
	Shiftr skeleton shifts the input list to the right.
template<typename A>
static void	shiftr_ow (const A &firstval, dist_list< A > *as)
	Shiftr skeleton shifts the input list to the right. This function overwrites the input list.
template<typename A>
static dist_list< A > *	shiftl (const A &lastval, const dist_list< A > *as)
	Shiftl skeleton shifts the input list to the left.
template<typename A>
static void	shiftl_ow (const A &lastval, dist_list< A > *as)
	Shiftl skeleton shifts the input list to the left. This function overwrites the input list.
template<typename G, typename P, typename OPLUS, typename Q, typename OTIMES, typename A>
static P::result_type	accumulate (const G &g, const P &p, const OPLUS &oplus, const Q &q, const OTIMES &otimes, const typename G::argument_type &e, const dist_list< A > *as)
	Accumulate skeleton is an implementation for the parallelizable recursive function.
template<typename G, typename P, typename OPLUS, typename Q, typename OTIMES, typename A>
static void	accumulate (const G &g, const P &p, const OPLUS &oplus, const Q &q, const OTIMES &otimes, const typename G::second_argument_type *e, const dist_list< A > *as, typename P::first_argument_type *retval)
	Accumulate skeleton is an implementation for the parallelizable recursive function.
template<typename A>
static void	gather (const dist_list< A > *as, A *array)
	Gathers the distributed list to rank 0 process.
template<typename A>
static void	print (const dist_list< A > *as, std::ostream &stream=std::cout)
	Prints out the whole list.
template<typename A>
static void	print (const dist_list< A > *as, int index, std::ostream &stream=std::cout)
	Prints out the index-th element.
template<typename OPLUS, typename P, typename A>
static P::result_type	cataj (const OPLUS &oplus, const P &p, const typename P::result_type &e, const dist_list< A > *as)
template<typename OPLUS, typename P, typename A>
static void	cataj (const OPLUS &oplus, const P &p, const typename P::first_argument_type *e, const dist_list< A > *as, typename P::first_argument_type *retval)
template<typename OPLUS, typename A, typename B>
static std::pair< A, B >	zip_reduce (const OPLUS &oplus, const std::pair< A, B > &e, const dist_list< A > *as, const dist_list< B > *bs)
template<typename OPLUS, typename A, typename B>
static void	zip_reduce (const OPLUS &oplus, const std::pair< A, B > *e, const dist_list< A > *as, const dist_list< B > *bs, std::pair< A, B > *result)
template<typename F, typename OPLUS, typename A, typename B>
static F::result_type	zipwith_reduce (const F &f, const OPLUS &oplus, const typename F::result_type &e, const dist_list< A > *as, const dist_list< B > *bs)
template<typename F, typename OPLUS, typename A, typename B>
static void	zipwith_reduce (const F &f, const OPLUS &oplus, const typename F::result_type *e, const dist_list< A > *as, const dist_list< B > *bs, typename F::result_type *result)

---

Detailed Description

list_skeletons are skeletons for dist_list.

Definition at line 22 of file list_skeletons.h.

---

Member Function Documentation

template<typename G, typename P, typename OPLUS, typename Q, typename OTIMES, typename A> void list_skeletons::accumulate (  const G &  g, const P &  p, const OPLUS &  oplus, const Q &  q, const OTIMES &  otimes, const typename G::second_argument_type *  e, const dist_list< A > *  as, typename P::first_argument_type *  retval )  [inline, static]

Accumulate skeleton is an implementation for the parallelizable recursive function. Accumulate is a higher order function defined as follows. h = acc [ g, (p, oplus), (q, otimes) ] h [] e = g e h (x : xs) e = p (x, e) oplus h xs (e otimes q x) To guarantee the efficient parallelization, the associativity of oplus and otimes respectively, are required. This skeleton uses the functions which handles the arguments with their pointers. Definition at line 1198 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::local_size, skeleton::procs, skeleton::rank, TAG_ACCUMULATE2_1, TAG_ACCUMULATE2_2, and template_mpitype< A >::type(). Here is the call graph for this function:

template<typename G, typename P, typename OPLUS, typename Q, typename OTIMES, typename A> P::result_type list_skeletons::accumulate (  const G &  g, const P &  p, const OPLUS &  oplus, const Q &  q, const OTIMES &  otimes, const typename G::argument_type &  e, const dist_list< A > *  as )  [inline, static]

Accumulate skeleton is an implementation for the parallelizable recursive function. Accumulate is a higher order function defined as follows. h = acc [[ g, (p, oplus), (q, otimes) ]] h [] e = g e h (x : xs) e = p (x, e) oplus h xs (e otimes q x) To guarantee the efficient parallelization, the associativity of oplus and otimes respectively, are required. Definition at line 1104 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::local_size, skeleton::procs, skeleton::rank, TAG_ACCUMULATE1_1, TAG_ACCUMULATE1_2, and template_mpitype< A >::type(). Here is the call graph for this function:

template<typename OPLUS, typename P, typename A> void list_skeletons::cataj (  const OPLUS &  oplus, const P &  p, const typename P::first_argument_type *  e, const dist_list< A > *  as, typename P::first_argument_type *  retval )  [inline, static]

Definition at line 1424 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, skeleton::procs, skeleton::rank, TAG_CATAJ2, and template_mpitype< A >::type(). Here is the call graph for this function:

template<typename OPLUS, typename P, typename A> P::result_type list_skeletons::cataj (  const OPLUS &  oplus, const P &  p, const typename P::result_type &  e, const dist_list< A > *  as )  [inline, static]

Definition at line 1387 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, skeleton::procs, skeleton::rank, TAG_CATAJ1, and template_mpitype< A >::type(). Here is the call graph for this function:

template<typename A> void list_skeletons::gather (  const dist_list< A > *  as, A *  array )  [inline, static]

Gathers the distributed list to rank 0 process. Parameters: as  : The list to be gathered. [ in ] array  : The array to be stored result. Definition at line 1300 of file list_skeletons.tpp. References skeleton::cout, dist_list< A >::data, debug, dist_list< A >::get_begin_index(), dist_list< A >::get_local_size(), dist_list< A >::local_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_GATHER. Here is the call graph for this function:

template<typename F, typename A> void list_skeletons::map (  const F &  f, const dist_list< A > *  as, dist_list< typename F::first_argument_type > *  bs )  [inline, static]

Map skeleton applies the function to each element. map f [a0, a1, ..., an-1] = [ f a0, f a1, ... , f an-1 ]. This skeleton uses the function, which returns the results by putting it where the pointer indicates. Parameters: f  : The function to apply to elements, and this accepts the pointer to the return value for the first argument, and the constant pointer to the input value for the second argument. [ in ] as  : The input list to be applied by function f. [ in ] bs  : The result list, and the area must be allocated before calling this function. [ in, out ] Attention: If bs is pointing the same dist_list object as this, the pointers passed to f will be the same. Definition at line 40 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::get_global_size(), and skeleton::rank. Here is the call graph for this function:

template<typename F, typename A> dist_list< typename F::result_type > * list_skeletons::map (  const F &  f, const dist_list< A > *  as )  [inline, static]

Map skeleton applies the function to each element. map f [a0, a1, ..., an-1] = [ f a0, f a1, ... , f an-1 ]. This skeleton uses the function in usual function call style. Parameters: f  : The function to apply to elements. [ in ] as  : The input list to be applied by function f. [ in ] Definition at line 25 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::global_size, and skeleton::rank. Here is the call graph for this function:

template<typename F, typename A> void list_skeletons::map_ow (  const F &  f, dist_list< A > *  as )  [inline, static]

Map skeleton applies the function to each element. map f [a0, a1, ..., an-1] = [ f a0, f a1, ... , f an-1 ]. This skeleton uses the function, which overwrites the results on the inputs. Parameters: f  : The function to apply to elements. [ in ] as  : The input list to be applied by function f. [ in ] Definition at line 58 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, and skeleton::rank. Here is the call graph for this function:

template<typename F, typename A> void list_skeletons::mapindex (  const F &  f, const dist_list< A > *  as, dist_list< typename F::first_argument_type > *  bs )  [inline, static]

Mapindex skeleton applies the function to each element. The function takes the index of the element for an argument. mapindex f [a0, a1, ..., an-1] = [f 0 a0, f 1 a1, ..., f (n-1) an-1] This function uses the function, which handles the pointers for the arguments and the return value. Attention: If retlist is same as this object, the two pointers passed for f will be same. Parameters: f  : The function to apply to the list. [ in ] as  : The input list to be applied by function f. [ in ] bs  : The list for result, and must be allocated before calling function. [ in, out ] Definition at line 88 of file list_skeletons.tpp. References dist_list< A >::at(), dist_list< A >::begin, skeleton::cout, debug, dist_list< A >::get_global_size(), and skeleton::rank. Here is the call graph for this function:

template<typename F, typename A> dist_list< typename F::result_type > * list_skeletons::mapindex (  const F &  f, const dist_list< A > *  as )  [inline, static]

Mapindex skeleton applies the function to each element. The function takes the index of the element for an argument. mapindex f [a0, a1, ..., an-1] = [f 0 a0, f 1 a1, ..., f (n-1) an-1] Parameters: f  : The function to apply to the list. [ in ] as  : The input list to be applied by function f. [ in ] Definition at line 73 of file list_skeletons.tpp. References dist_list< A >::at(), dist_list< A >::begin, skeleton::cout, debug, dist_list< A >::global_size, and skeleton::rank. Here is the call graph for this function:

template<typename F, typename A> void list_skeletons::mapindex_ow (  const F &  f, dist_list< A > *  as )  [inline, static]

Mapindex skeleton applies the function to each element. The function takes the index of the element for an argument. mapindex f [a0, a1, ..., an-1] = [f 0 a0, f 1 a1, ..., f (n-1) an-1] This skeleton uses the function, which overwrites the results on the inputs. Parameters: f  : The function to apply to elements. [ in ] as  : The input list to be applied by function f. [ in ] Definition at line 106 of file list_skeletons.tpp. References dist_list< A >::at(), dist_list< A >::begin, skeleton::cout, debug, and skeleton::rank. Here is the call graph for this function:

template<typename OPLUS, typename A> void list_skeletons::prescan (  const OPLUS &  oplus, const A *  e, const dist_list< A > *  as, dist_list< A > *  bs )  [inline, static]

Prescan skeleton performs the prefix-sum like computation by applying a binary operator. prescan (oplus) e [a0, a1, ..., an-1] = [e, e oplus a0, e oplus a0 oplus a1, ..., e oplus a0 oplus a1 oplus ... oplus an-2] This function handles the pointers for the arguments. Parameters: oplus  : The binary associative operator. [ in ] e  : The initial value. [ in ] as  : The input list to be applied by oplus. [ in ] bs  : The pointer for the result list. [ in, out ] Attention: The pointers passed to the operator oplus are guaranteed not to be same. Definition at line 552 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::get_global_size(), dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SCAN2. Here is the call graph for this function:

template<typename A, typename OPLUS> dist_list< A > * list_skeletons::prescan (  const OPLUS &  oplus, const A &  e, const dist_list< A > *  as )  [inline, static]

Prescan skeleton performs the prefix-sum like computation by applying a binary operator. prescan (oplus) e [a0, a1, ..., an-1] = [e, e oplus a0, e oplus a0 oplus a1, ..., e oplus a0 oplus a1 oplus ... oplus an-2] Parameters: oplus  : The binary associative operator. [ in ] e  : The initial value. [ in ] as  : The input list to be applied by oplus. [ in ] Definition at line 502 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::global_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SCAN1. Here is the call graph for this function:

template<typename A, typename OPLUS> void list_skeletons::prescan_ow (  const OPLUS &  oplus, const A &  e, dist_list< A > *  as )  [inline, static]

Prescan skeleton performs the prefix-sum like computation by applying a binary operator. prescan (oplus) e [a0, a1, ..., an-1] = [e, e oplus a0, e oplus a0 oplus a1, ..., e oplus a0 oplus a1 oplus ... oplus an-2] Parameters: oplus  : The binary associative operator. [ in ] e  : The initial value. [ in ] as  : The input list to be applied by oplus. [ in ] Definition at line 611 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SCAN1. Here is the call graph for this function:

template<typename OPLUS, typename A> void list_skeletons::prescanr (  const OPLUS &  oplus, const A *  e, const dist_list< A > *  as, dist_list< A > *  bs )  [inline, static]

Prescanr skeleton performs the prefix-sum like computation by applying a binary operator in the oppsed way ageinst prescan. prescanr (oplus) e [a0, a1, ..., an-1] = [e oplus a0 oplus a1 oplus ... oplus an-2, ..., e oplus a0, e] This function handles the pointers for the arguments. Parameters: oplus  : The binary associative operator. [ in ] e  : The initial value. [ in ] as  : The input list to be applied by oplus. [ in ] bs  : The pointer for the result list. [ in, out ] Attention: The pointers passed to the operator oplus are guaranteed not to be same. Definition at line 725 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::get_global_size(), dist_list< A >::local_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SCANR1. Here is the call graph for this function:

template<typename A, typename OPLUS> dist_list< A > * list_skeletons::prescanr (  const OPLUS &  oplus, const A &  e, const dist_list< A > *  as )  [inline, static]

Prescanr skeleton performs the prefix-sum like computation by applying a binary operator in the oppsed way ageinst prescan. prescanr (oplus) e [a0, a1, ..., an-1] = [e oplus a0 oplus a1 oplus ... oplus an-2, ..., e oplus a0, e] Parameters: oplus  : The binary associative operator. [ in ] e  : The initial value. [ in ] as  : The input list to be applied by oplus. [ in ] Definition at line 661 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::global_size, dist_list< A >::local_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SCANR1. Here is the call graph for this function:

template<typename A, typename OPLUS> void list_skeletons::prescanr_ow (  const OPLUS &  oplus, const A &  e, dist_list< A > *  as )  [inline, static]

Prescanr skeleton performs the prefix-sum like computation by applying a binary operator in the oppsed way ageinst prescan. prescanr (oplus) e [a0, a1, ..., an-1] = [e oplus a0 oplus a1 oplus ... oplus an-2, ..., e oplus a0, e] Parameters: oplus  : The binary associative operator. [ in ] e  : The initial value. [ in ] as  : The input list to be applied by oplus. [ in ] Definition at line 798 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::local_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SCANR1. Here is the call graph for this function:

template<typename A> void list_skeletons::print (  const dist_list< A > *  as, int  index, std::ostream &  stream = std::cout )  [inline, static]

Prints out the index-th element. This function moves the index -th element to the rank 0 process, and print out to out. To use this function, the class A must implement the operator<<. Parameters: as  : The list to be printed out. [ in ] index  : The global index to print out. [ in ] stream  : The output stream to print out to. [ in ] Todo: destination check is not efficient.... Definition at line 1355 of file list_skeletons.tpp. References dist_list< A >::at(), dist_list< A >::begin, dist_list< A >::get_begin_index(), dist_list< A >::get_end_index(), dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_PRINT2. Here is the call graph for this function:

template<typename A> void list_skeletons::print (  const dist_list< A > *  as, std::ostream &  stream = std::cout )  [inline, static]

Prints out the whole list. This function moves the elements to the rank 0 process, and print out to out. To use this function, the class A must implement the operator<<. Parameters: as  : The list to be printed out. [ in ] stream  : The output stream to print out to. [ in ] Definition at line 1328 of file list_skeletons.tpp. References dist_list< A >::at(), dist_list< A >::data, dist_list< A >::get_local_size(), dist_list< A >::local_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_PRINT1. Here is the call graph for this function:

template<typename OPLUS, typename A> void list_skeletons::reduce (  const OPLUS &  oplus, const A *  e, const dist_list< A > *  as, A *  retval )  [inline, static]

Reduce skeleton reduces the list into one element by applying a binary operator. reduce (oplus) e [a0, a1, ..., an-1] = e oplus a0 oplus a1 oplus ... oplus an-1. This skeleton handles the pointers for the arguments. Parameters: oplus  : The binary associative operator. [ in ] e  : The initial value. [ in ] as  : The input list to be applied by oplus. [ in ] retval  : The pointer for the result value. [ out ] Definition at line 155 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_REDUCE2. Here is the call graph for this function:

template<typename OPLUS, typename A> A list_skeletons::reduce (  const OPLUS &  oplus, const A &  e, const dist_list< A > *  as )  [inline, static]

Reduce skeleton reduces the list into one element by applying a binary operator. reduce (oplus) e [a0, a1, ..., an-1] = e oplus a0 oplus a1 oplus ... oplus an-1. Parameters: oplus  : The binary associative operator. [ in ] e  : The initial value. [ in ] as  : The input list to be applied by oplus. [ in ] Definition at line 121 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_REDUCE1. Here is the call graph for this function:

template<typename OPLUS, typename A> void list_skeletons::scan (  const OPLUS &  oplus, const A *  e, const dist_list< A > *  as, dist_list< A > *  bs )  [inline, static]

Scan skeleton performs the prefix-sum like computation by applying a binary operator. scan (oplus) e [a0, a1, ..., an-1] = [e, e oplus a0, e oplus a0 oplus a1, ..., e oplus a0 oplus a1 oplus ... oplus an-1] This function handles the pointers for the arguments. Parameters: oplus  : The binary associative operator. [ in ] e  : The initial value. [ in ] as  : The input list to be applied by oplus. [ in ] bs  : The pointer for the result list. [ in, out ] Attention: The pointers passed to the operator oplus are guaranteed not to be same. Definition at line 260 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::get_global_size(), dist_list< A >::global_size, dist_list< A >::local_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SCAN2. Here is the call graph for this function:

template<typename A, typename OPLUS> dist_list< A > * list_skeletons::scan (  const OPLUS &  oplus, const A &  e, const dist_list< A > *  as )  [inline, static]

Scan skeleton performs the prefix-sum like computation by applying a binary operator. scan (oplus) e [a0, a1, ..., an-1] = [e, e oplus a0, e oplus a0 oplus a1, ..., e oplus a0 oplus a1 oplus ... oplus an-1] Parameters: oplus  : The binary associative operator. [ in ] e  : The initial value. [ in ] as  : The input list to be applied by oplus. [ in ] Definition at line 195 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::global_size, dist_list< A >::local_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SCAN1. Here is the call graph for this function:

template<typename OPLUS, typename A> void list_skeletons::scanr (  const OPLUS &  oplus, const A *  e, const dist_list< A > *  as, dist_list< A > *  bs )  [inline, static]

Scanr skeleton performs the postfix-sum like computation by applying a binary operator in the opposed way against scan. scanr (oplus) e [a0, ..., an-2, an-1] = [a0 oplus ... oplus an-1 oplus e, ..., an-2 oplus an-1 oplus e, an-1 oplus e, e] This function handles the pointers for the arguments. Parameters: oplus  : The binary associative operator. [ in ] e  : The initial value. [ in ] as  : The input list to be applied by oplus. [ in ] bs  : The pointer for the result list. [ in, out ] Attention: The pointers passed to the operator oplus are guaranteed not to be same. Definition at line 411 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::get_global_size(), dist_list< A >::global_size, dist_list< A >::local_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SCANR2. Here is the call graph for this function:

template<typename A, typename OPLUS> dist_list< A > * list_skeletons::scanr (  const OPLUS &  oplus, const A &  e, const dist_list< A > *  as )  [inline, static]

Scanr skeleton performs the postfix-sum like computation by applying a binary operator in the opposed way against scan. scanr (oplus) e [a0, ..., an-2, an-1] = [a0 oplus ... oplus an-1 oplus e, ..., an-2 oplus an-1 oplus e, an-1 oplus e, e] Parameters: oplus  : The binary associative operator. [ in ] e  : The initial value. [ in ] as  : The input list to be applied by oplus. [ in ] Definition at line 332 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::global_size, dist_list< A >::local_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SCANR1. Here is the call graph for this function:

template<typename A> dist_list< A > * list_skeletons::shiftl (  const A &  lastval, const dist_list< A > *  as )  [inline, static]

Shiftl skeleton shifts the input list to the left. Parameters: lastval  : The value inserted into the rightmost position. [ in ] as  : The input list to be shifted to the left. [ in ] Definition at line 1052 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::global_size, dist_list< A >::local_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SHIFTL1. Here is the call graph for this function:

template<typename A> void list_skeletons::shiftl_ow (  const A &  lastval, dist_list< A > *  as )  [inline, static]

Shiftl skeleton shifts the input list to the left. This function overwrites the input list. Parameters: lastval  : The value inserted into the rightmost position. [ in ] as  : The input list to be shifted to the left. [ in ] Definition at line 1079 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::local_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SHIFTL2. Here is the call graph for this function:

template<typename A> dist_list< A > * list_skeletons::shiftr (  const A &  firstval, const dist_list< A > *  as )  [inline, static]

Shiftr skeleton shifts the input list to the right. Parameters: firstval  : The value inserted into the leftmost position. [ in ] as  : The input list to be shifted to the right. [ in ] Definition at line 1004 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::global_size, dist_list< A >::local_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SHIFTR1. Here is the call graph for this function:

template<typename A> void list_skeletons::shiftr_ow (  const A &  firstval, dist_list< A > *  as )  [inline, static]

Shiftr skeleton shifts the input list to the right. This function overwrites the input list. Parameters: firstval  : The value inserted into the leftmost position. [ in ] as  : The input list to be shifted to the right. [ in ] Definition at line 1030 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::local_size, dist_list< A >::mpitype, skeleton::procs, skeleton::rank, and TAG_SHIFTR2. Here is the call graph for this function:

template<typename A, typename B> void list_skeletons::zip (  const dist_list< A > *  as, const dist_list< B > *  bs, dist_list< std::pair< A, B > > *  cs )  [inline, static]

Zip skeleton accepts two list and returns an list whose elements are pairs. zip [a0, a1, ..., an-1] [b0, b1, ..., bn-1] = [(a0, b0), (a1, b1), ..., (an-1, bn-1)] Parameters: as  : The first list to zip up. [ in ] bs  : The second list to zip up. [ in ] cs  : The pointer for the result list. [ in, out ] Definition at line 887 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::get_global_size(), and skeleton::rank. Here is the call graph for this function:

template<typename A, typename B> dist_list< std::pair< A, B > > * list_skeletons::zip (  const dist_list< A > *  as, const dist_list< B > *  bs )  [inline, static]

Zip skeleton accepts two list and returns an list whose elements are pairs. zip [a0, a1, ..., an-1] [b0, b1, ..., bn-1] = [(a0, b0), (a1, b1), ..., (an-1, bn-1)] Parameters: as  : The first list to zip up. [ in ] bs  : The second list to zip up. [ in ] Definition at line 865 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::get_global_size(), dist_list< A >::global_size, and skeleton::rank. Here is the call graph for this function:

template<typename OPLUS, typename A, typename B> void list_skeletons::zip_reduce (  const OPLUS &  oplus, const std::pair< A, B > *  e, const dist_list< A > *  as, const dist_list< B > *  bs, std::pair< A, B > *  result )  [inline, static]

Definition at line 1504 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::get_global_size(), skeleton::procs, skeleton::rank, TAG_REDUCE2, and template_mpitype< A >::type(). Here is the call graph for this function:

template<typename OPLUS, typename A, typename B> std::pair< A, B > list_skeletons::zip_reduce (  const OPLUS &  oplus, const std::pair< A, B > &  e, const dist_list< A > *  as, const dist_list< B > *  bs )  [inline, static]

Definition at line 1462 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::get_global_size(), skeleton::procs, skeleton::rank, TAG_REDUCE1, and template_mpitype< A >::type(). Here is the call graph for this function:

template<typename F, typename A, typename B> void list_skeletons::zipwith (  const F &  f, const dist_list< A > *  as, const dist_list< B > *  bs, dist_list< typename F::first_argument_type > *  cs )  [inline, static]

Zipwith skeleton applies the function to each pair of two lists, and is equivalent to the map skeleton after zip skeleton. zipwith f [a0, a1, ..., an-1] [b0, b1, ..., bn-1] = [f a0 b0, f a1 b1, ..., f an-1 bn-1] This skeleton uses the function, which handles the pointers for arguments. Attention: If you passed the same dist_list for this, as, or cs, the pointers passed to function f might become the same. Parameters: f  : The function to apply to lists. [ in ] as  : The first list. [ in ] bs  : The second list. [ in ] cs  : The result list, and must be allocated before calling this function. [ in, out ] Definition at line 933 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::get_global_size(), and skeleton::rank. Here is the call graph for this function:

template<typename F, typename A, typename B> dist_list< typename F::result_type > * list_skeletons::zipwith (  const F &  f, const dist_list< A > *  as, const dist_list< B > *  bs )  [inline, static]

Zipwith skeleton applies the function to each pair of two lists, and is equivalent to the map skeleton after zip skeleton. zipwith f [a0, a1, ..., an-1] [b0, b1, ..., bn-1] = [f a0 b0, f a1 b1, ..., f an-1 bn-1] Parameters: f  : The function to apply to lists. [ in ] as  : The first list. [ in ] bs  : The second list. [ in ] Definition at line 912 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::get_global_size(), dist_list< A >::global_size, and skeleton::rank. Here is the call graph for this function:

template<typename F, typename OPLUS, typename A, typename B> void list_skeletons::zipwith_reduce (  const F &  f, const OPLUS &  oplus, const typename F::result_type *  e, const dist_list< A > *  as, const dist_list< B > *  bs, typename F::result_type *  result )  [static]

Definition at line 1592 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::get_global_size(), skeleton::procs, skeleton::rank, TAG_REDUCE2, and template_mpitype< A >::type(). Here is the call graph for this function:

template<typename F, typename OPLUS, typename A, typename B> F::result_type list_skeletons::zipwith_reduce (  const F &  f, const OPLUS &  oplus, const typename F::result_type &  e, const dist_list< A > *  as, const dist_list< B > *  bs )  [static]

Definition at line 1548 of file list_skeletons.tpp. References dist_list< A >::at(), skeleton::cout, debug, dist_list< A >::get_global_size(), skeleton::procs, skeleton::rank, TAG_REDUCE1, and template_mpitype< A >::type(). Here is the call graph for this function:

template<typename F, typename A, typename B> void list_skeletons::zipwithindex (  const F &  f, const dist_list< A > *  as, const dist_list< B > *  bs, dist_list< typename F::first_argument_type > *  cs )  [inline, static]

Zipwithindex skeleton applies the function to each corresponding pair of two lists, furthermore, the function takes the index of the pair for the first argument. This skeleton is equivalent to the successive call of mapindex skeleton after zip skeleton. zipwithindex f [a0, a1, ..., an-1] [b0, b1, ..., bn-1] = [f 0 a0 b0, f 1 a1 b1, ..., f n-1 an-1 bn-1]. The function f used in this skeleton, accepts the index of pair, and and two pointers for the elements of pair. Parameters: f  : The function to apply to the each pair. [ in ] as  : The first list. [ in ] bs  : The second list. [ in ] cs,:  The result list, and must be allocated before calling this skeleton. [ out ] Definition at line 979 of file list_skeletons.tpp. References dist_list< A >::at(), dist_list< A >::begin, skeleton::cout, debug, dist_list< A >::get_global_size(), and skeleton::rank. Here is the call graph for this function:

template<typename F, typename A, typename B> dist_list< typename F::result_type > * list_skeletons::zipwithindex (  const F &  f, const dist_list< A > *  as, const dist_list< B > *  bs )  [inline, static]

Zipwithindex skeleton applies the function to each corresponding pair of two lists, furthermore, the function takes the index of the pair for the first argument. This skeleton is equivalent to the successive call of mapindex skeleton after zip skeleton. zipwithindex f [a0, a1, ..., an-1] [b0, b1, ..., bn-1] = [f 0 a0 b0, f 1 a1 b1, ..., f n-1 an-1 bn-1]. Parameters: f  : The function to apply to the each pair. [ in ] as  : The first list. [ in ] bs  : The second list. [ in ] Definition at line 958 of file list_skeletons.tpp. References dist_list< A >::at(), dist_list< A >::begin, skeleton::cout, debug, dist_list< A >::get_global_size(), dist_list< A >::global_size, and skeleton::rank. Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• libraries/list/list_skeletons.h
• libraries/list/list_skeletons.tpp

---