Skip to content

[WIP] UxT-Reducer streaming terminals #190

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

[WIP] UxT-Reducer streaming terminals #190

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
c12bf4c
First draft of UT-reducer streaming terminals
devreal Nov 5, 2021
87a190c
Add test for vector<int> x int reduction
devreal Nov 5, 2021
f7f1f7b
Port more tests to use tuple-based type list
devreal Nov 17, 2021
88a3471
We need to call the reducer on the first input if edge type and arg t…
devreal Nov 17, 2021
e634897
Fix TT templates in mrattg-streaming
devreal Nov 17, 2021
5644691
PaRSEC: rename input terminal tuple and add static asserts
devreal Nov 17, 2021
1f152de
Adjust the madness backend to the tuple-based type lists
devreal Nov 17, 2021
6092f48
Adapt unit tests to tuple-based type lists
devreal Nov 18, 2021
62fedc0
Madness: Remove void from full_args_type
devreal Nov 18, 2021
d17f84e
Add missing stdexcept include to env.cpp
devreal Nov 18, 2021
4e877bf
Changed MRA example to use UxT reducer
pnookala Nov 19, 2021
fa3c2a0
Merge pull request #2 from pnookala/ut_streaming_mra
devreal Nov 20, 2021
32c2c32
PaRSEC: Cover all possible paths in input to argument conversion
devreal Nov 20, 2021
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, std::tuple<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, std::tuple<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, std::tuple<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, std::tuple<Control, Control, Control>> {
using baseT = typename FuncD::ttT;
double* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down
33 changes: 10 additions & 23 deletions examples/floyd-warshall/floyd_warshall_df.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -154,8 +154,8 @@ class Initiator : public TT<int,
};

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>, std::tuple<BlockMatrix<T>>> {
using baseT = typename Finalizer::ttT;
Matrix<T>* result_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -236,12 +236,8 @@ class FuncA : public TT<Key,
std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>,
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>>,
Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>>,
FuncA, BlockMatrix<T>>;
FuncA<T>, std::tuple<BlockMatrix<T>>> {
using baseT = typename FuncA::ttT;
Matrix<T>* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -339,11 +335,8 @@ template <typename T>
class FuncB : public TT<Key,
std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>,
Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>>,
FuncB<T>, BlockMatrix<T>, const BlockMatrix<T>> {
using baseT = TT<Key,
std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>,
Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>>,
FuncB, BlockMatrix<T>, const BlockMatrix<T>>;
FuncB<T>, std::tuple<BlockMatrix<T>, const BlockMatrix<T>>> {
using baseT = typename FuncB::ttT;
Matrix<T>* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -432,11 +425,8 @@ template <typename T>
class FuncC : public TT<Key,
std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>,
Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>>,
FuncC<T>, BlockMatrix<T>, const BlockMatrix<T>> {
using baseT = TT<Key,
std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>,
Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>>,
FuncC, BlockMatrix<T>, const BlockMatrix<T>>;
FuncC<T>, std::tuple<BlockMatrix<T>, const BlockMatrix<T>>> {
using baseT = typename FuncC::ttT;
Matrix<T>* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down Expand Up @@ -524,11 +514,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>>, Out<Key, BlockMatrix<T>>>,
FuncD<T>, BlockMatrix<T>, const BlockMatrix<T>, const BlockMatrix<T>> {
using baseT = TT<Key,
std::tuple<Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>,
Out<Key, BlockMatrix<T>>, Out<Key, BlockMatrix<T>>>,
FuncD, BlockMatrix<T>, const BlockMatrix<T>, const BlockMatrix<T>>;
FuncD<T>, std::tuple<BlockMatrix<T>, const BlockMatrix<T>, const BlockMatrix<T>>> {
using baseT = typename FuncD::ttT;
Matrix<T>* adjacency_matrix_ttg;
int problem_size;
int blocking_factor;
Expand Down
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, std::tuple<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, std::tuple<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, std::tuple<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, std::tuple<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>, std::tuple<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>, std::tuple<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>,
std::tuple<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>,
std::tuple<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>, std::tuple<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
Loading