Removed OpCreateTensor in favour of manager memory ownership

src/include/kompute/Manager.hpp

@@ -1,13 +1,12 @@
 #pragma once
 
 #include <unordered_map>
+#include <set>
 
 #include "kompute/Core.hpp"
 
 #include "kompute/Sequence.hpp"
 
-#include "kompute/operations/OpTensorCreate.hpp"
-
 #define KP_DEFAULT_SESSION "DEFAULT"
 
 namespace kp {
@@ -231,8 +230,8 @@ class Manager
     /**
      * Function that simplifies the common workflow of tensor creation and
      * initialization. It will take the constructor parameters for a Tensor
-     * and will will us it to create a new Tensor and then create it using
-     * the OpCreateTensor command.
+     * and will will us it to create a new Tensor and then create it. The
+     * tensor memory will then be managed and owned by the manager.
      *
      * @param data The data to initialize the tensor with
      * @param tensorType The type of tensor to initialize
@@ -242,17 +241,49 @@ class Manager
       const std::vector<float>& data,
       Tensor::TensorTypes tensorType = Tensor::TensorTypes::eDevice)
     {
-        SPDLOG_DEBUG("Kompute Manager createInitTensor triggered");
+        SPDLOG_DEBUG("Kompute Manager buildTensor triggered");
 
         SPDLOG_DEBUG("Kompute Manager creating new tensor shared ptr");
         std::shared_ptr<Tensor> tensor =
           std::make_shared<Tensor>(kp::Tensor(data, tensorType));
 
-        this->evalOpDefault<OpTensorCreate>({ tensor });
+        tensor->init(this->mPhysicalDevice, this->mDevice);
+        if (tensor->tensorType() != Tensor::TensorTypes::eStorage) {
+            tensor->mapDataIntoHostMemory();
+        }
+        this->mManagedTensors.insert(tensor);
 
         return tensor;
     }
 
+    /**
+     * Function that simplifies the common workflow of tensor initialisation. It will take the constructor parameters for a Tensor and will will us it to create a new Tensor. The tensor memory will then be managed and owned by the manager.
+     *
+     * @param data The data to initialize the tensor with
+     * @param tensorType The type of tensor to initialize
+     * @returns Initialized Tensor with memory Syncd to GPU device
+     */
+    void rebuildTensors(std::vector<std::shared_ptr<kp::Tensor>> tensors)
+    {
+        SPDLOG_DEBUG("Kompute Manager rebuildTensors triggered");
+        for (std::shared_ptr<Tensor> tensor : tensors) {
+
+            if (tensor->isInit()) {
+                tensor->freeMemoryDestroyGPUResources();
+            }
+
+            tensor->init(this->mPhysicalDevice, this->mDevice);
+            if (tensor->tensorType() != Tensor::TensorTypes::eStorage) {
+                tensor->mapDataIntoHostMemory();
+            }
+
+            std::set<std::shared_ptr<Tensor>>::iterator it = this->mManagedTensors.find(tensor);
+            if (it == this->mManagedTensors.end()) {
+                this->mManagedTensors.insert(tensor);
+            }
+        }
+    }
+
   private:
     // -------------- OPTIONALLY OWNED RESOURCES
     std::shared_ptr<vk::Instance> mInstance = nullptr;
@@ -263,6 +294,8 @@ class Manager
     bool mFreeDevice = false;
 
     // -------------- ALWAYS OWNED RESOURCES
+    std::set<std::shared_ptr<Tensor>> mManagedTensors;
+
     std::unordered_map<std::string, std::shared_ptr<Sequence>>
       mManagedSequences;
 

src/include/kompute/operations/OpBase.hpp

@@ -31,13 +31,11 @@ class OpBase
      * @param device Vulkan logical device for passing to Algorithm
      * @param commandBuffer Vulkan Command Buffer to record commands into
      * @param tensors Tensors that are to be used in this operation
-     * @param freeTensors Whether operation manages the memory of the Tensors
      */
     OpBase(std::shared_ptr<vk::PhysicalDevice> physicalDevice,
            std::shared_ptr<vk::Device> device,
            std::shared_ptr<vk::CommandBuffer> commandBuffer,
-           std::vector<std::shared_ptr<Tensor>>& tensors,
-           bool freeTensors)
+           std::vector<std::shared_ptr<Tensor>>& tensors)
     {
         SPDLOG_DEBUG("Compute OpBase constructor with params");
 
@@ -45,14 +43,12 @@ class OpBase
         this->mDevice = device;
         this->mCommandBuffer = commandBuffer;
         this->mTensors = tensors;
-        this->mFreeTensors = freeTensors;
     }
 
     /**
      * Default destructor for OpBase class. This OpBase destructor class should
      * always be called to destroy and free owned resources unless it is
-     * intended to destroy the resources in the parent class. This can be done
-     * by passing the mFreeTensors=false.
+     * intended to destroy the resources in the parent class.
      */
     virtual ~OpBase()
     {

src/include/kompute/operations/OpTensorCreate.hpp

@@ -1,74 +0,0 @@
-#pragma once
-
-#include "kompute/Core.hpp"
-
-#include "kompute/Tensor.hpp"
-
-#include "kompute/operations/OpBase.hpp"
-
-namespace kp {
-
-/**
-    Operation that creates tensor and manages the memory of the components
-   created
-*/
-class OpTensorCreate : public OpBase
-{
-  public:
-    OpTensorCreate();
-
-    /**
-     * Default constructor with parameters that provides the bare minimum
-     * requirements for the operations to be able to create and manage their
-     * sub-components.
-     *
-     * @param physicalDevice Vulkan physical device used to find device queues
-     * @param device Vulkan logical device for passing to Algorithm
-     * @param commandBuffer Vulkan Command Buffer to record commands into
-     * @param tensors Tensors that will be used to create in operation.
-     * @param freeTensors Whether operation manages the memory of the Tensors
-     */
-    OpTensorCreate(std::shared_ptr<vk::PhysicalDevice> physicalDevice,
-                   std::shared_ptr<vk::Device> device,
-                   std::shared_ptr<vk::CommandBuffer> commandBuffer,
-                   std::vector<std::shared_ptr<Tensor>> tensors);
-
-    /**
-     * Default destructor which in this case expects the parent class to free
-     * the tensors
-     */
-    ~OpTensorCreate() override;
-
-    /**
-     * In charge of initialising the primary Tensor as well as the staging
-     * tensor as required. It will only initialise a staging tensor if the
-     * Primary tensor is of type Device. For staging tensors it performs a 
-     * mapDataIntoHostMemory which would perform immediately as opposed to 
-     * on sequence eval/submission.
-     */
-    void init() override;
-
-    /**
-     * Record runs the core actions to create the tensors. For device tensors
-     * it records a copyCommand to move the data from the staging tensor to the 
-     * device tensor. The mapping for staging tensors happens in the init function
-     * not in the record function.
-     */
-    void record() override;
-
-    /**
-     * Does not perform any preEval commands.
-     */
-    virtual void preEval() override;
-
-    /**
-     * Performs a copy back into the main tensor to ensure that the data
-     * contained is the one that is now being stored in the GPU.
-     */
-    virtual void postEval() override;
-
-
-  private:
-};
-
-} // End namespace kp