Added initial base for architecture on the proposed Kompute structure

README.md

@@ -1,3 +1,82 @@
-# Vulkan Compute
+# Vulkan Kompute
+
+## Principles
+
+* Non-vulkan naming convention to disambiguate Vulkan vs Kompute components
+* TODO
+
+## Getting Started
+
+Use default equations
+
+```c++
+int main() {
+    kp::Manager kManager(); // Chooses device 0 
+
+    kp::Tensor inputOne = kManager.eval<kp::OpCreateTensor>({0, 1, 2, 3}); // Mounts to device and binds to 0
+    kp::Tensor inputTwo = kManager.eval<kp::OpCreateTensor>({0, 1, 2, 3}); // Mounts to device and binds to 1
+
+    kp::Tensor output = kManager.eval<kp::OpMult>(inputOne, inputTwo);
+
+    std::cout << output << std::endl;
+}
+```
+
+Create your own operation
+
+```c++
+class CustomOp : kp::BaseOperator {
+    CusomOp() {
+        this->mAlgorithm = kp::Algorithm("path/to/your/shader.compute.spv")
+    }
+
+    kp::Tensor init(kp::Tensor* rhs, kp::Tensor* lhs, kp::Tensor* result) override {
+        this->appendParameter(kp::Parameter(rhs)); // Binding 0
+        this->appendParameter(kp::Parameter(lhs)); // Binding 1
+        this->appendParameter(kp::Parameter(result)); // Binding 2
+    }
+}
+
+int main() {
+    kp::Manager kManager(); // Chooses device 0 
+
+    kp::Tensor inputOne; 
+    kManager.eval<kp::OpCreateTensor>(&inputOne, {0, 1, 2, 3}); // Mounts to device and binds to 0
+
+    kp::Tensor inputTwo;
+    kManager.eval<kp::OpCreateTensor>(&inputTwo, {0, 1, 2, 3}); // Mounts to device and binds to 1
+
+    kp::Tensor output;
+    kManager.eval<kp::CustomOp>(&inputOne, &inputTwo, &output);
+
+    std::cout << output << std::endl;
+}
+```
+
+Use equations to group operations on memory and execution step
+
+```c++
+int main() {
+    kp::Manager kManager(); // Chooses device 0 
+
+    kp::Sequence sq = kManager().createSequence<kp::Sequence>();
+
+    kp::Tensor inputOne; 
+    sq.record<kp::OpCreateTensor>(&inputOne, {0, 1, 2, 3}); // Mounts to device and binds to 0
+
+    kp::Tensor inputTwo;
+    sq.record<kp::OpCreateTensor>(&inputTwo, {0, 1, 2, 3}); // Mounts to device and binds to 1
+
+    kp::Tensor output;
+    sq.record<kp::OpMult>(&inputOne, &inputTwo, &output);
+
+    sq.eval();
+
+    std::cout << output << std::endl;
+}
+```
+
+
+## Development
 
 Follows Mozilla C++ Style Guide https://www-archive.mozilla.org/hacking/mozilla-style-guide.html

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(