Added tests to validate opcreatetensor components

src/Tensor.cpp

@@ -85,7 +85,7 @@ Tensor::tensorType()
 bool
 Tensor::isInit()
 {
-    return this->mIsInit;
+    return this->mIsInit && this->mBuffer && this->mMemory;
 }
 
 void
@@ -352,6 +352,7 @@ Tensor::freeMemoryDestroyGPUResources()
         } else {
             SPDLOG_DEBUG("Kompose Tensor destroying buffer");
             this->mDevice->destroy(*this->mBuffer);
+            this->mBuffer = nullptr;
         }
     }
 
@@ -362,6 +363,7 @@ Tensor::freeMemoryDestroyGPUResources()
         } else {
             SPDLOG_DEBUG("Kompose Tensor freeing memory");
             this->mDevice->freeMemory(*this->mMemory);
+            this->mDevice = nullptr;
         }
     }
 

test/TestMultipleAlgoExecutions.cpp

@@ -0,0 +1,167 @@
+
+#include "catch2/catch.hpp"
+
+#include "kompute/Kompute.hpp"
+
+#include <fmt/ranges.h>
+
+TEST_CASE("test_multiple_algo_exec_single_cmd_buf_record") {
+
+    kp::Manager mgr;
+
+    std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 })};
+
+    std::string shader(
+        "#version 450\n"
+        "layout (local_size_x = 1) in;\n"
+        "layout(set = 0, binding = 0) buffer a { uint pa[]; };\n"
+        "void main() {\n"
+        "    uint index = gl_GlobalInvocationID.x;\n"
+        "    pa[index] = pa[index] + 1;\n"
+        "}\n"
+    );
+
+    std::weak_ptr<kp::Sequence> sqWeakPtr = mgr.getOrCreateManagedSequence("newSequence");
+    if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
+        sq->begin();
+
+        sq->record<kp::OpCreateTensor>({ tensorA });
+
+        sq->record<kp::OpAlgoBase<3, 1, 1>>(
+                { tensorA }, 
+                false, // Whether to copy output from device
+                std::vector<char>(shader.begin(), shader.end()));
+        sq->record<kp::OpAlgoBase<3, 1, 1>>(
+                { tensorA }, 
+                false, // Whether to copy output from device
+                std::vector<char>(shader.begin(), shader.end()));
+        sq->record<kp::OpAlgoBase<3, 1, 1>>(
+                { tensorA }, 
+                true, // Whether to copy output from device
+                std::vector<char>(shader.begin(), shader.end()));
+
+        sq->end();
+        sq->eval();
+    }
+    sqWeakPtr.reset();
+
+    REQUIRE(tensorA->data() == std::vector<uint32_t>{3, 3, 3});
+}
+
+TEST_CASE("test_multiple_algo_exec_multiple_record") {
+
+    kp::Manager mgr;
+
+    std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 })};
+
+    std::string shader(
+        "#version 450\n"
+        "layout (local_size_x = 1) in;\n"
+        "layout(set = 0, binding = 0) buffer a { uint pa[]; };\n"
+        "void main() {\n"
+        "    uint index = gl_GlobalInvocationID.x;\n"
+        "    pa[index] = pa[index] + 1;\n"
+        "}\n"
+    );
+
+    std::weak_ptr<kp::Sequence> sqWeakPtr = mgr.getOrCreateManagedSequence("newSequence");
+    if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
+        sq->begin();
+
+        sq->record<kp::OpCreateTensor>({ tensorA });
+
+        sq->record<kp::OpAlgoBase<3, 1, 1>>(
+                { tensorA }, 
+                false, // Whether to copy output from device
+                std::vector<char>(shader.begin(), shader.end()));
+
+        sq->end();
+        sq->eval();
+
+        sq->begin();
+
+        sq->record<kp::OpAlgoBase<3, 1, 1>>(
+                { tensorA }, 
+                false, // Whether to copy output from device
+                std::vector<char>(shader.begin(), shader.end()));
+
+        sq->end();
+        sq->eval();
+
+        sq->begin();
+
+        sq->record<kp::OpAlgoBase<3, 1, 1>>(
+                { tensorA }, 
+                true, // Whether to copy output from device
+                std::vector<char>(shader.begin(), shader.end()));
+
+        sq->end();
+        sq->eval();
+    }
+    sqWeakPtr.reset();
+
+    REQUIRE(tensorA->data() == std::vector<uint32_t>{3, 3, 3});
+
+}
+
+TEST_CASE("test_multiple_algo_exec_multiple_sequence") {
+
+    kp::Manager mgr;
+
+    std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 })};
+
+    std::string shader(
+        "#version 450\n"
+        "layout (local_size_x = 1) in;\n"
+        "layout(set = 0, binding = 0) buffer a { uint pa[]; };\n"
+        "void main() {\n"
+        "    uint index = gl_GlobalInvocationID.x;\n"
+        "    pa[index] = pa[index] + 1;\n"
+        "}\n"
+    );
+
+    std::weak_ptr<kp::Sequence> sqWeakPtr = mgr.getOrCreateManagedSequence("newSequence");
+    if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
+        sq->begin();
+
+        sq->record<kp::OpCreateTensor>({ tensorA });
+
+        sq->record<kp::OpAlgoBase<3, 1, 1>>(
+                { tensorA }, 
+                true, // Whether to copy output from device
+                std::vector<char>(shader.begin(), shader.end()));
+
+        sq->end();
+        sq->eval();
+    }
+
+    std::weak_ptr<kp::Sequence> sqWeakPtr2 = mgr.getOrCreateManagedSequence("newSequence2");
+    if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
+        sq->begin();
+
+        sq->record<kp::OpAlgoBase<3, 1, 1>>(
+                { tensorA }, 
+                true, // Whether to copy output from device
+                std::vector<char>(shader.begin(), shader.end()));
+
+        sq->end();
+        sq->eval();
+    }
+
+
+    std::weak_ptr<kp::Sequence> sqWeakPtr3 = mgr.getOrCreateManagedSequence("newSequence3");
+    if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
+        sq->begin();
+
+        sq->record<kp::OpAlgoBase<3, 1, 1>>(
+                { tensorA }, 
+                true, // Whether to copy output from device
+                std::vector<char>(shader.begin(), shader.end()));
+
+        sq->end();
+        sq->eval();
+    }
+
+    REQUIRE(tensorA->data() == std::vector<uint32_t>{3, 3, 3});
+}
+

test/TestOpCreateTensor.cpp

@@ -0,0 +1,113 @@
+
+#include "catch2/catch.hpp"
+
+#include "kompute/Kompute.hpp"
+
+#include <fmt/ranges.h>
+
+TEST_CASE("test_opcreatetensor_create_single_tensor") {
+
+    kp::Manager mgr;
+
+    std::vector<uint32_t> testVecA{ 9, 8, 7 };
+
+    std::shared_ptr<kp::Tensor> tensorA{new kp::Tensor(testVecA)};
+
+    mgr.evalOpDefault<kp::OpCreateTensor>({tensorA});
+
+    REQUIRE(tensorA->isInit());
+
+    REQUIRE(tensorA->data() == testVecA);
+
+    tensorA->freeMemoryDestroyGPUResources();
+    REQUIRE(!tensorA->isInit());
+}
+
+TEST_CASE("test_opcreatetensor_create_multiple_tensors_single_op") {
+
+    kp::Manager mgr;
+
+    std::vector<uint32_t> testVecA{ 9, 8, 7 };
+    std::vector<uint32_t> testVecB{ 6, 5, 4 };
+
+    std::shared_ptr<kp::Tensor> tensorA{new kp::Tensor(testVecA)};
+    std::shared_ptr<kp::Tensor> tensorB{new kp::Tensor(testVecB)};
+
+    mgr.evalOpDefault<kp::OpCreateTensor>({tensorA, tensorB});
+
+    REQUIRE(tensorA->isInit());
+    REQUIRE(tensorB->isInit());
+
+    REQUIRE(tensorA->data() == testVecA);
+    REQUIRE(tensorB->data() == testVecB);
+}
+
+TEST_CASE("test_opcreatetensor_create_multiple_tensors_multiple_op") {
+
+    kp::Manager mgr;
+
+    std::vector<uint32_t> testVecA{ 9, 8, 7 };
+    std::vector<uint32_t> testVecB{ 6, 5, 4 };
+
+    std::shared_ptr<kp::Tensor> tensorA{new kp::Tensor(testVecA)};
+    std::shared_ptr<kp::Tensor> tensorB{new kp::Tensor(testVecB)};
+
+    mgr.evalOpDefault<kp::OpCreateTensor>({tensorA});
+    mgr.evalOpDefault<kp::OpCreateTensor>({tensorB});
+
+    REQUIRE(tensorA->isInit());
+    REQUIRE(tensorB->isInit());
+
+    REQUIRE(tensorA->data() == testVecA);
+    REQUIRE(tensorB->data() == testVecB);
+}
+
+TEST_CASE("test_opcreatetensor_manage_tensor_memory_when_destroyed") {
+
+    std::vector<uint32_t> testVecA{ 9, 8, 7 };
+    std::vector<uint32_t> testVecB{ 6, 5, 4 };
+
+    std::shared_ptr<kp::Tensor> tensorA{new kp::Tensor(testVecA)};
+    std::shared_ptr<kp::Tensor> tensorB{new kp::Tensor(testVecB)};
+
+    {
+        kp::Manager mgr;
+        mgr.evalOpDefault<kp::OpCreateTensor>({tensorA});
+        mgr.evalOpDefault<kp::OpCreateTensor>({tensorB});
+
+        REQUIRE(tensorA->isInit());
+        REQUIRE(tensorB->isInit());
+
+        REQUIRE(tensorA->data() == testVecA);
+        REQUIRE(tensorB->data() == testVecB);
+    }
+
+    REQUIRE(!tensorA->isInit());
+    REQUIRE(!tensorB->isInit());
+}
+
+TEST_CASE("test_opcreatetensor_no_error_if_tensor_freed_before") {
+
+    std::vector<uint32_t> testVecA{ 9, 8, 7 };
+    std::vector<uint32_t> testVecB{ 6, 5, 4 };
+
+    std::shared_ptr<kp::Tensor> tensorA{new kp::Tensor(testVecA)};
+    std::shared_ptr<kp::Tensor> tensorB{new kp::Tensor(testVecB)};
+
+    kp::Manager mgr;
+
+    mgr.evalOpDefault<kp::OpCreateTensor>({tensorA});
+    mgr.evalOpDefault<kp::OpCreateTensor>({tensorB});
+
+    REQUIRE(tensorA->isInit());
+    REQUIRE(tensorB->isInit());
+
+    REQUIRE(tensorA->data() == testVecA);
+    REQUIRE(tensorB->data() == testVecB);
+
+    tensorA->freeMemoryDestroyGPUResources();
+    tensorB->freeMemoryDestroyGPUResources();
+    REQUIRE(!tensorA->isInit());
+    REQUIRE(!tensorB->isInit());
+}
+