From 7679070274d417063f479130d05d2713073bd522 Mon Sep 17 00:00:00 2001
From: Alejandro Saucedo <axsauze@gmail.com>
Date: Sun, 18 Oct 2020 16:04:52 +0100
Subject: [PATCH] Updated tests to use new constraints on unique default
 operations

---
 test/TestAsyncOperations.cpp        |  31 +++++---
 test/TestLogisticRegression.cpp     | 108 ++++++++++++++--------------
 test/TestMultipleAlgoExecutions.cpp |  61 ++++++++--------
 3 files changed, 103 insertions(+), 97 deletions(-)

diff --git a/test/TestAsyncOperations.cpp b/test/TestAsyncOperations.cpp
index 5c8612fc3..896f32b2a 100644
--- a/test/TestAsyncOperations.cpp
+++ b/test/TestAsyncOperations.cpp
@@ -142,23 +142,32 @@ TEST(TestAsyncOperations, TestManagerAsyncExecution)
     std::vector<float> data(size, 0.0);
     std::vector<float> resultAsync(size, 100000000);
 
-    kp::Manager mgrAsync(0);
+    kp::Manager mgr;
 
-    std::vector<std::shared_ptr<kp::Tensor>> inputsAsyncB;
+    std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(data) };
+    std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(data) };
 
-    inputsAsyncB.push_back(std::make_shared<kp::Tensor>(kp::Tensor(data)));
+    mgr.createManagedSequence("asyncOne");
+    mgr.createManagedSequence("asyncTwo");
 
-    mgrAsync.evalOpAsyncDefault<kp::OpTensorCreate>(inputsAsyncB);
-    mgrAsync.evalOpAwaitDefault();
+    mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
 
-    mgrAsync.evalOpAsyncDefault<kp::OpAlgoBase<>>(
-      { inputsAsyncB[0] },
+    mgr.evalOpAsync<kp::OpAlgoBase<>>(
+      { tensorA },
+      "asyncOne",
       std::vector<char>(shader.begin(), shader.end()));
 
-    mgrAsync.evalOpAwaitDefault();
+    mgr.evalOpAsync<kp::OpAlgoBase<>>(
+      { tensorB },
+      "asyncTwo",
+      std::vector<char>(shader.begin(), shader.end()));
 
-    mgrAsync.evalOpAsyncDefault<kp::OpTensorSyncLocal>({ inputsAsyncB });
-    mgrAsync.evalOpAwaitDefault();
+    mgr.evalOpAwait("asyncOne");
+    mgr.evalOpAwait("asyncTwo");
 
-    EXPECT_EQ(inputsAsyncB[0]->data(), resultAsync);
+    mgr.evalOpAsyncDefault<kp::OpTensorSyncLocal>({ tensorA, tensorB });
+    mgr.evalOpAwaitDefault();
+
+    EXPECT_EQ(tensorA->data(), resultAsync);
+    EXPECT_EQ(tensorB->data(), resultAsync);
 }
diff --git a/test/TestLogisticRegression.cpp b/test/TestLogisticRegression.cpp
index c87ef8e1f..5043a5a36 100644
--- a/test/TestLogisticRegression.cpp
+++ b/test/TestLogisticRegression.cpp
@@ -31,38 +31,38 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegression)
     {
         kp::Manager mgr;
 
-        if (std::shared_ptr<kp::Sequence> sq =
-              mgr.getOrCreateManagedSequence("createTensors").lock()) {
+        std::shared_ptr<kp::Sequence> sqTensor =
+          mgr.createManagedSequence().lock();
 
-            sq->begin();
+        sqTensor->begin();
+        sqTensor->record<kp::OpTensorCreate>(params);
+        sqTensor->end();
+        sqTensor->eval();
 
-            sq->record<kp::OpTensorCreate>(params);
+        std::shared_ptr<kp::Sequence> sq =
+          mgr.createManagedSequence().lock();
+
+        // Record op algo base
+        sq->begin();
+
+        sq->record<kp::OpTensorSyncDevice>({ wIn, bIn });
+
+        sq->record<kp::OpAlgoBase<>>(
+          params, "test/shaders/glsl/test_logistic_regression.comp");
+
+        sq->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
+
+        sq->end();
+
+        // Iterate across all expected iterations
+        for (size_t i = 0; i < ITERATIONS; i++) {
 
-            sq->end();
             sq->eval();
 
-            // Record op algo base
-            sq->begin();
-
-            sq->record<kp::OpTensorSyncDevice>({ wIn, bIn });
-
-            sq->record<kp::OpAlgoBase<>>(
-              params, "test/shaders/glsl/test_logistic_regression.comp");
-
-            sq->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
-
-            sq->end();
-
-            // Iterate across all expected iterations
-            for (size_t i = 0; i < ITERATIONS; i++) {
-
-                sq->eval();
-
-                for (size_t j = 0; j < bOut->size(); j++) {
-                    wIn->data()[0] -= learningRate * wOutI->data()[j];
-                    wIn->data()[1] -= learningRate * wOutJ->data()[j];
-                    bIn->data()[0] -= learningRate * bOut->data()[j];
-                }
+            for (size_t j = 0; j < bOut->size(); j++) {
+                wIn->data()[0] -= learningRate * wOutI->data()[j];
+                wIn->data()[1] -= learningRate * wOutJ->data()[j];
+                bIn->data()[0] -= learningRate * bOut->data()[j];
             }
         }
     }
@@ -115,39 +115,39 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegressionManualCopy)
     {
         kp::Manager mgr;
 
-        if (std::shared_ptr<kp::Sequence> sq =
-              mgr.getOrCreateManagedSequence("createTensors").lock()) {
+        std::shared_ptr<kp::Sequence> sqTensor =
+          mgr.createManagedSequence().lock();
 
-            sq->begin();
+        sqTensor->begin();
+        sqTensor->record<kp::OpTensorCreate>(params);
+        sqTensor->end();
+        sqTensor->eval();
 
-            sq->record<kp::OpTensorCreate>(params);
+        std::shared_ptr<kp::Sequence> sq =
+          mgr.createManagedSequence().lock();
+
+        // Record op algo base
+        sq->begin();
+
+        sq->record<kp::OpAlgoBase<>>(
+          params, "test/shaders/glsl/test_logistic_regression.comp");
+
+        sq->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
+
+        sq->end();
+
+        // Iterate across all expected iterations
+        for (size_t i = 0; i < ITERATIONS; i++) {
 
-            sq->end();
             sq->eval();
 
-            // Record op algo base
-            sq->begin();
-
-            sq->record<kp::OpAlgoBase<>>(
-              params, "test/shaders/glsl/test_logistic_regression.comp");
-
-            sq->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
-
-            sq->end();
-
-            // Iterate across all expected iterations
-            for (size_t i = 0; i < ITERATIONS; i++) {
-
-                sq->eval();
-
-                for (size_t j = 0; j < bOut->size(); j++) {
-                    wIn->data()[0] -= learningRate * wOutI->data()[j];
-                    wIn->data()[1] -= learningRate * wOutJ->data()[j];
-                    bIn->data()[0] -= learningRate * bOut->data()[j];
-                }
-                wIn->mapDataIntoHostMemory();
-                bIn->mapDataIntoHostMemory();
+            for (size_t j = 0; j < bOut->size(); j++) {
+                wIn->data()[0] -= learningRate * wOutI->data()[j];
+                wIn->data()[1] -= learningRate * wOutJ->data()[j];
+                bIn->data()[0] -= learningRate * bOut->data()[j];
             }
+            wIn->mapDataIntoHostMemory();
+            bIn->mapDataIntoHostMemory();
         }
     }
 
diff --git a/test/TestMultipleAlgoExecutions.cpp b/test/TestMultipleAlgoExecutions.cpp
index 1b59d3516..45b672919 100644
--- a/test/TestMultipleAlgoExecutions.cpp
+++ b/test/TestMultipleAlgoExecutions.cpp
@@ -45,7 +45,6 @@ TEST(TestMultipleAlgoExecutions, SingleSequenceRecord)
 
 TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords)
 {
-
     kp::Manager mgr;
 
     std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
@@ -59,43 +58,41 @@ TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords)
           pa[index] = pa[index] + 1;
       })");
 
-    std::weak_ptr<kp::Sequence> sqWeakPtr =
-      mgr.getOrCreateManagedSequence("newSequence");
-    if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
-        sq->begin();
+    std::shared_ptr<kp::Sequence> sqTensor = 
+      mgr.createManagedSequence().lock();
 
-        sq->record<kp::OpTensorCreate>({ tensorA });
+    std::shared_ptr<kp::Sequence> sq = 
+      mgr.createManagedSequence().lock();
 
-        sq->record<kp::OpAlgoBase<3, 1, 1>>(
-          { tensorA }, std::vector<char>(shader.begin(), shader.end()));
+    // First create the tensor in a separate sequence
+    sqTensor->begin();
+    sqTensor->record<kp::OpTensorCreate>({ tensorA });
+    sqTensor->end();
+    sqTensor->eval();
 
-        sq->end();
-        sq->eval();
+    // Then perform the computations
+    sq->begin();
+    sq->record<kp::OpAlgoBase<3, 1, 1>>(
+      { tensorA }, std::vector<char>(shader.begin(), shader.end()));
+    sq->end();
+    sq->eval();
 
-        sq->begin();
+    sq->begin();
+    sq->record<kp::OpAlgoBase<3, 1, 1>>(
+      { tensorA }, std::vector<char>(shader.begin(), shader.end()));
+    sq->end();
+    sq->eval();
 
-        sq->record<kp::OpAlgoBase<3, 1, 1>>(
-          { tensorA }, std::vector<char>(shader.begin(), shader.end()));
+    sq->begin();
+    sq->record<kp::OpAlgoBase<3, 1, 1>>(
+      { tensorA }, std::vector<char>(shader.begin(), shader.end()));
+    sq->end();
+    sq->eval();
 
-        sq->end();
-        sq->eval();
-
-        sq->begin();
-
-        sq->record<kp::OpAlgoBase<3, 1, 1>>(
-          { tensorA }, std::vector<char>(shader.begin(), shader.end()));
-
-        sq->end();
-        sq->eval();
-
-        sq->begin();
-
-        sq->record<kp::OpTensorSyncLocal>({ tensorA });
-
-        sq->end();
-        sq->eval();
-    }
-    sqWeakPtr.reset();
+    sq->begin();
+    sq->record<kp::OpTensorSyncLocal>({ tensorA });
+    sq->end();
+    sq->eval();
 
     EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
 }