Skip to content

Implement Policies #218

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
devreal wants to merge 13 commits into from
Closed

Implement Policies #218

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
13 commits
Select commit Hold shift + click to select a range
251caaf
Store input types in ttg::typelist
devreal Feb 8, 2022
a022ba2
Fix typelist use in unit tests
devreal Feb 14, 2022
6cad27c
First step towards policies
devreal Feb 9, 2022
9710abd
Adapt make_tt to policies and use a custom policy in floyd warshall
devreal Feb 14, 2022
ae60ea0
Fix missing semicolon
devreal Feb 15, 2022
63668be
Adapt madness backend to policies
devreal Feb 15, 2022
867267d
Guard policy type in make_tt
devreal Feb 15, 2022
cbccfc3
Implement base class for TTs to properly handle policies
devreal Feb 17, 2022
fccce57
Fix handling of member functions and std::function detection
devreal Feb 18, 2022
eb50c62
Fixes for tests
devreal Feb 18, 2022
e5b0e76
Add policy unit tests
devreal Feb 18, 2022
015db6f
Fix erroneous use of default_priomap
devreal Feb 18, 2022
08cf69e
Add policies.h to list of installed files
devreal Feb 18, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
27 changes: 9 additions & 18 deletions examples/floyd-warshall/floyd_warshall.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -95,8 +95,7 @@ std::ostream& operator<<(std::ostream& s, const Control& ctl) {

class Initiator : public TT<int, std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>,
Initiator> {
using baseT =
TT<int, std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>, Initiator>;
using baseT = typename Initiator::ttT;

public:
Initiator(const std::string& name) : baseT(name, {}, {"outA", "outB", "outC", "outD"}) {}
Expand Down Expand Up @@ -128,11 +127,8 @@ class Initiator : public TT<int, std::tuple<Out<Key, Control>, Out<Key, Control>
class FuncA : public TT<Key,
std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>,
Out<Key, Control>, Out<Key, Control>>,
FuncA, Control> {
using baseT = TT<Key,
std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>,
Out<Key, Control>, Out<Key, Control>>,
FuncA, Control>;
FuncA, ttg::typelist<Control>> {
using baseT = typename FuncA::ttT;
double* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -224,10 +220,8 @@ class FuncB
: public TT<
Key,
std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>,
FuncB, Control, Control> {
using baseT =
TT<Key, std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>,
FuncB, Control, Control>;
FuncB, ttg::typelist<Control, Control>> {
using baseT = typename FuncB::ttT;
double* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -317,10 +311,8 @@ class FuncC
: public TT<
Key,
std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>,
FuncC, Control, Control> {
using baseT =
TT<Key, std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>,
FuncC, Control, Control>;
FuncC, ttg::typelist<Control, Control>> {
using baseT = typename FuncC::ttT;
double* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -407,9 +399,8 @@ class FuncC
};

class FuncD : public TT<Key, std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>,
FuncD, Control, Control, Control> {
using baseT = TT<Key, std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>, FuncD,
Control, Control, Control>;
FuncD, ttg::typelist<Control, Control, Control>> {
using baseT = typename FuncD::ttT;
double* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down
154 changes: 80 additions & 74 deletions examples/floyd-warshall/floyd_warshall_df.cc
View file
Open in desktop

Large diffs are not rendered by default.

20 changes: 9 additions & 11 deletions examples/ge/ge.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -130,8 +130,7 @@ std::ostream& operator<<(std::ostream& s, const Integer& intVal) {
class Initiator
: public TT<Integer, std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>,
Initiator> {
using baseT =
TT<Integer, std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>, Initiator>;
using baseT = typename Initiator::ttT;

public:
Initiator(const std::string& name) : baseT(name, {}, {"outA", "outB", "outC", "outD"}) {}
Expand Down Expand Up @@ -160,8 +159,8 @@ class Initiator
}
};

class FuncA : public TT<Key, std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>, FuncA, Control> {
using baseT = TT<Key, std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>, FuncA, Control>;
class FuncA : public TT<Key, std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>, FuncA, ttg::typelist<Control>> {
using baseT = typename FuncA::ttT;
double* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -240,8 +239,8 @@ class FuncA : public TT<Key, std::tuple<Out<Key, Control>, Out<Key, Control>, Ou
}
};

class FuncB : public TT<Key, std::tuple<Out<Key, Control>>, FuncB, Control, Control> {
using baseT = TT<Key, std::tuple<Out<Key, Control>>, FuncB, Control, Control>;
class FuncB : public TT<Key, std::tuple<Out<Key, Control>>, FuncB, ttg::typelist<Control, Control>> {
using baseT = typename FuncB::ttT;
double* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -312,8 +311,8 @@ class FuncB : public TT<Key, std::tuple<Out<Key, Control>>, FuncB, Control, Cont
}
};

class FuncC : public TT<Key, std::tuple<Out<Key, Control>>, FuncC, Control, Control> {
using baseT = TT<Key, std::tuple<Out<Key, Control>>, FuncC, Control, Control>;
class FuncC : public TT<Key, std::tuple<Out<Key, Control>>, FuncC, ttg::typelist<Control, Control>> {
using baseT = typename FuncC::ttT;
double* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -385,9 +384,8 @@ class FuncC : public TT<Key, std::tuple<Out<Key, Control>>, FuncC, Control, Cont
};

class FuncD : public TT<Key, std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>,
FuncD, Control, Control, Control, Control> {
using baseT = TT<Key, std::tuple<Out<Key, Control>, Out<Key, Control>, Out<Key, Control>, Out<Key, Control>>, FuncD,
Control, Control, Control, Control>;
FuncD, ttg::typelist<Control, Control, Control, Control>> {
using baseT = typename FuncD::ttT;
double* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down
37 changes: 13 additions & 24 deletions examples/ge/ge_df.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -136,10 +136,7 @@ class Initiator : public TT<Integer,
std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>,
Out<Key, BlockMatrix<T>>>,
Initiator<T>> {
using baseT = TT<Integer,
std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>,
Out<Key, BlockMatrix<T>>>,
Initiator>;
using baseT = typename Initiator::ttT;

Matrix<T>* adjacency_matrix_ttg;

Expand Down Expand Up @@ -179,8 +176,8 @@ class Initiator : public TT<Integer,
};

template <typename T>
class Finalizer : public TT<Key, std::tuple<>, Finalizer<T>, BlockMatrix<T>> {
using baseT = TT<Key, std::tuple<>, Finalizer<T>, BlockMatrix<T>>;
class Finalizer : public TT<Key, std::tuple<>, Finalizer<T>, ttg::typelist<BlockMatrix<T>>> {
using baseT = typename Finalizer::ttT;
Matrix<T>* result_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -256,11 +253,8 @@ template <typename T>
class FuncA : public TT<Key,
std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>,
Out<Key, BlockMatrix<T>>>,
FuncA<T>, BlockMatrix<T>> {
using baseT = TT<Key,
std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>,
Out<Key, BlockMatrix<T>>>,
FuncA, BlockMatrix<T>>;
FuncA<T>, ttg::typelist<BlockMatrix<T>>> {
using baseT = typename FuncA::ttT;
Matrix<T>* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -346,10 +340,9 @@ class FuncA : public TT<Key,
};

template <typename T>
class FuncB : public TT<Key, std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>>, FuncB<T>, BlockMatrix<T>,
BlockMatrix<T>> {
using baseT =
TT<Key, std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>>, FuncB, BlockMatrix<T>, BlockMatrix<T>>;
class FuncB : public TT<Key, std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>>,
FuncB<T>, ttg::typelist<BlockMatrix<T>, BlockMatrix<T>>> {
using baseT = typename FuncB::ttT;
Matrix<T>* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -427,10 +420,9 @@ class FuncB : public TT<Key, std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, Block
};

template <typename T>
class FuncC : public TT<Key, std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>>, FuncC<T>, BlockMatrix<T>,
BlockMatrix<T>> {
using baseT =
TT<Key, std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>>, FuncC, BlockMatrix<T>, BlockMatrix<T>>;
class FuncC : public TT<Key, std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>>,
FuncC<T>, ttg::typelist<BlockMatrix<T>, BlockMatrix<T>>> {
using baseT = typename FuncC::ttT;
Matrix<T>* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -512,11 +504,8 @@ template <typename T>
class FuncD : public TT<Key,
std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>,
Out<Key, BlockMatrix<T>>>,
FuncD<T>, BlockMatrix<T>, BlockMatrix<T>, BlockMatrix<T>, BlockMatrix<T>> {
using baseT = TT<Key,
std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>,
Out<Key, BlockMatrix<T>>>,
FuncD, BlockMatrix<T>, BlockMatrix<T>, BlockMatrix<T>, BlockMatrix<T>>;
FuncD<T>, ttg::typelist<BlockMatrix<T>, BlockMatrix<T>, BlockMatrix<T>, BlockMatrix<T>>> {
using baseT = typename FuncD::ttT;
Matrix<T>* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down
52 changes: 30 additions & 22 deletions examples/madness/madness-1d/madness-1d.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -309,8 +309,8 @@ std::ostream& operator<<(std::ostream&s, const Control& ctl) {
return s;
}

class Printer : public TT<Key, std::tuple<>, Printer, Node> {
using baseT = TT<Key, std::tuple<>, Printer, Node>;
class Printer : public TT<Key, std::tuple<>, Printer, ttg::typelist<Node>> {
using baseT = typename Printer::ttT;
public:
Printer(const std::string& name) : baseT(name, {"input"}, {}) {}

Expand All @@ -325,8 +325,8 @@ class Printer : public TT<Key, std::tuple<>, Printer, Node> {
};


class GaxpyOp : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>, GaxpyOp, Node, Node> {
using baseT = TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>, GaxpyOp, Node, Node>;
class GaxpyOp : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>, GaxpyOp, ttg::typelist<Node, Node>> {
using baseT = typename GaxpyOp::ttT;

double alpha;
double beta;
Expand Down Expand Up @@ -369,8 +369,9 @@ class GaxpyOp : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Ke
};


class BinaryOp : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>, BinaryOp, Node, Node> {
using baseT = TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>, BinaryOp, Node, Node>;
class BinaryOp : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>,
BinaryOp, ttg::typelist<Node, Node>> {
using baseT = typename BinaryOp::ttT;

using funcT = Vector (*)(const Vector &, const Vector&);
funcT func;
Expand Down Expand Up @@ -430,8 +431,9 @@ class BinaryOp : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<K
};


class Diff_prologue : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>, Diff_prologue, Node> {
using baseT = TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>, Diff_prologue, Node>;
class Diff_prologue : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>,
Diff_prologue, ttg::typelist<Node>> {
using baseT = typename Diff_prologue::ttT;

public:

Expand All @@ -452,8 +454,9 @@ class Diff_prologue : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>,
}
};

class Diff_doIt : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>, Diff_doIt, Node, Node, Node> {
using baseT = TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>, Diff_doIt, Node, Node, Node>;
class Diff_doIt : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>,
Diff_doIt, ttg::typelist<Node, Node, Node>> {
using baseT = typename Diff_doIt::ttT;

Vector unfilter(const Vector &inputVector, int k, const Matrix * hg) const {
Vector inputVector_copy(inputVector);
Expand Down Expand Up @@ -530,8 +533,9 @@ class Diff_doIt : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<
};


class Compress_prologue : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>, Compress_prologue, Node> {
using baseT = TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>, Compress_prologue, Node>;
class Compress_prologue : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>,
Compress_prologue, ttg::typelist<Node>> {
using baseT = typename Compress_prologue::ttT;

public:
Compress_prologue(const std::string &name)
Expand Down Expand Up @@ -564,8 +568,9 @@ class Compress_prologue : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Nod

};

class Compress_doIt : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>, Compress_doIt, Node, Node> {
using baseT = TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>, Compress_doIt, Node, Node>;
class Compress_doIt : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>, Out<Key, Node>>,
Compress_doIt, ttg::typelist<Node, Node>> {
using baseT = typename Compress_doIt::ttT;

public:
Compress_doIt(const std::string &name)
Expand Down Expand Up @@ -607,8 +612,9 @@ class Compress_doIt : public TT<Key, std::tuple<Out<Key, Node>, Out<Key, Node>,
};


class Reconstruct_prologue : public TT<Key, std::tuple<Out<Key, Vector>>, Reconstruct_prologue, Node> {
using baseT = TT<Key, std::tuple<Out<Key, Vector>>, Reconstruct_prologue, Node>;
class Reconstruct_prologue : public TT<Key, std::tuple<Out<Key, Vector>>,
Reconstruct_prologue, ttg::typelist<Node>> {
using baseT = typename Reconstruct_prologue::ttT;

public:
Reconstruct_prologue(const std::string &name)
Expand All @@ -633,8 +639,9 @@ class Reconstruct_prologue : public TT<Key, std::tuple<Out<Key, Vector>>, Recons
};


class Reconstruct_doIt : public TT<Key, std::tuple<Out<Key, Vector>, Out<Key, Node>>, Reconstruct_doIt, Vector, Node> {
using baseT = TT<Key, std::tuple<Out<Key, Vector>, Out<Key, Node>>, Reconstruct_doIt, Vector, Node>;
class Reconstruct_doIt : public TT<Key, std::tuple<Out<Key, Vector>, Out<Key, Node>>,
Reconstruct_doIt, ttg::typelist<Vector, Node>> {
using baseT = typename Reconstruct_doIt::ttT;

public:
Reconstruct_doIt(const std::string &name)
Expand Down Expand Up @@ -672,8 +679,9 @@ class Reconstruct_doIt : public TT<Key, std::tuple<Out<Key, Vector>, Out<Key, No
};


class Project : public TT<Key, std::tuple<Out<Key,Control>, Out<Key,Node>>, Project, Control> {
using baseT = TT<Key, std::tuple<Out<Key,Control>, Out<Key,Node>>, Project, Control>;
class Project : public TT<Key, std::tuple<Out<Key,Control>, Out<Key,Node>>,
Project, ttg::typelist<Control>> {
using baseT = typename Project::ttT;

public:
using funcT = double(*)(double);
Expand Down Expand Up @@ -733,7 +741,7 @@ class Project : public TT<Key, std::tuple<Out<Key,Control>, Out<Key,Node>>, Pro
};

class Producer : public TT<Key, std::tuple<Out<Key, Control>>, Producer> {
using baseT = TT<Key, std::tuple<Out<Key, Control>>, Producer>;
using baseT = typename Producer::ttT;

public:
Producer(const std::string &name) : baseT(name, {}, {"output"}) {}
Expand All @@ -753,7 +761,7 @@ class Producer : public TT<Key, std::tuple<Out<Key, Control>>, Producer> {

// EXAMPLE 1
class Everything : public TT<Key, std::tuple<>, Everything> {
using baseT = TT<Key, std::tuple<>, Everything>;
using baseT = typename Everything::ttT;

Producer producer;
Project project;
Expand Down
9 changes: 5 additions & 4 deletions examples/madness/mrattg.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -135,7 +135,7 @@ namespace detail {
using compress_out_type = std::tuple<Rout,Rout,cnodeOut<T,K,1>>;
using compress_in_type = std::tuple<Rin, Rin>;
template <typename compfuncT>
using compwrap_type = ttg::CallableWrapTT<compfuncT, Key<1>, compress_out_type, Rin, Rin>;
using compwrap_type = ttg::CallableWrapTT<compfuncT, Key<1>, compress_out_type, ttg::TTPolicyBase<Key<1>>, Rin, Rin>;
};

template <typename T, size_t K> struct tree_types<T,K,2>{
Expand All @@ -144,7 +144,7 @@ namespace detail {
using compress_out_type = std::tuple<Rout,Rout,Rout,Rout,cnodeOut<T,K,2>>;
using compress_in_type = std::tuple<Rin, Rin, Rin, Rin>;
template <typename compfuncT>
using compwrap_type = ttg::CallableWrapTT<compfuncT, Key<2>, compress_out_type, Rin, Rin, Rin, Rin>;
using compwrap_type = ttg::CallableWrapTT<compfuncT, Key<2>, compress_out_type, ttg::TTPolicyBase<Key<2>>, Rin, Rin, Rin, Rin>;
};

template <typename T, size_t K> struct tree_types<T,K,3>{
Expand All @@ -153,7 +153,7 @@ namespace detail {
using compress_out_type = std::tuple<Rout,Rout,Rout,Rout,Rout,Rout,Rout,Rout,cnodeOut<T,K,3>>;
using compress_in_type = std::tuple<Rin, Rin, Rin, Rin, Rin, Rin, Rin, Rin>;
template <typename compfuncT>
using compwrap_type = ttg::CallableWrapTT<compfuncT, Key<3>, compress_out_type, Rin, Rin, Rin, Rin, Rin, Rin, Rin, Rin>;
using compwrap_type = ttg::CallableWrapTT<compfuncT, Key<3>, compress_out_type, ttg::TTPolicyBase<Key<3>>, Rin, Rin, Rin, Rin, Rin, Rin, Rin, Rin>;
};
};

Expand Down Expand Up @@ -237,7 +237,8 @@ auto make_compress(rnodeEdge<T,K,NDIM>& in, cnodeEdge<T,K,NDIM>& out, const std:
constexpr size_t num_children = Key<NDIM>::num_children;

using sendfuncT = decltype(&send_leaves_up<T,K,NDIM>);
using sendwrapT = ttg::CallableWrapTT<sendfuncT, Key<NDIM>, typename ::detail::tree_types<T,K,NDIM>::compress_out_type, FunctionReconstructedNode<T,K,NDIM> >;
using sendwrapT = ttg::CallableWrapTT<sendfuncT, Key<NDIM>, typename ::detail::tree_types<T,K,NDIM>::compress_out_type,
ttg::TTPolicyBase<Key<NDIM>>, FunctionReconstructedNode<T,K,NDIM> >;
using compfuncT = decltype(&do_compress<T,K,NDIM>);
using compwrapT = typename ::detail::tree_types<T,K,NDIM>::template compwrap_type<compfuncT>;

Expand Down
6 changes: 3 additions & 3 deletions examples/madness/mrattg_streaming.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -366,7 +366,7 @@ namespace detail {
using compress_out_type = std::tuple<Rout,Rout,cnodeOut<T,K,1>>;
using compress_in_type = std::tuple<Rin, Rin>;
template <typename compfuncT>
using compmake_tt_type = ttg::TT<compfuncT, Key<1>, compress_out_type, Rin, Rin>;
using compmake_tt_type = ttg::TT<compfuncT, Key<1>, compress_out_type, ttg::typelist<Rin, Rin>>;
};

template <typename T, size_t K> struct tree_types<T,K,2>{
Expand All @@ -375,7 +375,7 @@ namespace detail {
using compress_out_type = std::tuple<Rout,Rout,Rout,Rout,cnodeOut<T,K,2>>;
using compress_in_type = std::tuple<Rin, Rin, Rin, Rin>;
template <typename compfuncT>
using compmake_tt_type = ttg::TT<compfuncT, Key<2>, compress_out_type, Rin, Rin, Rin, Rin>;
using compmake_tt_type = ttg::TT<compfuncT, Key<2>, compress_out_type, ttg::typelist<Rin, Rin, Rin, Rin>>;
};

template <typename T, size_t K> struct tree_types<T,K,3>{
Expand All @@ -384,7 +384,7 @@ namespace detail {
using compress_out_type = std::tuple<Rout,Rout,Rout,Rout,Rout,Rout,Rout,Rout,cnodeOut<T,K,3>>;
using compress_in_type = std::tuple<Rin, Rin, Rin, Rin, Rin, Rin, Rin, Rin>;
template <typename compfuncT>
using compmake_tt_type = ttg::TT<compfuncT, Key<3>, compress_out_type, Rin, Rin, Rin, Rin, Rin, Rin, Rin, Rin>;
using compmake_tt_type = ttg::TT<compfuncT, Key<3>, compress_out_type, ttg::typelist<Rin, Rin, Rin, Rin, Rin, Rin, Rin, Rin>>;
};
};

Expand Down
Loading