Initial checkpoint with reasonable workflow

src/include/kompute/operations/OpBase.hpp

@@ -3,6 +3,7 @@
 #include "kompute/Core.hpp"
 
 #include "kompute/Tensor.hpp"
+#include "kompute/Algorithm.hpp"
 
 namespace kp {
 
@@ -17,10 +18,6 @@ namespace kp {
 class OpBase
 {
   public:
-    /**
-     *  Base constructor, should not be used unless explicitly intended.
-     */
-    OpBase() { KP_LOG_DEBUG("Compute OpBase base constructor"); }
 
     /**
      * Default constructor with parameters that provides the bare minimum
@@ -32,17 +29,13 @@ class OpBase
      * @param commandBuffer Vulkan Command Buffer to record commands into
      * @param tensors Tensors that are to be used in this operation
      */
-    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)
+    OpBase(std::vector<std::shared_ptr<Tensor>>& tensors,
+            std::shared_ptr<Algorithm> algorithm)
     {
         KP_LOG_DEBUG("Compute OpBase constructor with params");
-
-        this->mPhysicalDevice = physicalDevice;
-        this->mDevice = device;
-        this->mCommandBuffer = commandBuffer;
         this->mTensors = tensors;
+        this->mAlgorithm = algorithm;
+        this->mIsInit = false;
     }
 
     /**
@@ -53,37 +46,89 @@ class OpBase
     virtual ~OpBase()
     {
         KP_LOG_DEBUG("Kompute OpBase destructor started");
+        this->destroy();
+    }
 
-        if (!this->mDevice) {
-            KP_LOG_WARN("Kompute OpBase destructor called with empty device");
-            return;
-        }
+    virtual std::shared_ptr<kp::Algorithm> algorithm() {
+        return this->mAlgorithm;
+    }
 
-        if (this->mFreeTensors) {
-            KP_LOG_DEBUG("Kompute OpBase freeing tensors");
-            for (std::shared_ptr<Tensor> tensor : this->mTensors) {
-                if (tensor && tensor->isInit()) {
-                    tensor->freeMemoryDestroyGPUResources();
-                } else {
-                    KP_LOG_WARN("Kompute OpBase expected to free "
-                                  "tensor but has already been freed.");
-                }
-            }
-        }
+    virtual std::vector<std::shared_ptr<kp::Tensor>> tensors() {
+        return this->mTensors;
+    }
+
+    virtual bool isInit() {
+        return this->mIsInit;
     }
 
     /**
      * The init function is responsible for setting up all the resources and
      * should be called after the Operation has been created.
      */
-    virtual void init() = 0;
+    // TODO: Potentially remove physicalDevice in favour of memoryProperties (for tensor)
+    virtual void init(
+            std::shared_ptr<vk::PhysicalDevice> physicalDevice,
+            std::shared_ptr<vk::Device> device) {
+
+        if (this->mTensors.size() < 1) {
+            throw std::runtime_error("Kompute OpBase init called with 0 tensors");
+        }
+
+        if (this->mManagesTensors) {
+            for (std::shared_ptr<Tensor> tensor : this->mTensors) {
+                if (tensor->isInit()) {
+                    // TODO: Evaluate whether throwing runtime error or just writing error log
+                    throw std::runtime_error(
+                      "Kompute OpTensorCreate: Tensor has already been initialized");
+                }
+                else {
+                    tensor->init(physicalDevice, device);
+                }
+            }
+        }
+
+        if (this->mManagesAlgorithm) {
+            this->mAlgorithm->init(device, this->mTensors);
+        }
+    }
+
+    virtual void destroy() {
+        if (!this->mIsInit) {
+            KP_LOG_WARN("Kompute OpBase destroy called but not initialised");
+        }
+
+        if (this->mManagesTensors) {
+            for (const std::shared_ptr<Tensor>& tensor : this->mTensors) {
+                if (!tensor->isInit()) {
+                    KP_LOG_WARN("Kompute OpBase attempted to free managed tensor "
+                                 "but tensor is not initialised");
+                } else {
+                    KP_LOG_DEBUG("Kompute OpBase freeing tensor");
+                    tensor->freeMemoryDestroyGPUResources();
+                }
+            }
+            this->mTensors.clear();
+        }
+
+        if (this->mManagesAlgorithm) {
+            if (this->mAlgorithm && this->mAlgorithm->isInit()) {
+                KP_LOG_DEBUG("Kompute OpBase freeing tensor");
+                this->mAlgorithm->freeMemoryDestroyGPUResources();
+            } else {
+                KP_LOG_WARN("Kompute OpBase attempted to free managed algorithm"
+                             "but algorithm is not initialised");
+            }
+        }
+
+        this->mIsInit = false;
+    }
 
     /**
      * The record function is intended to only send a record command or run
      * commands that are expected to record operations that are to be submitted
      * as a batch into the GPU.
      */
-    virtual void record() = 0;
+    virtual void record(std::shared_ptr<vk::CommandBuffer> commandBuffer) = 0;
 
     /**
      * Pre eval is called before the Sequence has called eval and submitted the commands to
@@ -106,19 +151,14 @@ class OpBase
     virtual void postEval() = 0;
 
   protected:
-    // -------------- NEVER OWNED RESOURCES
-    std::shared_ptr<vk::PhysicalDevice>
-      mPhysicalDevice;                   ///< Vulkan Physical Device
-    std::shared_ptr<vk::Device> mDevice; ///< Vulkan Logical Device
-    std::shared_ptr<vk::CommandBuffer>
-      mCommandBuffer; ///< Vulkan Command Buffer
-
     // -------------- OPTIONALLY OWNED RESOURCES
-    std::vector<std::shared_ptr<Tensor>>
-      mTensors; ///< Tensors referenced by operation that can be managed
-                ///< optionally by operation
-    bool mFreeTensors = false; ///< Explicit boolean that specifies whether the
-                               ///< tensors are freed (if they are managed)
+    std::vector<std::shared_ptr<Tensor>> mTensors; 
+    bool mManagesTensors = false;
+    std::shared_ptr<kp::Algorithm> mAlgorithm;
+    bool mManagesAlgorithm = false;
+
+    // -------------- ALWAYS OWNED RESOURCES
+    bool mIsInit;
 };
 
 } // End namespace kp