Added initial base for architecture on the proposed Kompute structure

src/Algorithm.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace kp {
+
+class Algorithm
+{
+private:
+    
+
+public:
+    Algorithm();
+    virtual ~Algorithm();
+};
+
+} // End namespace kp
+
+

src/BaseOperator.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace kp {
+
+class BaseOperator
+{
+private:
+    
+
+public:
+    BaseOperator();
+    virtual ~BaseOperator();
+};
+
+} // End namespace kp
+

src/Manager.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace kp {
+
+class Manager
+{
+private:
+    
+
+public:
+    Manager();
+    virtual ~Manager();
+};
+
+} // End namespace kp
+

src/OpMult.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#import "BaseOperator.hpp"
+
+namespace kp {
+
+class OpMult: BaseOperator
+{
+private:
+    
+
+public:
+    OpMult();
+    virtual ~OpMult();
+};
+
+} // End namespace kp

src/Parameter.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace kp {
+
+class Parameter
+{
+private:
+    
+
+public:
+    Parameter();
+    virtual ~Parameter();
+};
+
+} // End namespace kp

src/Sequence.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace kp {
+
+class Sequence
+{
+private:
+    
+
+public:
+    Sequence();
+    virtual ~Sequence();
+};
+
+} // End namespace kp
+

src/Tensor.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace kp {
+
+class Tensor
+{
+private:
+    
+
+public:
+    Tensor();
+    virtual ~Tensor();
+};
+
+} // End namespace kp
+

src/main.cpp

@@ -13,8 +13,9 @@
 #include <string>
 #include <vector>
 
-#include "spdlog/fmt/bundled/ranges.h"
 #include <spdlog/spdlog.h>
+// ranges.h must come after spdlog.h
+#include <spdlog/fmt/bundled/ranges.h>
 
 #include <vulkan/vulkan.h>
 #include <vulkan/vulkan.hpp>
@@ -230,6 +231,7 @@ class VulkanCompute
 
             this->mDevice =
               this->mPhysicalDevice.createDevice(deviceCreateInfo);
+
             this->mComputeQueue =
               this->mDevice.getQueue(this->mComputeQueueFamilyIndex, 0);
         }
@@ -267,8 +269,7 @@ class VulkanCompute
                          vk::MemoryPropertyFlagBits::eHostVisible,
                          &hostBuffer,
                          &hostMemory,
-                         bufferSize,
-                         computeInput.data());
+                         bufferSize);
 
             createBuffer(vk::BufferUsageFlagBits::eStorageBuffer |
                            vk::BufferUsageFlagBits::eTransferSrc |
@@ -513,23 +514,6 @@ class VulkanCompute
                   bufferMemoryBarrier,
                   nullptr);
 
-                // // Reset the host buffer to -1 to ensure that data is being
-                // copied this->mCommandBuffer.fillBuffer(hostBuffer, 0,
-                // bufferSize, -1);
-                // // Barrier to ensure that buffer is reset before its copied
-                // bufferMemoryBarrier.srcAccessMask =
-                //   vk::AccessFlagBits::eTransferWrite;
-                // bufferMemoryBarrier.dstAccessMask =
-                //   vk::AccessFlagBits::eTransferWrite;
-                // bufferMemoryBarrier.buffer = hostBuffer;
-                // this->mCommandBuffer.pipelineBarrier(
-                //   vk::PipelineStageFlagBits::eTransfer,
-                //   vk::PipelineStageFlagBits::eTransfer,
-                //   vk::DependencyFlags(),
-                //   nullptr,
-                //   bufferMemoryBarrier,
-                //   nullptr);
-
                 // Read back to host visible buffer
                 vk::BufferCopy copyRegion(0, 0, bufferSize);
                 this->mCommandBuffer.copyBuffer(