Reformatted

Author: axsaucedo

src/Manager.cpp

@@ -124,10 +124,10 @@ Manager::createManagedSequence(std::string sequenceName, uint32_t queueIndex)
 
     if (sequenceName.empty()) {
         this->mCurrentSequenceIndex++;
-        this->mManagedSequences.insert({ KP_DEFAULT_SESSION + std::to_string(this->mCurrentSequenceIndex), sq });
-    }
-    else 
-    {
+        this->mManagedSequences.insert(
+          { KP_DEFAULT_SESSION + std::to_string(this->mCurrentSequenceIndex),
+            sq });
+    } else {
         // TODO: Check if sequence doens't already exist
         this->mManagedSequences.insert({ sequenceName, sq });
     }

src/Sequence.cpp

@@ -76,7 +76,8 @@ Sequence::begin()
     }
 
     if (this->isRunning()) {
-        SPDLOG_WARN("Kompute Sequence begin called when sequence still running");
+        SPDLOG_WARN(
+          "Kompute Sequence begin called when sequence still running");
         return false;
     }
 

src/include/kompute/Manager.hpp

@@ -72,7 +72,8 @@ class Manager
      * Create a new managed Kompute sequence so it's available within the
      * manager.
      *
-     * @param sequenceName The name for the named sequence to be created, if empty then default indexed value is used
+     * @param sequenceName The name for the named sequence to be created, if
+     * empty then default indexed value is used
      * @param queueIndex The queue to use from the available queues
      * @return Weak pointer to the manager owned sequence resource
      */
@@ -125,8 +126,10 @@ class Manager
     {
         SPDLOG_DEBUG("Kompute Manager evalOp Default triggered");
         this->mCurrentSequenceIndex++;
-        this->evalOp<T>(
-          tensors, KP_DEFAULT_SESSION + std::to_string(this->mCurrentSequenceIndex), std::forward<TArgs>(params)...);
+        this->evalOp<T>(tensors,
+                        KP_DEFAULT_SESSION +
+                          std::to_string(this->mCurrentSequenceIndex),
+                        std::forward<TArgs>(params)...);
     }
 
     /**
@@ -168,20 +171,23 @@ class Manager
     }
 
     /**
-     * Operation that evaluates operation against default sequence asynchronously.
+     * Operation that evaluates operation against default sequence
+     * asynchronously.
      *
      * @param tensors The tensors to be used in the operation recorded
      * @param params Template parameters that will be used to initialise
      * Operation to allow for extensible configurations on initialisation
      */
     template<typename T, typename... TArgs>
     void evalOpAsyncDefault(std::vector<std::shared_ptr<Tensor>> tensors,
-                     TArgs&&... params)
+                            TArgs&&... params)
     {
         SPDLOG_DEBUG("Kompute Manager evalOpAsyncDefault triggered");
         this->mCurrentSequenceIndex++;
-        this->evalOpAsync<T>(
-                tensors, KP_DEFAULT_SESSION + std::to_string(this->mCurrentSequenceIndex), std::forward<TArgs>(params)...);
+        this->evalOpAsync<T>(tensors,
+                             KP_DEFAULT_SESSION +
+                               std::to_string(this->mCurrentSequenceIndex),
+                             std::forward<TArgs>(params)...);
     }
 
     /**
@@ -192,7 +198,8 @@ class Manager
      */
     void evalOpAwait(std::string sequenceName, uint64_t waitFor = UINT64_MAX)
     {
-        SPDLOG_DEBUG("Kompute Manager evalOpAwait triggered with sequence {}", sequenceName);
+        SPDLOG_DEBUG("Kompute Manager evalOpAwait triggered with sequence {}",
+                     sequenceName);
         std::unordered_map<std::string, std::shared_ptr<Sequence>>::iterator
           found = this->mManagedSequences.find(sequenceName);
 
@@ -221,7 +228,9 @@ class Manager
     void evalOpAwaitDefault(uint64_t waitFor = UINT64_MAX)
     {
         SPDLOG_DEBUG("Kompute Manager evalOpAwaitDefault triggered");
-        this->evalOpAwait(KP_DEFAULT_SESSION + std::to_string(this->mCurrentSequenceIndex), waitFor);
+        this->evalOpAwait(KP_DEFAULT_SESSION +
+                            std::to_string(this->mCurrentSequenceIndex),
+                          waitFor);
     }
 
     /**

test/TestAsyncOperations.cpp

@@ -55,8 +55,7 @@ TEST(TestAsyncOperations, TestManagerParallelExecution)
 
     for (uint32_t i = 0; i < numParallel; i++) {
         mgr.evalOpDefault<kp::OpAlgoBase<>>(
-          { inputsSyncB[i] },
-          std::vector<char>(shader.begin(), shader.end()));
+          { inputsSyncB[i] }, std::vector<char>(shader.begin(), shader.end()));
     }
 
     auto endSync = std::chrono::high_resolution_clock::now();
@@ -153,14 +152,10 @@ TEST(TestAsyncOperations, TestManagerAsyncExecution)
     mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
 
     mgr.evalOpAsync<kp::OpAlgoBase<>>(
-      { tensorA },
-      "asyncOne",
-      std::vector<char>(shader.begin(), shader.end()));
+      { tensorA }, "asyncOne", std::vector<char>(shader.begin(), shader.end()));
 
     mgr.evalOpAsync<kp::OpAlgoBase<>>(
-      { tensorB },
-      "asyncTwo",
-      std::vector<char>(shader.begin(), shader.end()));
+      { tensorB }, "asyncTwo", std::vector<char>(shader.begin(), shader.end()));
 
     mgr.evalOpAwait("asyncOne");
     mgr.evalOpAwait("asyncTwo");

test/TestLogisticRegression.cpp

@@ -39,8 +39,7 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegression)
         sqTensor->end();
         sqTensor->eval();
 
-        std::shared_ptr<kp::Sequence> sq =
-          mgr.createManagedSequence().lock();
+        std::shared_ptr<kp::Sequence> sq = mgr.createManagedSequence().lock();
 
         // Record op algo base
         sq->begin();
@@ -123,8 +122,7 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegressionManualCopy)
         sqTensor->end();
         sqTensor->eval();
 
-        std::shared_ptr<kp::Sequence> sq =
-          mgr.createManagedSequence().lock();
+        std::shared_ptr<kp::Sequence> sq = mgr.createManagedSequence().lock();
 
         // Record op algo base
         sq->begin();

test/TestMultipleAlgoExecutions.cpp

@@ -58,11 +58,9 @@ TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords)
           pa[index] = pa[index] + 1;
       })");
 
-    std::shared_ptr<kp::Sequence> sqTensor = 
-      mgr.createManagedSequence().lock();
+    std::shared_ptr<kp::Sequence> sqTensor = mgr.createManagedSequence().lock();
 
-    std::shared_ptr<kp::Sequence> sq = 
-      mgr.createManagedSequence().lock();
+    std::shared_ptr<kp::Sequence> sq = mgr.createManagedSequence().lock();
 
     // First create the tensor in a separate sequence
     sqTensor->begin();