MTLComputeGPU.hpp

Go to the documentation of this file.

#include "MTLComputeGlobals.hpp"
#include "MTLComputeBuffer.hpp"
#include "MTLComputeKernel.hpp"
#include "MTLComputeCommandManager.hpp"
#include "MTLComputeTexture.hpp"
 
#pragma once
 
#ifdef USING_MULTIPLE_CLASSES
#error "Cannot include both MTLCompute.hpp and MTLComputeGPU.hpp"
#endif
 
#define USING_SINGLE_CLASS
 
namespace MTLCompute {
 
    template <typename T>
    class GPU {
 
        private:
            MTL::Device *gpu; 
            MTLCompute::Kernel kernel; 
            bool kernelLoaded = false; 
            MTLCompute::CommandManager<T> commandManager; 
 
            void checkloaded() {
                if (!this->kernelLoaded) {
                    throw std::runtime_error("MTLCompute error: Kernel not loaded");
                }
            }
 
        public:
 
            GPU(std::string libname, std::string functionName) : kernel(), commandManager() {
                this->gpu = MTL::CreateSystemDefaultDevice();
                this->kernel = MTLCompute::Kernel(this->gpu, libname+".metallib");
                this->kernel.useFunction(functionName);
                this->commandManager = MTLCompute::CommandManager<T>(this->gpu, &this->kernel);
                this->kernelLoaded = true;
            }
 
            GPU() : kernel(), commandManager() {
                this->gpu = MTL::CreateSystemDefaultDevice();
            };
 
            ~GPU() {
                this->gpu->autorelease();
            }
 
            void loadKernel(std::string libname, std::string functionName) {
                this->kernel = MTLCompute::Kernel(this->gpu, libname+".metallib");
                this->kernel.useFunction(functionName);
                this->commandManager = MTLCompute::CommandManager<T>(this->gpu, &this->kernel);
                this->kernelLoaded = true;
            }
 
            void loadArray(std::vector<T> &array, int index) {
                this->checkloaded();
                MTLCompute::Buffer<T> buffer(gpu, array.size(), MTLCompute::ResourceStorage::Shared);
                buffer = array;
                this->commandManager.loadBuffer(buffer, index);
            }
 
            void loadMatrix(std::vector<std::vector<T>> &matrix, int index) {
                this->checkloaded();
                MTLCompute::Texture<T> texture(gpu, matrix[0].size(), matrix.size());
                texture = matrix;
                this->commandManager.loadTexture(texture, index);
            }
 
            void runKernel() {
                this->checkloaded();
                this->commandManager.dispatch();
            }
 
            std::vector<T> getArray(int index) {
                this->checkloaded();
                MTLCompute::Buffer<T> buffer = commandManager.getBuffers()[index];
                return buffer.getData();
            }
 
            std::vector<std::vector<T>> getMatrix(int index) {
                this->checkloaded();
                MTLCompute::Texture<T> texture = commandManager.getTextures()[index];
                return texture.getData();
            }
 
            void reset() {
                this->checkloaded();
                this->commandManager.reset();
            }
 
            MTL::Device *getGPU() {
                return this->gpu;
            }
 
    };
 
}