ttg/dox-master/iterative_8cc-example.html

#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>;


namespace std {

  std::ostream &operator<<(std::ostream &os, const Key2 &key) {

    os << "{" << std::get<0>(key) << ", " << std::get<1>(key) << "}";

    return os;

  }

}  // namespace std


static void a(const int &k, const double &input, std::tuple<ttg::Out<Key2, double>> &out) {

  ttg::print("Called task A(", k, ")");

 ttg::send <0>(Key2{k, 0}, 1.0 + input, out); ttg::send <0>(Key2{k, 1}, 2.0 + input, out);}


static void b(const Key2 &key, const double &input, std::tuple<ttg::Out<int, double>, ttg::Out<int, double>> &out) {

  ttg::print("Called task B(", key, ") with input data ", input);

  if (std::get<1>(key) == 0)

 ttg::send <0>(std::get<0>(key), input + 1.0, out);  else

 ttg::send <1>(std::get<0>(key), input + 1.0, out);}


static void c(const int &k, const double &b0, const double &b1, std::tuple<ttg::Out<int, double>> &out) {

  ttg::print("Called task C(", k, ") with inputs ", b0, " from B(", k, " 0) and ", b1, " from B(", k, " 1)");

  if (b0 + b1 < threshold) {

    ttg::print("  ", b0, "+", b1, "<", threshold, " so continuing to iterate");

 ttg::send <0>(k + 1, b0 + b1, out);  } else {

    ttg::print("  ", b0, "+", b1, ">=", threshold, " so stopping the iterations");

  }

}


int main(int argc, char **argv) {

  ttg::initialize(argc, argv, -1);


  ttg::Edge<Key2, double> A_B("A(k)->B(k)");

  ttg::Edge<int, double> B_C0("B(k)->C0(k)");

  ttg::Edge<int, double> B_C1("B(k)->C1(k)");

  ttg::Edge<int, double> C_A("C(k)->A(k)");


  auto wa(ttg::make_tt(a, ttg::edges(C_A), ttg::edges(A_B), "A", {"from C"}, {"to B"}));

  auto wb(ttg::make_tt(b, ttg::edges(A_B), ttg::edges(B_C0, B_C1), "B", {"from A"},

                       {"to 1st input of C", "to 2nd input of C"}));

  auto wc(ttg::make_tt(c, ttg::edges(B_C0, B_C1), ttg::edges(C_A), "C", {"From B", "From B"}, {"to A"}));


  ttg::make_graph_executable(wa);


  if (wa->get_world().rank() == 0) wa->invoke(0, 0.0);


  ttg::execute();

  ttg::fence(ttg::get_default_world());


  ttg::finalize();

  return EXIT_SUCCESS;

}


ttg::Edge
Edge is used to connect In and Out terminals.
Definition edge.h:25

ttg::Out
Definition terminal.h:429

threshold
const double threshold
Definition distributed.cc:5

main
int main(int argc, char **argv)
Definition distributed.cc:31

Key2
std::pair< int, int > Key2
Definition distributed.cc:6

std
STL namespace.

std::operator<<
std::ostream & operator<<(std::ostream &os, ttg::device::Device device)
Definition device.h:83

ttg::execute
void execute(ttg::World world)
Starts the execution in the given execution context.
Definition run.h:74

ttg::initialize
void initialize(int argc, char **argv, int num_threads=-1, RestOfArgs &&...)

ttg::send
void send()
Sends a control message (message without an accompanying task id or a value) to the template tasks at...
Definition func.h:340

ttg::get_default_world
ttg::World & get_default_world()
Definition world.h:80

ttg::fence
void fence(ttg::World world)
Returns when all tasks associated with the given execution context have finished on all ranks.
Definition run.h:81

ttg::finalize
void finalize()
Finalizes the TTG runtime.
Definition func.h:589

ttg::print
void print(const T &t, const Ts &... ts)
atomically prints to std::cout a sequence of items (separated by ttg::print_separator) followed by st...
Definition print.h:130

ttg::make_graph_executable
std::enable_if_t<(std::is_convertible_v< decltype(*(std::declval< TTBasePtrs >())), TTBase & > &&...), bool > make_graph_executable(TTBasePtrs &&...tts)
Make the TTG tts executable. Applies.
Definition func.h:80

ttg::edges
auto edges(inedgesT &&...args)
Make a tuple of Edges to pass to.
Definition func.h:147

pair.h

pair.h