The namespace for synchronous MoC. More...

Classes
class	apply
	Process constructor for a combinational adaptive process with one input and one output. More...

class	comb
	Process constructor for a combinational process with one input and one output. More...

class	comb2
	Process constructor for a combinational process with two inputs and one output. More...

class	comb3
	Process constructor for a combinational process with three inputs and one output. More...

class	comb4
	Process constructor for a combinational process with four inputs and one output. More...

class	combX
	Process constructor for a combinational process with an array of inputs and one output. More...

class	constant
	Process constructor for a constant source process. More...

class	delay
	Process constructor for a delay element. More...

class	delayn
	Process constructor for a n-delay element. More...

class	fanout
	Process constructor for a fan-out process with one input and one output. More...

class	file_sink
	Process constructor for a file_sink process. More...

class	file_source
	Process constructor for a file_source process. More...

class	fill
	Process constructor for a fill process. More...

class	gaussian
	Process constructor for a Gaussian randome wave generator. More...

class	gdbwrap
	Process constructor for a GDB wrapper with one input and one output. More...

class	group
	The group process with one input and one absent-extended output. More...

class	hold
	Process constructor for a hold process. More...

class	mealy
	Process constructor for a Mealy machine. More...

class	moore
	Process constructor for a Moore machine. More...

class	pipewrap
	Process constructor for a pipe wrapper with one input and one output. More...

class	pipewrap2
	Process constructor for a pipe wrapper with one input and one output. More...

class	receiver
	Process constructor for a receiver process with one output. More...

class	scomb
	Process constructor for a strict combinational process with one input and one output. More...

class	scomb2
	Process constructor for a strict combinational process with two inputs and one output. More...

class	scomb3
	Process constructor for a strict combinational process with three inputs and one output. More...

class	scomb4
	Process constructor for a strict combinational process with four inputs and one output. More...

class	scombX
	Process constructor for a strict combinational process with an array of inputs and one output. More...

class	sconstant
	Process constructor for a strict constant source process. More...

class	sdelay
	Process constructor for a strict delay element. More...

class	sdelayn
	Process constructor for a strict n-delay element. More...

class	sdpmap
	A data-parallel process constructor for a strict combinational process with input and output array types. More...

class	sdpreduce
	A data-parallel process constructor for a strict reduce process with an array of inputs and one output. More...

class	sdpscan
	A data-parallel process constructor for a strict scan process with input and output array types. More...

class	sender
	Process constructor for a sender process with one input. More...

class	sgroup
	The strict group process with one input and one output. More...

class	sink
	Process constructor for a sink process. More...

class	smealy
	Process constructor for a strict Mealy machine. More...

class	smoore
	Process constructor for a strict Moore machine. More...

class	source
	Process constructor for a source process. More...

class	ssink
	Process constructor for a strict sink process. More...

class	ssource
	Process constructor for a strict source process. More...

class	sunzip
	The strict unzip process with one input and two outputs. More...

class	sunzipN
	The unzip process with one input and variable number of outputs. More...

class	sunzipX
	The sunzipX process with one input and an array of outputs. More...

class	svsource
	Process constructor for a strict source process with vector input. More...

class	SY2SY
	The SY2SY signal used to inter-connect SY processes. More...

class	SY_in
	The SY_in port is used for input ports of SY processes. More...

class	SY_out
	The SY_out port is used for output ports of SY processes. More...

class	szip
	The strict zip process with two inputs and one output. More...

class	szipN
	The strict zip process with variable number of inputs and one output. More...

class	szipX
	The strict zipX process with an array of inputs and one output. More...

class	unzip
	The unzip process with one input and two outputs. More...

class	unzipN
	The unzip process with one input and variable number of outputs. More...

class	unzipX
	The unzipX process with one input and an array of outputs. More...

class	vsource
	Process constructor for a source process with vector input. More...

class	zip
	The zip process with two inputs and one output. More...

class	zipN
	The zip process with variable number of inputs and one output. More...

class	zipX
	The zipX process with an array of inputs and one output. More...

Typedefs
template<typename T >
using	signal = SY2SY< T >
	The SY::signal is an alias for SY::SY2SY.

template<typename T >
using	in_port = SY_in< T >
	The SY::in_port is an alias for SY::SY_in.

template<typename T >
using	out_port = SY_out< T >
	The SY::out_port is an alias for SY::SY_out.

typedef ForSyDe::process	sy_process
	Abstract semantics of a process in the SY MoC.

Functions
template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, template< class > class FIf>
apply< T0, T1 > *	make_apply (const std::string &pName, OIf< T0 > &outS, I1If< T1 > &inp1S, FIf< typename apply< T0, T1 >::functype > &fS)
	Helper function to construct a comb process. More...

template<class T0 , template< class > class I0If>
sender< T0 > *	make_sender (const std::string &pName, int destination, int tag, I0If< T0 > &inp1S)
	Helper function to construct a sender process. More...

template<class T0 , template< class > class OIf>
receiver< T0 > *	make_receiver (const std::string &pName, int source, int tag, OIf< T0 > &outS)
	Helper function to construct a sender process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If>
comb< T0, T1 > *	make_comb (const std::string &pName, const typename comb< T0, T1 >::functype &_func, OIf< T0 > &outS, I1If< T1 > &inp1S)
	Helper function to construct a comb process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If>
comb2< T0, T1, T2 > *	make_comb2 (const std::string &pName, const typename comb2< T0, T1, T2 >::functype &_func, OIf< T0 > &outS, I1If< T1 > &inp1S, I2If< T2 > &inp2S)
	Helper function to construct a comb2 process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If, class T3 , template< class > class I3If>
comb3< T0, T1, T2, T3 > *	make_comb3 (const std::string &pName, const typename comb3< T0, T1, T2, T3 >::functype &_func, OIf< T0 > &outS, I1If< T1 > &inp1S, I2If< T2 > &inp2S, I3If< T3 > &inp3S)
	Helper function to construct a comb3 process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If, class T3 , template< class > class I3If, class T4 , template< class > class I4If>
comb4< T0, T1, T2, T3, T4 > *	make_comb4 (const std::string &pName, const typename comb4< T0, T1, T2, T3, T4 >::functype &_func, OIf< T0 > &outS, I1If< T1 > &inp1S, I2If< T2 > &inp2S, I3If< T3 > &inp3S, I4If< T4 > &inp4S)
	Helper function to construct a comb4 process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class IIf, std::size_t N>
combX< T0, T1, N > *	make_combX (const std::string &pName, const typename combX< T0, T1, N >::functype &_func, OIf< T0 > &outS, std::array< IIf< T1 >, N > &inpS)
	Helper function to construct a combX process. More...

template<typename T , template< class > class IIf, template< class > class OIf>
delay< T > *	make_delay (const std::string &pName, const abst_ext< T > &initval, OIf< T > &outS, IIf< T > &inpS)
	Helper function to construct a delay process. More...

template<typename T , template< class > class IIf, template< class > class OIf>
delayn< T > *	make_delayn (const std::string &pName, const abst_ext< T > &initval, const unsigned int &n, OIf< T > &outS, IIf< T > &inpS)
	Helper function to construct a delayn process. More...

template<typename IT , typename ST , typename OT , template< class > class IIf, template< class > class OIf>
moore< IT, ST, OT > *	make_moore (const std::string &pName, const typename moore< IT, ST, OT >::ns_functype &_ns_func, const typename moore< IT, ST, OT >::od_functype &_od_func, const ST &init_st, OIf< OT > &outS, IIf< IT > &inpS)
	Helper function to construct a moore process. More...

template<typename IT , typename ST , typename OT , template< class > class IIf, template< class > class OIf>
mealy< IT, ST, OT > *	make_mealy (const std::string &pName, const typename mealy< IT, ST, OT >::ns_functype &_ns_func, const typename mealy< IT, ST, OT >::od_functype &_od_func, const ST &init_st, OIf< OT > &outS, IIf< IT > &inpS)
	Helper function to construct a mealy process. More...

template<typename T , template< class > class IIf, template< class > class OIf>
fill< T > *	make_fill (const std::string &pName, const T &def_val, OIf< T > &outS, IIf< T > &inpS)
	Helper function to construct a fill process. More...

template<typename T , template< class > class IIf, template< class > class OIf>
hold< T > *	make_hold (const std::string &pName, const T &def_val, OIf< T > &outS, IIf< T > &inpS)
	Helper function to construct a hold process. More...

template<typename T , template< class > class IIf, template< class > class OIf>
group< T > *	make_group (const std::string &pName, const unsigned long &samples, OIf< std::vector< abst_ext< T >>> &outS, IIf< T > &inpS)
	Helper function to construct a group process. More...

template<class T , template< class > class OIf>
constant< T > *	make_constant (const std::string &pName, const abst_ext< T > &initval, const unsigned long long &take, OIf< T > &outS)
	Helper function to construct a constant source process. More...

template<class T , template< class > class OIf>
source< T > *	make_source (const std::string &pName, const typename source< T >::functype &_func, const abst_ext< T > &initval, const unsigned long long &take, OIf< T > &outS)
	Helper function to construct a source process. More...

template<class T , template< class > class OIf>
file_source< T > *	make_file_source (std::string pName, typename file_source< T >::functype _func, std::string file_name, OIf< T > &outS)
	Helper function to construct a file_source process. More...

template<class T , template< class > class OIf>
vsource< T > *	make_vsource (const std::string &pName, const std::vector< abst_ext< T >> &in_vec, OIf< T > &outS)
	Helper function to construct a vector source process. More...

template<class T , template< class > class IIf>
sink< T > *	make_sink (const std::string &pName, const typename sink< T >::functype &_func, IIf< T > &inS)
	Helper function to construct a sink process. More...

template<class T , template< class > class IIf>
file_sink< T > *	make_file_sink (std::string pName, typename file_sink< T >::functype _func, std::string file_name, IIf< T > &inS)
	Helper function to construct a file_sink process. More...

template<class T1 , template< class > class I1If, class T2 , template< class > class I2If, template< class > class OIf>
zip< T1, T2 > *	make_zip (const std::string &pName, OIf< std::tuple< abst_ext< T1 >, abst_ext< T2 >>> &outS, I1If< T1 > &inp1S, I2If< T2 > &inp2S)
	Helper function to construct a zip process. More...

template<class T1 , std::size_t N, template< class > class OIf>
zipX< T1, N > *	make_zipX (const std::string &pName, OIf< std::array< abst_ext< T1 >, N >> &outS)
	Helper function to construct a zipX process. More...

template<template< class > class IIf, class T1 , template< class > class O1If, class T2 , template< class > class O2If>
unzip< T1, T2 > *	make_unzip (const std::string &pName, IIf< std::tuple< abst_ext< T1 >, abst_ext< T2 >>> &inpS, O1If< T1 > &out1S, O2If< T2 > &out2S)
	Helper function to construct an unzip process. More...

template<template< class > class IIf, class T1 , std::size_t N>
unzipX< T1, N > *	make_unzipX (const std::string &pName, IIf< std::array< abst_ext< T1 >, N >> &inpS)
	Helper function to construct an unzipX process. More...

template<typename T , template< class > class IIf, template< class > class OIf>
fanout< T > *	make_fanout (const std::string &pName, OIf< T > &outS, IIf< T > &inpS)
	Helper function to construct a fanout process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If>
scomb< T0, T1 > *	make_scomb (const std::string &pName, const typename scomb< T0, T1 >::functype &_func, OIf< T0 > &outS, I1If< T1 > &inp1S)
	Helper function to construct a strict comb process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If>
scomb2< T0, T1, T2 > *	make_scomb2 (const std::string &pName, const typename scomb2< T0, T1, T2 >::functype &_func, OIf< T0 > &outS, I1If< T1 > &inp1S, I2If< T2 > &inp2S)
	Helper function to construct a strict comb2 process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If, class T3 , template< class > class I3If>
scomb3< T0, T1, T2, T3 > *	make_scomb3 (const std::string &pName, const typename scomb3< T0, T1, T2, T3 >::functype &_func, OIf< T0 > &outS, I1If< T1 > &inp1S, I2If< T2 > &inp2S, I3If< T3 > &inp3S)
	Helper function to construct a strict comb3 process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If, class T3 , template< class > class I3If, class T4 , template< class > class I4If>
scomb4< T0, T1, T2, T3, T4 > *	make_scomb4 (const std::string &pName, const typename scomb4< T0, T1, T2, T3, T4 >::functype &_func, OIf< T0 > &outS, I1If< T1 > &inp1S, I2If< T2 > &inp2S, I3If< T3 > &inp3S, I4If< T4 > &inp4S)
	Helper function to construct a strict comb4 process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class IIf, std::size_t N>
scombX< T0, T1, N > *	make_scombX (const std::string &pName, const typename scombX< T0, T1, N >::functype &_func, OIf< T0 > &outS, std::array< IIf< T1 >, N > &inpS)
	Helper function to construct a strict combX process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class IIf, std::size_t N>
sdpmap< T0, T1, N > *	make_sdpmap (const std::string &pName, const typename sdpmap< T0, T1, N >::functype &_func, OIf< std::array< T0, N >> &outS, IIf< std::array< T1, N >> &inpS)
	Helper function to construct a strict data parallel comb process. More...

template<class T0 , template< class > class OIf, template< class > class IIf, std::size_t N>
sdpreduce< T0, N > *	make_sdpreduce (const std::string &pName, const typename sdpreduce< T0, N >::functype &_func, OIf< T0 > &outS, IIf< std::array< T0, N >> &inpS)
	Helper function to construct a strict reduce process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class IIf, std::size_t N>
sdpscan< T0, T1, N > *	make_sdpscan (const std::string &pName, const typename sdpscan< T0, T1, N >::functype &_func, const T0 &init_res, OIf< std::array< T0, N >> &outS, IIf< std::array< T1, N >> &inpS)
	Helper function to construct a strict data parallel scan process. More...

template<typename T , template< class > class IIf, template< class > class OIf>
sdelay< T > *	make_sdelay (const std::string &pName, const T &initval, OIf< T > &outS, IIf< T > &inpS)
	Helper function to construct a strict delay process. More...

template<typename T , template< class > class IIf, template< class > class OIf>
sdelayn< T > *	make_sdelayn (const std::string &pName, const T &initval, const unsigned int &n, OIf< T > &outS, IIf< T > &inpS)
	Helper function to construct a strict delayn process. More...

template<typename IT , typename ST , typename OT , template< class > class IIf, template< class > class OIf>
smoore< IT, ST, OT > *	make_smoore (const std::string &pName, const typename smoore< IT, ST, OT >::ns_functype &_ns_func, const typename smoore< IT, ST, OT >::od_functype &_od_func, const ST &init_st, OIf< OT > &outS, IIf< IT > &inpS)
	Helper function to construct a moore process. More...

template<typename IT , typename ST , typename OT , template< class > class IIf, template< class > class OIf>
smealy< IT, ST, OT > *	make_smealy (const std::string &pName, const typename smealy< IT, ST, OT >::ns_functype &_ns_func, const typename smealy< IT, ST, OT >::od_functype &_od_func, const ST &init_st, OIf< OT > &outS, IIf< IT > &inpS)
	Helper function to construct a strict mealy process. More...

template<typename T , template< class > class IIf, template< class > class OIf>
sgroup< T > *	make_sgroup (const std::string &pName, const unsigned long &samples, OIf< std::vector< T >> &outS, IIf< T > &inpS)
	Helper function to construct a strict group process. More...

template<class T , template< class > class OIf>
sconstant< T > *	make_sconstant (const std::string &pName, const T &initval, const unsigned long long &take, OIf< T > &outS)
	Helper function to construct a strict constant source process. More...

template<class T , template< class > class OIf>
ssource< T > *	make_ssource (const std::string &pName, const typename ssource< T >::functype &_func, const T &initval, const unsigned long long &take, OIf< T > &outS)
	Helper function to construct a strict source process. More...

template<class T , template< class > class OIf>
svsource< T > *	make_svsource (const std::string &pName, const std::vector< T > &in_vec, OIf< T > &outS)
	Helper function to construct a strict vector source process. More...

template<class T , template< class > class IIf>
ssink< T > *	make_ssink (const std::string &pName, const typename ssink< T >::functype &_func, IIf< T > &inS)
	Helper function to construct a strict sink process. More...

template<class T1 , template< class > class I1If, class T2 , template< class > class I2If, template< class > class OIf>
szip< T1, T2 > *	make_szip (const std::string &pName, OIf< std::tuple< T1, T2 >> &outS, I1If< T1 > &inp1S, I2If< T2 > &inp2S)
	Helper function to construct a szip process. More...

template<class T1 , std::size_t N, template< class > class OIf>
szipX< T1, N > *	make_szipX (const std::string &pName, OIf< std::array< T1, N >> &outS)
	Helper function to construct a szipX process. More...

template<template< class > class IIf, class T1 , template< class > class O1If, class T2 , template< class > class O2If>
sunzip< T1, T2 > *	make_sunzip (const std::string &pName, IIf< std::tuple< T1, T2 >> &inpS, O1If< T1 > &out1S, O2If< T2 > &out2S)
	Helper function to construct a sunzip process. More...

template<template< class > class IIf, class T1 , std::size_t N>
unzipX< T1, N > *	make_unzipX (const std::string &pName, IIf< std::array< T1, N >> &inpS)
	Helper function to construct a strict unzipX process. More...

template<template< class > class OIf>
gaussian *	make_gaussian (const std::string &pName, const double &gaussVar, const double &gaussMean, OIf< double > &outS)
	Helper function to construct a Gaussian randome wave generator. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If>
gdbwrap< T0, T1 > *	make_gdbwrap (const std::string &pName, const std::string &exec_name, OIf< T0 > &outS, I1If< T1 > &inp1S)
	Helper function to construct a gdbwrap process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If>
pipewrap< T0, T1 > *	make_pipewrap (const std::string &pName, const int &offset, const std::string &path_name, OIf< T0 > &outS, I1If< T1 > &inp1S)
	Helper function to construct a pipewrap process. More...

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If>
pipewrap2< T0, T1, T2 > *	make_pipewrap2 (const std::string &pName, const int &offset, const std::string &path_name, OIf< T0 > &outS, I1If< T1 > &inp1S, I2If< T2 > &inp2S)
	Helper function to construct a pipewrap process. More...

Detailed Description

The namespace for synchronous MoC.

This namespace includes constructs used for building models in the synchronous MoC.

Function Documentation

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, template< class > class FIf>

apply<T0,T1>* ForSyDe::SY::make_apply	(	const std::string &	pName,
		OIf< T0 > &	outS,
		I1If< T1 > &	inp1S,
		FIf< typename apply< T0, T1 >::functype > &	fS
	)

inline

Helper function to construct a comb process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If>

comb<T0,T1>* ForSyDe::SY::make_comb	(	const std::string &	pName,
		const typename comb< T0, T1 >::functype &	_func,
		OIf< T0 > &	outS,
		I1If< T1 > &	inp1S
	)

inline

Helper function to construct a comb process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If>

comb2<T0,T1,T2>* ForSyDe::SY::make_comb2	(	const std::string &	pName,
		const typename comb2< T0, T1, T2 >::functype &	_func,
		OIf< T0 > &	outS,
		I1If< T1 > &	inp1S,
		I2If< T2 > &	inp2S
	)

inline

Helper function to construct a comb2 process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If, class T3 , template< class > class I3If>

comb3<T0,T1,T2,T3>* ForSyDe::SY::make_comb3	(	const std::string &	pName,
		const typename comb3< T0, T1, T2, T3 >::functype &	_func,
		OIf< T0 > &	outS,
		I1If< T1 > &	inp1S,
		I2If< T2 > &	inp2S,
		I3If< T3 > &	inp3S
	)

inline

Helper function to construct a comb3 process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If, class T3 , template< class > class I3If, class T4 , template< class > class I4If>

comb4<T0,T1,T2,T3,T4>* ForSyDe::SY::make_comb4	(	const std::string &	pName,
		const typename comb4< T0, T1, T2, T3, T4 >::functype &	_func,
		OIf< T0 > &	outS,
		I1If< T1 > &	inp1S,
		I2If< T2 > &	inp2S,
		I3If< T3 > &	inp3S,
		I4If< T4 > &	inp4S
	)

inline

Helper function to construct a comb4 process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, class T1 , template< class > class IIf, std::size_t N>

combX<T0,T1,N>* ForSyDe::SY::make_combX	(	const std::string &	pName,
		const typename combX< T0, T1, N >::functype &	_func,
		OIf< T0 > &	outS,
		std::array< IIf< T1 >, N > &	inpS
	)

inline

Helper function to construct a combX process.

This function is used to construct a process (SystemC module) and connect its input and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T , template< class > class OIf>

constant<T>* ForSyDe::SY::make_constant	(	const std::string &	pName,
		const abst_ext< T > &	initval,
		const unsigned long long &	take,
		OIf< T > &	outS
	)

inline

Helper function to construct a constant source process.

This function is used to construct a constant (SystemC module) and connect its output signal. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the output FIFOs.

template<typename T , template< class > class IIf, template< class > class OIf>

delay<T>* ForSyDe::SY::make_delay	(	const std::string &	pName,
		const abst_ext< T > &	initval,
		OIf< T > &	outS,
		IIf< T > &	inpS
	)

inline

Helper function to construct a delay process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<typename T , template< class > class IIf, template< class > class OIf>

delayn<T>* ForSyDe::SY::make_delayn	(	const std::string &	pName,
		const abst_ext< T > &	initval,
		const unsigned int &	n,
		OIf< T > &	outS,
		IIf< T > &	inpS
	)

inline

Helper function to construct a delayn process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<typename T , template< class > class IIf, template< class > class OIf>

fanout<T>* ForSyDe::SY::make_fanout	(	const std::string &	pName,
		OIf< T > &	outS,
		IIf< T > &	inpS
	)

inline

Helper function to construct a fanout process.

This function is used to construct a fanout process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T , template< class > class IIf>

file_sink<T>* ForSyDe::SY::make_file_sink	(	std::string	pName,
		typename file_sink< T >::functype	_func,
		std::string	file_name,
		IIf< T > &	inS
	)

inline

Helper function to construct a file_sink process.

This function is used to construct a file_sink (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input FIFOs.

template<class T , template< class > class OIf>

file_source<T>* ForSyDe::SY::make_file_source	(	std::string	pName,
		typename file_source< T >::functype	_func,
		std::string	file_name,
		OIf< T > &	outS
	)

inline

Helper function to construct a file_source process.

This function is used to construct a file_source (SystemC module) and connect its output signal. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the output FIFOs.

template<typename T , template< class > class IIf, template< class > class OIf>

fill<T>* ForSyDe::SY::make_fill	(	const std::string &	pName,
		const T &	def_val,
		OIf< T > &	outS,
		IIf< T > &	inpS
	)

inline

Helper function to construct a fill process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<template< class > class OIf>

gaussian* ForSyDe::SY::make_gaussian	(	const std::string &	pName,
		const double &	gaussVar,
		const double &	gaussMean,
		OIf< double > &	outS
	)

inline

Helper function to construct a Gaussian randome wave generator.

This function is used to construct a Gaussian (SystemC module) and connect its output signal. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the output FIFOs.

Parameters

gaussVar	The variance
gaussMean	The mean value

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If>

gdbwrap<T0,T1>* ForSyDe::SY::make_gdbwrap	(	const std::string &	pName,
		const std::string &	exec_name,
		OIf< T0 > &	outS,
		I1If< T1 > &	inp1S
	)

inline

Helper function to construct a gdbwrap process.

This function is used to construct a GDB wrapper process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<typename T , template< class > class IIf, template< class > class OIf>

group<T>* ForSyDe::SY::make_group	(	const std::string &	pName,
		const unsigned long &	samples,
		OIf< std::vector< abst_ext< T >>> &	outS,
		IIf< T > &	inpS
	)

inline

Helper function to construct a group process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<typename T , template< class > class IIf, template< class > class OIf>

hold<T>* ForSyDe::SY::make_hold	(	const std::string &	pName,
		const T &	def_val,
		OIf< T > &	outS,
		IIf< T > &	inpS
	)

inline

Helper function to construct a hold process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<typename IT , typename ST , typename OT , template< class > class IIf, template< class > class OIf>

mealy<IT,ST,OT>* ForSyDe::SY::make_mealy	(	const std::string &	pName,
		const typename mealy< IT, ST, OT >::ns_functype &	_ns_func,
		const typename mealy< IT, ST, OT >::od_functype &	_od_func,
		const ST &	init_st,
		OIf< OT > &	outS,
		IIf< IT > &	inpS
	)

inline

Helper function to construct a mealy process.

This function is used to construct a mealy process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<typename IT , typename ST , typename OT , template< class > class IIf, template< class > class OIf>

moore<IT,ST,OT>* ForSyDe::SY::make_moore	(	const std::string &	pName,
		const typename moore< IT, ST, OT >::ns_functype &	_ns_func,
		const typename moore< IT, ST, OT >::od_functype &	_od_func,
		const ST &	init_st,
		OIf< OT > &	outS,
		IIf< IT > &	inpS
	)

inline

Helper function to construct a moore process.

This function is used to construct a moore process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If>

pipewrap<T0,T1>* ForSyDe::SY::make_pipewrap	(	const std::string &	pName,
		const int &	offset,
		const std::string &	path_name,
		OIf< T0 > &	outS,
		I1If< T1 > &	inp1S
	)

inline

Helper function to construct a pipewrap process.

This function is used to construct a pipe wrapper process (SystemC module) and connect its input and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If>

pipewrap2<T0,T1,T2>* ForSyDe::SY::make_pipewrap2	(	const std::string &	pName,
		const int &	offset,
		const std::string &	path_name,
		OIf< T0 > &	outS,
		I1If< T1 > &	inp1S,
		I2If< T2 > &	inp2S
	)

inline

Helper function to construct a pipewrap process.

This function is used to construct a pipe wrapper process (SystemC module) and connect its input and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf>

receiver<T0>* ForSyDe::SY::make_receiver	(	const std::string &	pName,
		int	source,
		int	tag,
		OIf< T0 > &	outS
	)

inline

Helper function to construct a sender process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

Parameters

source	MPI rank of the source process
tag	MPI tag of the message

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If>

scomb<T0,T1>* ForSyDe::SY::make_scomb	(	const std::string &	pName,
		const typename scomb< T0, T1 >::functype &	_func,
		OIf< T0 > &	outS,
		I1If< T1 > &	inp1S
	)

inline

Helper function to construct a strict comb process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If>

scomb2<T0,T1,T2>* ForSyDe::SY::make_scomb2	(	const std::string &	pName,
		const typename scomb2< T0, T1, T2 >::functype &	_func,
		OIf< T0 > &	outS,
		I1If< T1 > &	inp1S,
		I2If< T2 > &	inp2S
	)

inline

Helper function to construct a strict comb2 process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If, class T3 , template< class > class I3If>

scomb3<T0,T1,T2,T3>* ForSyDe::SY::make_scomb3	(	const std::string &	pName,
		const typename scomb3< T0, T1, T2, T3 >::functype &	_func,
		OIf< T0 > &	outS,
		I1If< T1 > &	inp1S,
		I2If< T2 > &	inp2S,
		I3If< T3 > &	inp3S
	)

inline

Helper function to construct a strict comb3 process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, class T1 , template< class > class I1If, class T2 , template< class > class I2If, class T3 , template< class > class I3If, class T4 , template< class > class I4If>

scomb4<T0,T1,T2,T3,T4>* ForSyDe::SY::make_scomb4	(	const std::string &	pName,
		const typename scomb4< T0, T1, T2, T3, T4 >::functype &	_func,
		OIf< T0 > &	outS,
		I1If< T1 > &	inp1S,
		I2If< T2 > &	inp2S,
		I3If< T3 > &	inp3S,
		I4If< T4 > &	inp4S
	)

inline

Helper function to construct a strict comb4 process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, class T1 , template< class > class IIf, std::size_t N>

scombX<T0,T1,N>* ForSyDe::SY::make_scombX	(	const std::string &	pName,
		const typename scombX< T0, T1, N >::functype &	_func,
		OIf< T0 > &	outS,
		std::array< IIf< T1 >, N > &	inpS
	)

inline

Helper function to construct a strict combX process.

This function is used to construct a process (SystemC module) and connect its input and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T , template< class > class OIf>

sconstant<T>* ForSyDe::SY::make_sconstant	(	const std::string &	pName,
		const T &	initval,
		const unsigned long long &	take,
		OIf< T > &	outS
	)

inline

Helper function to construct a strict constant source process.

This function is used to construct a constant (SystemC module) and connect its output signal. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the output FIFOs.

template<typename T , template< class > class IIf, template< class > class OIf>

sdelay<T>* ForSyDe::SY::make_sdelay	(	const std::string &	pName,
		const T &	initval,
		OIf< T > &	outS,
		IIf< T > &	inpS
	)

inline

Helper function to construct a strict delay process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<typename T , template< class > class IIf, template< class > class OIf>

sdelayn<T>* ForSyDe::SY::make_sdelayn	(	const std::string &	pName,
		const T &	initval,
		const unsigned int &	n,
		OIf< T > &	outS,
		IIf< T > &	inpS
	)

inline

Helper function to construct a strict delayn process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, class T1 , template< class > class IIf, std::size_t N>

sdpmap<T0,T1,N>* ForSyDe::SY::make_sdpmap	(	const std::string &	pName,
		const typename sdpmap< T0, T1, N >::functype &	_func,
		OIf< std::array< T0, N >> &	outS,
		IIf< std::array< T1, N >> &	inpS
	)

inline

Helper function to construct a strict data parallel comb process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, template< class > class IIf, std::size_t N>

sdpreduce<T0,N>* ForSyDe::SY::make_sdpreduce	(	const std::string &	pName,
		const typename sdpreduce< T0, N >::functype &	_func,
		OIf< T0 > &	outS,
		IIf< std::array< T0, N >> &	inpS
	)

inline

Helper function to construct a strict reduce process.

This function is used to construct a sreduce process (SystemC module) and connect connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class OIf, class T1 , template< class > class IIf, std::size_t N>

sdpscan<T0,T1,N>* ForSyDe::SY::make_sdpscan	(	const std::string &	pName,
		const typename sdpscan< T0, T1, N >::functype &	_func,
		const T0 &	init_res,
		OIf< std::array< T0, N >> &	outS,
		IIf< std::array< T1, N >> &	inpS
	)

inline

Helper function to construct a strict data parallel scan process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T0 , template< class > class I0If>

sender<T0>* ForSyDe::SY::make_sender	(	const std::string &	pName,
		int	destination,
		int	tag,
		I0If< T0 > &	inp1S
	)

inline

Helper function to construct a sender process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

Parameters

destination	MPI rank of the destination process
tag	MPI tag of the message

template<typename T , template< class > class IIf, template< class > class OIf>

sgroup<T>* ForSyDe::SY::make_sgroup	(	const std::string &	pName,
		const unsigned long &	samples,
		OIf< std::vector< T >> &	outS,
		IIf< T > &	inpS
	)

inline

Helper function to construct a strict group process.

This function is used to construct a process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T , template< class > class IIf>

sink<T>* ForSyDe::SY::make_sink	(	const std::string &	pName,
		const typename sink< T >::functype &	_func,
		IIf< T > &	inS
	)

inline

Helper function to construct a sink process.

This function is used to construct a sink (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input FIFOs.

template<typename IT , typename ST , typename OT , template< class > class IIf, template< class > class OIf>

smealy<IT,ST,OT>* ForSyDe::SY::make_smealy	(	const std::string &	pName,
		const typename smealy< IT, ST, OT >::ns_functype &	_ns_func,
		const typename smealy< IT, ST, OT >::od_functype &	_od_func,
		const ST &	init_st,
		OIf< OT > &	outS,
		IIf< IT > &	inpS
	)

inline

Helper function to construct a strict mealy process.

This function is used to construct a mealy process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<typename IT , typename ST , typename OT , template< class > class IIf, template< class > class OIf>

smoore<IT,ST,OT>* ForSyDe::SY::make_smoore	(	const std::string &	pName,
		const typename smoore< IT, ST, OT >::ns_functype &	_ns_func,
		const typename smoore< IT, ST, OT >::od_functype &	_od_func,
		const ST &	init_st,
		OIf< OT > &	outS,
		IIf< IT > &	inpS
	)

inline

Helper function to construct a moore process.

This function is used to construct a moore process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input and output FIFOs.

template<class T , template< class > class OIf>

source<T>* ForSyDe::SY::make_source	(	const std::string &	pName,
		const typename source< T >::functype &	_func,
		const abst_ext< T > &	initval,
		const unsigned long long &	take,
		OIf< T > &	outS
	)

inline

Helper function to construct a source process.

This function is used to construct a source (SystemC module) and connect its output signal. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the output FIFOs.

template<class T , template< class > class IIf>

ssink<T>* ForSyDe::SY::make_ssink	(	const std::string &	pName,
		const typename ssink< T >::functype &	_func,
		IIf< T > &	inS
	)

inline

Helper function to construct a strict sink process.

This function is used to construct a sink (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input FIFOs.

template<class T , template< class > class OIf>

ssource<T>* ForSyDe::SY::make_ssource	(	const std::string &	pName,
		const typename ssource< T >::functype &	_func,
		const T &	initval,
		const unsigned long long &	take,
		OIf< T > &	outS
	)

inline

Helper function to construct a strict source process.

This function is used to construct a source (SystemC module) and connect its output signal. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the output FIFOs.

template<template< class > class IIf, class T1 , template< class > class O1If, class T2 , template< class > class O2If>

sunzip<T1,T2>* ForSyDe::SY::make_sunzip	(	const std::string &	pName,
		IIf< std::tuple< T1, T2 >> &	inpS,
		O1If< T1 > &	out1S,
		O2If< T2 > &	out2S
	)

inline

Helper function to construct a sunzip process.

This function is used to construct a strict unzip process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input FIFOs.

template<class T , template< class > class OIf>

svsource<T>* ForSyDe::SY::make_svsource	(	const std::string &	pName,
		const std::vector< T > &	in_vec,
		OIf< T > &	outS
	)

inline

Helper function to construct a strict vector source process.

This function is used to construct a vector source (SystemC module) and connect its output signal. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the output FIFOs.

template<class T1 , template< class > class I1If, class T2 , template< class > class I2If, template< class > class OIf>

szip<T1,T2>* ForSyDe::SY::make_szip	(	const std::string &	pName,
		OIf< std::tuple< T1, T2 >> &	outS,
		I1If< T1 > &	inp1S,
		I2If< T2 > &	inp2S
	)

inline

Helper function to construct a szip process.

This function is used to construct a strict zip process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input FIFOs.

template<class T1 , std::size_t N, template< class > class OIf>

szipX<T1,N>* ForSyDe::SY::make_szipX	(	const std::string &	pName,
		OIf< std::array< T1, N >> &	outS
	)

inline

Helper function to construct a szipX process.

This function is used to construct a szip process (SystemC module) and connect its output signal. The user binds the inputs manually. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input FIFOs.

template<template< class > class IIf, class T1 , template< class > class O1If, class T2 , template< class > class O2If>

unzip<T1,T2>* ForSyDe::SY::make_unzip	(	const std::string &	pName,
		IIf< std::tuple< abst_ext< T1 >, abst_ext< T2 >>> &	inpS,
		O1If< T1 > &	out1S,
		O2If< T2 > &	out2S
	)

inline

Helper function to construct an unzip process.

This function is used to construct an unzip process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input FIFOs.

template<template< class > class IIf, class T1 , std::size_t N>

unzipX<T1,N>* ForSyDe::SY::make_unzipX	(	const std::string &	pName,
		IIf< std::array< T1, N >> &	inpS
	)

inline

Helper function to construct a strict unzipX process.

This function is used to construct a strict unzipX process (SystemC module) and connect its input signal. The user binds the outputs manually. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input FIFOs.

template<template< class > class IIf, class T1 , std::size_t N>

unzipX<T1,N>* ForSyDe::SY::make_unzipX	(	const std::string &	pName,
		IIf< std::array< abst_ext< T1 >, N >> &	inpS
	)

inline

Helper function to construct an unzipX process.

This function is used to construct an unzipX process (SystemC module) and connect its input signal. The user binds the outputs manually. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input FIFOs.

template<class T , template< class > class OIf>

vsource<T>* ForSyDe::SY::make_vsource	(	const std::string &	pName,
		const std::vector< abst_ext< T >> &	in_vec,
		OIf< T > &	outS
	)

inline

Helper function to construct a vector source process.

This function is used to construct a vector source (SystemC module) and connect its output signal. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the output FIFOs.

template<class T1 , template< class > class I1If, class T2 , template< class > class I2If, template< class > class OIf>

zip<T1,T2>* ForSyDe::SY::make_zip	(	const std::string &	pName,
		OIf< std::tuple< abst_ext< T1 >, abst_ext< T2 >>> &	outS,
		I1If< T1 > &	inp1S,
		I2If< T2 > &	inp2S
	)

inline

Helper function to construct a zip process.

This function is used to construct a zip process (SystemC module) and connect its output and output signals. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input FIFOs.

template<class T1 , std::size_t N, template< class > class OIf>

zipX<T1,N>* ForSyDe::SY::make_zipX	(	const std::string &	pName,
		OIf< std::array< abst_ext< T1 >, N >> &	outS
	)

inline

Helper function to construct a zipX process.

This function is used to construct a zip process (SystemC module) and connect its output signals. The user binds the inputs manually. It provides a more functional style definition of a ForSyDe process. It also removes bilerplate code by using type-inference feature of C++ and automatic binding to the input FIFOs.

ForSyDe-SystemC

The SystemC implementation of ForSyDe

Classes

Typedefs

Functions

Detailed Description

Function Documentation