#included util/hash/std/pair.h where needed

therault · Sep 15, 2022 · 1f4efe1 · 1f4efe1
1 parent ebfe297
commit 1f4efe1
Show file tree

Hide file tree

Showing 10 changed files with 42 additions and 41 deletions.
diff --git a/doc/dox/user/examples/distributed.cc b/doc/dox/user/examples/distributed.cc
@@ -1,5 +1,6 @@
 #include <ttg.h>
 #include <ttg/serialization/std/pair.h>
+#include <ttg/util/hash/std/pair.h>
 
 const double threshold = 100.0;
 using Key2 = std::pair<int, int>;
@@ -35,7 +36,7 @@ int main(int argc, char **argv) {
   ttg::Edge<int, double> C_A("C(k)->A(k)");
 
   auto wc(ttg::make_tt(c, ttg::edges(B_C), ttg::edges(C_A), "C", {"From B"}, {"to A"}));
-  
+
   /**! \link TT::set_input_reducer() */wc->set_input_reducer/**! \endlink */<0>([](double &a, const double &b) { a += b; });
 
   auto wa(ttg::make_tt([&](const int &k, const double &input, std::tuple<ttg::Out<Key2, double>> &out) {
@@ -67,8 +68,8 @@ int main(int argc, char **argv) {
 /**
  * \example distributed.cc
  * This is the iterative diamond DAG with variable number of inputs using the reducing
- * terminals of Template Task Graph, adapted to run in distributed: iteratively, a reducing 
- * diamond of data-dependent width is run, until the amount of data gathered at the bottom 
+ * terminals of Template Task Graph, adapted to run in distributed: iteratively, a reducing
+ * diamond of data-dependent width is run, until the amount of data gathered at the bottom
  * of the diamond exceeds a given threshold. First and last tasks of each diamond are run
  * on rank 0, while the tasks inside the diamond are distributed between the ranks in a
  * round-robin fashion.

diff --git a/examples/floyd-warshall/floyd_warshall.cc b/examples/floyd-warshall/floyd_warshall.cc
@@ -23,6 +23,7 @@ using namespace ttg;
 
 #include "ttg/serialization.h"
 #include "ttg/serialization/std/pair.h"
+#include "ttg/util/hash/std/pair.h"
 
 struct Key {
   // ((I, J), K) where (I, J) is the tile coordinate and K is the iteration number
@@ -81,8 +82,8 @@ namespace std {
   };
 }  // namespace std
 
-class Initiator : public TT<int, std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>>,
-                            Initiator> {
+class Initiator
+    : public TT<int, std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>>, Initiator> {
   using baseT = typename Initiator::ttT;
 
  public:
@@ -112,10 +113,11 @@ class Initiator : public TT<int, std::tuple<Out<Key, void>, Out<Key, void>, Out<
   }
 };
 
-class FuncA : public TT<Key,
-                        std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>,
-                                   Out<Key, void>, Out<Key, void>>,
-                        FuncA, ttg::typelist<void>> {
+class FuncA
+    : public TT<
+          Key,
+          std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>>,
+          FuncA, ttg::typelist<void>> {
   using baseT = typename FuncA::ttT;
   double* adjacency_matrix_ttg;
   int problem_size;
@@ -204,11 +206,8 @@ class FuncA : public TT<Key,
   }
 };
 
-class FuncB
-    : public TT<
-          Key,
-          std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>>,
-          FuncB, ttg::typelist<void, void>> {
+class FuncB : public TT<Key, std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>>,
+                        FuncB, ttg::typelist<void, void>> {
   using baseT = typename FuncB::ttT;
   double* adjacency_matrix_ttg;
   int problem_size;
@@ -295,11 +294,8 @@ class FuncB
   }
 };
 
-class FuncC
-    : public TT<
-          Key,
-          std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>>,
-          FuncC, ttg::typelist<void, void>> {
+class FuncC : public TT<Key, std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>>,
+                        FuncC, ttg::typelist<void, void>> {
   using baseT = typename FuncC::ttT;
   double* adjacency_matrix_ttg;
   int problem_size;
@@ -386,8 +382,8 @@ class FuncC
   }
 };
 
-class FuncD : public TT<Key, std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>>,
-                        FuncD, ttg::typelist<void, void, void>> {
+class FuncD : public TT<Key, std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>>, FuncD,
+                        ttg::typelist<void, void, void>> {
   using baseT = typename FuncD::ttT;
   double* adjacency_matrix_ttg;
   int problem_size;

diff --git a/examples/floyd-warshall/floyd_warshall_df.cc b/examples/floyd-warshall/floyd_warshall_df.cc
@@ -23,6 +23,7 @@ using namespace ttg;
 
 #include "ttg/serialization.h"
 #include "ttg/serialization/std/pair.h"
+#include "ttg/util/hash/std/pair.h"
 
 #include "../blockmatrix.h"
 #include "ttg/util/bug.h"

diff --git a/examples/ge/ge.cc b/examples/ge/ge.cc
@@ -20,6 +20,7 @@ using namespace std;
 
 #include "ttg/serialization.h"
 #include "ttg/serialization/std/pair.h"
+#include "ttg/util/hash/std/pair.h"
 
 using namespace ttg;
 
@@ -116,8 +117,7 @@ std::ostream& operator<<(std::ostream& s, const Integer& intVal) {
 }
 
 class Initiator
-    : public TT<Integer, std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>>,
-                Initiator> {
+    : public TT<Integer, std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>>, Initiator> {
   using baseT = typename Initiator::ttT;
 
  public:
@@ -371,8 +371,8 @@ class FuncC : public TT<Key, std::tuple<Out<Key, void>>, FuncC, ttg::typelist<vo
   }
 };
 
-class FuncD : public TT<Key, std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>>,
-                        FuncD, ttg::typelist<void, void, void, void>> {
+class FuncD : public TT<Key, std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>, Out<Key, void>>, FuncD,
+                        ttg::typelist<void, void, void, void>> {
   using baseT = typename FuncD::ttT;
   double* adjacency_matrix_ttg;
   int problem_size;

diff --git a/examples/ge/ge_df.cc b/examples/ge/ge_df.cc
@@ -24,6 +24,7 @@ using namespace ttg;
 
 #include "ttg/serialization.h"
 #include "ttg/serialization/std/pair.h"
+#include "ttg/util/hash/std/pair.h"
 
 #include <madness/world/world.h>
 
@@ -328,8 +329,8 @@ 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>, ttg::typelist<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;
@@ -408,8 +409,8 @@ 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>, ttg::typelist<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;

diff --git a/examples/sw/sw.cc b/examples/sw/sw.cc
@@ -11,6 +11,7 @@
 #include "ttg.h"
 
 #include "ttg/serialization/std/pair.h"
+#include "ttg/util/hash/std/pair.h"
 
 /* TODO: get rid of the using statement */
 using namespace ttg;

diff --git a/examples/wavefront/wavefront-df.cc b/examples/wavefront/wavefront-df.cc
@@ -14,6 +14,7 @@
 #include "ttg/serialization.h"
 #include "ttg/serialization/std/pair.h"
 #include "ttg/serialization/std/vector.h"
+#include "ttg/util/hash/std/pair.h"
 
 /* TODO: Get rid of using statement */
 using namespace ttg;
@@ -113,7 +114,7 @@ auto make_wavefront2(const funcT& func, int MB, int NB, Edge<Key, BlockMatrix<T>
   };
 
   return make_tt(f, edges(input, left, top, bottom_right), edges(left, top, result), "wavefront2",
-              {"input", "left", "top", "bottom-right"}, {"left", "top", "result"});
+                 {"input", "left", "top", "bottom-right"}, {"left", "top", "result"});
 }
 
 template <typename T>
@@ -165,7 +166,7 @@ auto initiator(Matrix<T>* m, Edge<Key, BlockMatrix<T>>& out0, Edge<Key, BlockMat
   };
 
   return make_tt<Key>(f, edges(), edges(out0, out1, out2, bottom_right0, bottom_right1, bottom_right2), "initiator", {},
-                   {"out0", "out1", "out2", "bottom_right0", "bottom-right1", "bottom-right2"});
+                      {"out0", "out1", "out2", "bottom_right0", "bottom-right1", "bottom-right2"});
 }
 
 template <typename funcT, typename T>
@@ -189,7 +190,7 @@ auto make_wavefront0(const funcT& func, int MB, int NB, Edge<Key, BlockMatrix<T>
   };
 
   return make_tt(f, edges(input, bottom_right), edges(toporleft, result), "wavefront0", {"input", "bottom_right"},
-              {"toporleft", "result"});
+                 {"toporleft", "result"});
 }
 
 // Method to generate wavefront task with single input.

diff --git a/examples/wavefront/wavefront-wf.cc b/examples/wavefront/wavefront-wf.cc
@@ -10,6 +10,7 @@
 #include <utility>
 
 #include "ttg/serialization/std/pair.h"
+#include "ttg/util/hash/std/pair.h"
 
 #include "ttg.h"
 
@@ -92,10 +93,8 @@ void wavefront_serial() {
 
 // Method to generate  wavefront tasks with two inputs.
 template <typename funcT>
-auto make_wavefront2(std::shared_ptr<double> m, const funcT& func, Edge<Key, void>& input1,
-                     Edge<Key, void>& input2) {
-  auto f = [m, func](const Key& key,
-                     std::tuple<Out<Key, void>, Out<Key, void>>& out) {
+auto make_wavefront2(std::shared_ptr<double> m, const funcT& func, Edge<Key, void>& input1, Edge<Key, void>& input2) {
+  auto f = [m, func](const Key& key, std::tuple<Out<Key, void>, Out<Key, void>>& out) {
     auto [i, j] = key;
     int next_i = i + 1;
     int next_j = j + 1;
@@ -123,10 +122,8 @@ auto make_wavefront2(std::shared_ptr<double> m, const funcT& func, Edge<Key, voi
 
 // Method to generate wavefront task with single input.
 template <typename funcT>
-auto make_wavefront(std::shared_ptr<double> m, const funcT& func, Edge<Key, void>& input1,
-                    Edge<Key, void>& input2) {
-  auto f = [m, func](const Key& key,
-                     std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>>& out) {
+auto make_wavefront(std::shared_ptr<double> m, const funcT& func, Edge<Key, void>& input1, Edge<Key, void>& input2) {
+  auto f = [m, func](const Key& key, std::tuple<Out<Key, void>, Out<Key, void>, Out<Key, void>>& out) {
     auto [i, j] = key;
     int next_i = i + 1;
     int next_j = j + 1;
@@ -148,7 +145,8 @@ auto make_wavefront(std::shared_ptr<double> m, const funcT& func, Edge<Key, void
   };
 
   Edge<Key, void> recur("recur");
-  return make_tt(f, edges(recur), edges(recur, input1, input2), "wavefront", {"control"}, {"recur", "output1", "output2"});
+  return make_tt(f, edges(recur), edges(recur, input1, input2), "wavefront", {"control"},
+                 {"recur", "output1", "output2"});
 }
 
 int main(int argc, char** argv) {

diff --git a/examples/wavefront/wavefront-wf2.cc b/examples/wavefront/wavefront-wf2.cc
@@ -11,6 +11,7 @@
 #include "ttg.h"
 
 #include "ttg/serialization/std/pair.h"
+#include "ttg/util/hash/std/pair.h"
 
 using namespace ttg;
 

diff --git a/tests/unit/fibonacci.cc b/tests/unit/fibonacci.cc
@@ -3,6 +3,7 @@
 #include "ttg.h"
 
 #include "ttg/serialization/std/pair.h"
+#include "ttg/util/hash/std/pair.h"
 
 constexpr int64_t N = 1000;