From 970f502cdac8c7fefe93669365a8daff196ff56f Mon Sep 17 00:00:00 2001 From: Alejandro Saucedo Date: Sat, 15 Aug 2020 18:58:18 +0100 Subject: [PATCH] Added initial base for architecture on the proposed Kompute structure --- README.md | 81 +++++++++++++++++++++++++++++++++++++++++++- src/Algorithm.hpp | 17 ++++++++++ src/BaseOperator.hpp | 16 +++++++++ src/Manager.hpp | 16 +++++++++ src/OpMult.hpp | 17 ++++++++++ src/Parameter.hpp | 15 ++++++++ src/Sequence.hpp | 16 +++++++++ src/Tensor.hpp | 16 +++++++++ src/main.cpp | 24 +++---------- 9 files changed, 197 insertions(+), 21 deletions(-) create mode 100644 src/Algorithm.hpp create mode 100644 src/BaseOperator.hpp create mode 100644 src/Manager.hpp create mode 100644 src/OpMult.hpp create mode 100644 src/Parameter.hpp create mode 100644 src/Sequence.hpp create mode 100644 src/Tensor.hpp diff --git a/README.md b/README.md index d1e4b5367..0a5dfb504 100644 --- a/README.md +++ b/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({0, 1, 2, 3}); // Mounts to device and binds to 0 + kp::Tensor inputTwo = kManager.eval({0, 1, 2, 3}); // Mounts to device and binds to 1 + + kp::Tensor output = kManager.eval(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(&inputOne, {0, 1, 2, 3}); // Mounts to device and binds to 0 + + kp::Tensor inputTwo; + kManager.eval(&inputTwo, {0, 1, 2, 3}); // Mounts to device and binds to 1 + + kp::Tensor output; + kManager.eval(&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::Tensor inputOne; + sq.record(&inputOne, {0, 1, 2, 3}); // Mounts to device and binds to 0 + + kp::Tensor inputTwo; + sq.record(&inputTwo, {0, 1, 2, 3}); // Mounts to device and binds to 1 + + kp::Tensor output; + sq.record(&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 diff --git a/src/Algorithm.hpp b/src/Algorithm.hpp new file mode 100644 index 000000000..a340d76cb --- /dev/null +++ b/src/Algorithm.hpp @@ -0,0 +1,17 @@ +#pragma once + +namespace kp { + +class Algorithm +{ +private: + + +public: + Algorithm(); + virtual ~Algorithm(); +}; + +} // End namespace kp + + diff --git a/src/BaseOperator.hpp b/src/BaseOperator.hpp new file mode 100644 index 000000000..2a87c5519 --- /dev/null +++ b/src/BaseOperator.hpp @@ -0,0 +1,16 @@ +#pragma once + +namespace kp { + +class BaseOperator +{ +private: + + +public: + BaseOperator(); + virtual ~BaseOperator(); +}; + +} // End namespace kp + diff --git a/src/Manager.hpp b/src/Manager.hpp new file mode 100644 index 000000000..d34dd40b4 --- /dev/null +++ b/src/Manager.hpp @@ -0,0 +1,16 @@ +#pragma once + +namespace kp { + +class Manager +{ +private: + + +public: + Manager(); + virtual ~Manager(); +}; + +} // End namespace kp + diff --git a/src/OpMult.hpp b/src/OpMult.hpp new file mode 100644 index 000000000..3dbcff5b7 --- /dev/null +++ b/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 diff --git a/src/Parameter.hpp b/src/Parameter.hpp new file mode 100644 index 000000000..ff1189682 --- /dev/null +++ b/src/Parameter.hpp @@ -0,0 +1,15 @@ +#pragma once + +namespace kp { + +class Parameter +{ +private: + + +public: + Parameter(); + virtual ~Parameter(); +}; + +} // End namespace kp diff --git a/src/Sequence.hpp b/src/Sequence.hpp new file mode 100644 index 000000000..3586451e3 --- /dev/null +++ b/src/Sequence.hpp @@ -0,0 +1,16 @@ +#pragma once + +namespace kp { + +class Sequence +{ +private: + + +public: + Sequence(); + virtual ~Sequence(); +}; + +} // End namespace kp + diff --git a/src/Tensor.hpp b/src/Tensor.hpp new file mode 100644 index 000000000..b6880b913 --- /dev/null +++ b/src/Tensor.hpp @@ -0,0 +1,16 @@ +#pragma once + +namespace kp { + +class Tensor +{ +private: + + +public: + Tensor(); + virtual ~Tensor(); +}; + +} // End namespace kp + diff --git a/src/main.cpp b/src/main.cpp index df3d0e0be..0c3274269 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -13,8 +13,9 @@ #include #include -#include "spdlog/fmt/bundled/ranges.h" #include +// ranges.h must come after spdlog.h +#include #include #include @@ -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(