#2378: apply clang-format to src, examples, tests

Author: cz4rs

examples/callback/callback.cc

@@ -53,8 +53,7 @@ struct TestMsg : vt::Message {
 
   explicit TestMsg(int in_val, std::string const& in_s = "hello")
     : val_(in_val),
-      s_(in_s)
-  { }
+      s_(in_s) { }
 
   template <typename SerializerT>
   void serialize(SerializerT& s) {
@@ -69,9 +68,7 @@ struct TestMsg : vt::Message {
 
 // Message containing the callback to invoke
 struct HelloMsg : vt::Message {
-  explicit HelloMsg(vt::Callback<TestMsg> in_cb)
-    : cb_(in_cb)
-  { }
+  explicit HelloMsg(vt::Callback<TestMsg> in_cb) : cb_(in_cb) { }
 
   vt::Callback<TestMsg> cb_;
 };
@@ -85,14 +82,14 @@ void hello_world(HelloMsg* msg) {
 
 void printOutput(TestMsg* msg, std::string type) {
   vt::NodeType this_node = vt::theContext()->getNode();
-  fmt::print("{}: cb {}: val={}, str={}\n", this_node, type, msg->val_, msg->s_);
+  fmt::print(
+    "{}: cb {}: val={}, str={}\n", this_node, type, msg->val_, msg->s_
+  );
 }
 
 // Functor callback endpoint
 struct CallbackFunctor {
-  void operator()(TestMsg* msg) {
-    printOutput(msg, "CallbackFunctor");
-  }
+  void operator()(TestMsg* msg) { printOutput(msg, "CallbackFunctor"); }
 };
 
 // Function callback endpoint
@@ -102,9 +99,7 @@ static void callbackFunc(TestMsg* msg) {
 
 struct MyObj {
   // Objgroup callback endpoint
-  void handler(TestMsg* msg) {
-    printOutput(msg, "MyObj::handler");
-  }
+  void handler(TestMsg* msg) { printOutput(msg, "MyObj::handler"); }
 };
 
 struct MyCol : vt::Collection<MyCol, vt::Index1D> { };
@@ -131,9 +126,9 @@ int main(int argc, char** argv) {
 
   auto obj = vt::theObjGroup()->makeCollective<MyObj>("examples_callback");
   auto col = vt::makeCollection<MyCol>("examples_callback")
-    .bounds(vt::Index1D(8))
-    .bulkInsert()
-    .wait();
+               .bounds(vt::Index1D(8))
+               .bulkInsert()
+               .wait();
 
   if (this_node == 0) {
     vt::NodeType dest = num_nodes > 2 ? 2 : 0;

examples/callback/callback_context.cc

@@ -87,7 +87,7 @@ static void callbackFn(DataMsg* msg, MyContext* ctx) {
 static void handler(CallbackMsg* msg) {
   auto cb = msg->cb;
   auto data_msg = vt::makeMessage<DataMsg>();
-  data_msg->vec_ = std::vector<int>{18,45,28,-1,344};
+  data_msg->vec_ = std::vector<int>{18, 45, 28, -1, 344};
   fmt::print("handler: vec.size={}\n", data_msg->vec_.size());
   cb.sendMsg(data_msg);
 }
@@ -109,7 +109,7 @@ int main(int argc, char** argv) {
     my_global_ctx.x = 1283;
 
     // Make a callback that triggers the callback with a context
-    auto cb = vt::theCB()->makeFunc<DataMsg,MyContext>(
+    auto cb = vt::theCB()->makeFunc<DataMsg, MyContext>(
       vt::pipe::LifetimeEnum::Once, &my_global_ctx, callbackFn
     );
 

examples/collection/4d_collection.cc

@@ -44,32 +44,29 @@
 #include <vt/transport.h>
 
 struct Example4D : vt::Collection<Example4D, vt::Index4D> {
-
   Example4D() = default;
 
   void hello() {
     fmt::print(
       "{}: Hello from Example4D: {}\n", vt::theContext()->getNode(), getIndex()
     );
   }
-
 };
 
 int main(int argc, char** argv) {
   vt::initialize(argc, argv);
 
-  auto range = vt::Index4D(2,4,3,2);
+  auto range = vt::Index4D(2, 4, 3, 2);
 
   auto proxy = vt::makeCollection<Example4D>("4d_collection")
-    .bounds(range)
-    .bulkInsert()
-    .wait();
+                 .bounds(range)
+                 .bulkInsert()
+                 .wait();
 
   if (vt::theContext()->getNode() == 0) {
     proxy.broadcast<&Example4D::hello>();
   }
 
-
   vt::finalize();
   return 0;
 }

examples/collection/do_flops_perf.cc

@@ -55,10 +55,10 @@ double pi(uint64_t n) {
   double sum = 0.0;
   int sign = 1;
   for (uint64_t i = 0; i < n; ++i) {
-    sum += sign/(2.0*i+1.0);
+    sum += sign / (2.0 * i + 1.0);
     sign *= -1;
   }
-  return 4.0*sum;
+  return 4.0 * sum;
 }
 
 struct GenericWork : vt::Collection<GenericWork, vt::Index1D> {
@@ -75,17 +75,16 @@ struct GenericWork : vt::Collection<GenericWork, vt::Index1D> {
     // ----------------------------------------------------------
 
     vt::theContext()->getTask()->stopMetrics();
-    std::unordered_map<std::string, uint64_t> res = vt::theContext()->getTask()->getMetrics();
+    std::unordered_map<std::string, uint64_t> res =
+      vt::theContext()->getTask()->getMetrics();
     for (auto [name, value] : res) {
       fmt::print("  {}: {}\n", name, value);
     }
 
     fmt::print("-- Stopping Iteration --\n");
   }
 
-  void init(int in_flops_per_iter) {
-    flopsPerIter_ = in_flops_per_iter;
-  }
+  void init(int in_flops_per_iter) { flopsPerIter_ = in_flops_per_iter; }
 
 private:
   size_t flopsPerIter_ = 0;
@@ -105,7 +104,9 @@ int main(int argc, char** argv) {
 
   if (argc == 1) {
     if (this_node == 0) {
-      fmt::print(stderr, "{}: using default arguments since none provided\n", name);
+      fmt::print(
+        stderr, "{}: using default arguments since none provided\n", name
+      );
     }
     num_objs = default_num_objs * num_nodes;
   } else if (argc == 2) {
@@ -118,24 +119,26 @@ int main(int argc, char** argv) {
     flopsPerIter = static_cast<size_t>(strtol(argv[2], nullptr, 10));
     maxIter = static_cast<size_t>(strtol(argv[3], nullptr, 10));
   } else {
-    fmt::print(stderr, "usage: {} <num-objects> <flops-per-iter> <maxiter>\n", name);
+    fmt::print(
+      stderr, "usage: {} <num-objects> <flops-per-iter> <maxiter>\n", name
+    );
     return 1;
   }
 
   using BaseIndexType = typename vt::Index1D::DenseIndexType;
   auto range = vt::Index1D(static_cast<BaseIndexType>(num_objs));
 
   auto col_proxy = vt::makeCollection<GenericWork>("examples_generic_work")
-    .bounds(range)
-    .bulkInsert()
-    .wait();
+                     .bounds(range)
+                     .bulkInsert()
+                     .wait();
 
-  vt::runInEpochCollective([&]{
+  vt::runInEpochCollective([&] {
     col_proxy.broadcastCollective<&GenericWork::init>(flopsPerIter);
   });
 
   for (std::size_t i = 0; i < maxIter; i++) {
-    vt::runInEpochCollective([&]{
+    vt::runInEpochCollective([&] {
       col_proxy.broadcastCollective<&GenericWork::doIteration>();
     });
     vt::thePhase()->nextPhaseCollective();

examples/collection/insertable_collection.cc

@@ -55,7 +55,7 @@ struct InsertCol : vt::Collection<InsertCol, vt::Index1D> {
 int main(int argc, char** argv) {
   vt::initialize(argc, argv);
 
-  if(vt::theContext()->getNumNodes() < 2){
+  if (vt::theContext()->getNumNodes() < 2) {
     vt::finalize();
     return 0;
   }
@@ -70,8 +70,8 @@ int main(int argc, char** argv) {
 
   auto range = vt::Index1D(num_elms);
   auto proxy = vt::makeCollection<InsertCol>("examples_insertable_collection")
-    .dynamicMembership(true)
-    .wait();
+                 .dynamicMembership(true)
+                 .wait();
 
   {
     auto token = proxy.beginModification();
@@ -89,7 +89,7 @@ int main(int argc, char** argv) {
   {
     auto token = proxy.beginModification();
 
-    for (int i = range.x()/2; i < range.x(); i++) {
+    for (int i = range.x() / 2; i < range.x(); i++) {
       if (i % num_nodes == this_node) {
         proxy[i].insertAt(token, i % 2);
       }
@@ -98,7 +98,6 @@ int main(int argc, char** argv) {
     fmt::print("called finishedModification (2)\n");
   }
 
-
   vt::finalize();
 
   return 0;