diff --git a/examples/array_multiplication/src/Main.cpp b/examples/array_multiplication/src/Main.cpp index 812a5039f..95e0781ad 100755 --- a/examples/array_multiplication/src/Main.cpp +++ b/examples/array_multiplication/src/Main.cpp @@ -14,9 +14,9 @@ int main() kp::Manager mgr; - auto tensorInA = mgr.tensor({ 2.0, 4.0, 6.0 }); - auto tensorInB = mgr.tensor({ 0.0, 1.0, 2.0 }); - auto tensorOut = mgr.tensor({ 0.0, 0.0, 0.0 }); + auto tensorInA = mgr.tensor({ 2.0, 4.0, 6.0 }); + auto tensorInB = mgr.tensor({ 0.0, 1.0, 2.0 }); + auto tensorOut = mgr.tensor({ 0.0, 0.0, 0.0 }); std::string shader(R"( // The version to use @@ -49,7 +49,7 @@ int main() // prints "Output { 0 4 12 }" std::cout<< "Output: { "; - for (const float& elem : tensorOut->data()) { + for (const float& elem : tensorOut->vector()) { std::cout << elem << " "; } std::cout << "}" << std::endl; diff --git a/examples/logistic_regression/src/Main.cpp b/examples/logistic_regression/src/Main.cpp index 3b6ec11e1..c7cc827ba 100755 --- a/examples/logistic_regression/src/Main.cpp +++ b/examples/logistic_regression/src/Main.cpp @@ -17,19 +17,19 @@ int main() kp::Manager mgr; - auto xI = mgr.tensor({ 0, 1, 1, 1, 1 }); - auto xJ = mgr.tensor({ 0, 0, 0, 1, 1 }); + auto xI = mgr.tensor({ 0, 1, 1, 1, 1 }); + auto xJ = mgr.tensor({ 0, 0, 0, 1, 1 }); - auto y = mgr.tensor({ 0, 0, 0, 1, 1 }); + auto y = mgr.tensor({ 0, 0, 0, 1, 1 }); - auto wIn = mgr.tensor({ 0.001, 0.001 }); - auto wOutI = mgr.tensor({ 0, 0, 0, 0, 0 }); - auto wOutJ = mgr.tensor({ 0, 0, 0, 0, 0 }); + auto wIn = mgr.tensor({ 0.001, 0.001 }); + auto wOutI = mgr.tensor({ 0, 0, 0, 0, 0 }); + auto wOutJ = mgr.tensor({ 0, 0, 0, 0, 0 }); - auto bIn = mgr.tensor({ 0 }); - auto bOut = mgr.tensor({ 0, 0, 0, 0, 0 }); + auto bIn = mgr.tensor({ 0 }); + auto bOut = mgr.tensor({ 0, 0, 0, 0, 0 }); - auto lOut = mgr.tensor({ 0, 0, 0, 0, 0 }); + auto lOut = mgr.tensor({ 0, 0, 0, 0, 0 }); std::vector> params = { xI, xJ, y, wIn, wOutI, wOutJ, @@ -40,7 +40,8 @@ int main() (uint32_t*)(kp::shader_data::shaders_glsl_logisticregression_comp_spv + kp::shader_data::shaders_glsl_logisticregression_comp_spv_len)); - std::shared_ptr algo = mgr.algorithm(params, spirv); + std::shared_ptr algo = mgr.algorithm( + params, spirv, kp::Workgroup({ 5 }), kp::Constants({ 5.0 })); mgr.sequence()->eval(params); diff --git a/single_include/kompute/Kompute.hpp b/single_include/kompute/Kompute.hpp index 496e6f198..df9549aab 100755 --- a/single_include/kompute/Kompute.hpp +++ b/single_include/kompute/Kompute.hpp @@ -974,11 +974,21 @@ class Tensor return this->mDataType; } - // TODO: move to cpp - const void* getRawData() { + void* rawData() { return this->mRawData; } + // TODO: move to cpp + template + T* data() { + return this->mRawData; + } + + template + std::vector vector() { + return { (T*)this->mRawData, ((T*)this->mRawData) + this->size() }; + } + /** * Sets / resets the vector data of the tensor. This function does not * perform any copies into GPU memory and is only performed on the host. @@ -989,6 +999,14 @@ class Tensor memcpy(this->mRawData, data, this->memorySize()); } + protected: + // -------------- ALWAYS OWNED RESOURCES + TensorTypes mTensorType; + TensorDataTypes mDataType; + uint32_t mSize; + uint32_t mDataTypeMemorySize; + void* mRawData; + private: void rawMapData() { @@ -1027,13 +1045,6 @@ class Tensor std::shared_ptr mStagingMemory; bool mFreeStagingMemory = false; - // -------------- ALWAYS OWNED RESOURCES - TensorTypes mTensorType; - TensorDataTypes mDataType; - uint32_t mSize; - uint32_t mDataTypeMemorySize; - void* mRawData; - void allocateMemoryCreateGPUResources(); // Creates the vulkan buffer void createBuffer(std::shared_ptr buffer, vk::BufferUsageFlags bufferUsageFlags); @@ -1057,10 +1068,11 @@ class Tensor // TODO: Limit T to be only float, bool, double, etc template -class TensorView: public Tensor +class TensorT: public Tensor { + public: - TensorView(std::shared_ptr physicalDevice, + TensorT(std::shared_ptr physicalDevice, std::shared_ptr device, const std::vector& data, const TensorTypes& tensorType = TensorTypes::eDevice) @@ -1069,35 +1081,42 @@ class TensorView: public Tensor (void*)data.data(), data.size(), sizeof(T), - this->dataType()) + this->dataType(), + tensorType) { - KP_LOG_DEBUG("Kompute TensorView constructor with data size {}", data.size()); + KP_LOG_DEBUG("Kompute TensorT constructor with data size {}", data.size()); } - ~TensorView() { - KP_LOG_DEBUG("Kompute TensorView destructor"); + ~TensorT() { + KP_LOG_DEBUG("Kompute TensorT destructor"); } - std::vector data() { - return { (T*)this->getRawData(), ((T*)this->getRawData()) + this->size() }; + T* data() { + return (T*)this->mRawData; + } + + std::vector vector() { + return { (T*)this->mRawData, ((T*)this->mRawData) + this->size() }; } T& operator[](int index) { - return ((T*)this->mRawData)[index]; + return *(((T*)this->mRawData) + index); } void setData(const std::vector& data) { - KP_LOG_DEBUG("Kompute TensorView setting data with data size {}", data.size()); + KP_LOG_DEBUG("Kompute TensorT setting data with data size {}", data.size()); if (data.size() != this->mSize) { throw std::runtime_error( - "Kompute TensorView Cannot set data of different sizes"); + "Kompute TensorT Cannot set data of different sizes"); } - Tensor::setRawData(this->mData.data(), this->mData.size(), sizeof(T)); + Tensor::setRawData(data.data()); } + TensorDataTypes dataType(); + }; } // End namespace kp @@ -1969,13 +1988,13 @@ class Manager * @returns Shared pointer with initialised tensor */ template - std::shared_ptr> tensor( + std::shared_ptr> tensorT( const std::vector& data, Tensor::TensorTypes tensorType = Tensor::TensorTypes::eDevice) { KP_LOG_DEBUG("Kompute Manager tensor creation triggered"); - std::shared_ptr> tensor{ new kp::TensorView( + std::shared_ptr> tensor{ new kp::TensorT( this->mPhysicalDevice, this->mDevice, data, tensorType) }; if (this->mManageResources) { @@ -1985,6 +2004,13 @@ class Manager return tensor; } + std::shared_ptr> tensor( + const std::vector& data, + Tensor::TensorTypes tensorType = Tensor::TensorTypes::eDevice) + { + return this->tensorT(data, tensorType); + } + /** * Create a managed algorithm that will be destroyed by this manager * if it hasn't been destroyed by its reference count going to zero. diff --git a/src/OpTensorCopy.cpp b/src/OpTensorCopy.cpp index ce53455a3..c93830902 100644 --- a/src/OpTensorCopy.cpp +++ b/src/OpTensorCopy.cpp @@ -61,7 +61,7 @@ OpTensorCopy::postEval(const vk::CommandBuffer& commandBuffer) uint32_t size = this->mTensors[0]->size(); uint32_t dataTypeMemSize = this->mTensors[0]->dataTypeMemorySize(); uint32_t memSize = size * dataTypeMemSize; - const void* data = this->mTensors[0]->getRawData(); + void* data = this->mTensors[0]->rawData(); // Copy the data from the first tensor into all the tensors for (size_t i = 1; i < this->mTensors.size(); i++) { diff --git a/src/Tensor.cpp b/src/Tensor.cpp index 4d7dcd2db..335e48959 100644 --- a/src/Tensor.cpp +++ b/src/Tensor.cpp @@ -429,4 +429,34 @@ Tensor::destroy() KP_LOG_DEBUG("Kompute Tensor successful destroy()"); } +template<> +Tensor::TensorDataTypes +TensorT::dataType() { + return Tensor::TensorDataTypes::eBool; +} + +template<> +Tensor::TensorDataTypes +TensorT::dataType() { + return Tensor::TensorDataTypes::eInt; +} + +template<> +Tensor::TensorDataTypes +TensorT::dataType() { + return Tensor::TensorDataTypes::eUnsignedInt; +} + +template<> +Tensor::TensorDataTypes +TensorT::dataType() { + return Tensor::TensorDataTypes::eFloat; +} + +template<> +Tensor::TensorDataTypes +TensorT::dataType() { + return Tensor::TensorDataTypes::eDouble; +} + } diff --git a/src/include/kompute/Manager.hpp b/src/include/kompute/Manager.hpp index d27bccacc..c39f5d6b5 100644 --- a/src/include/kompute/Manager.hpp +++ b/src/include/kompute/Manager.hpp @@ -75,13 +75,13 @@ class Manager * @returns Shared pointer with initialised tensor */ template - std::shared_ptr> tensor( + std::shared_ptr> tensorT( const std::vector& data, Tensor::TensorTypes tensorType = Tensor::TensorTypes::eDevice) { KP_LOG_DEBUG("Kompute Manager tensor creation triggered"); - std::shared_ptr> tensor{ new kp::TensorView( + std::shared_ptr> tensor{ new kp::TensorT( this->mPhysicalDevice, this->mDevice, data, tensorType) }; if (this->mManageResources) { @@ -91,6 +91,13 @@ class Manager return tensor; } + std::shared_ptr> tensor( + const std::vector& data, + Tensor::TensorTypes tensorType = Tensor::TensorTypes::eDevice) + { + return this->tensorT(data, tensorType); + } + /** * Create a managed algorithm that will be destroyed by this manager * if it hasn't been destroyed by its reference count going to zero. diff --git a/src/include/kompute/Tensor.hpp b/src/include/kompute/Tensor.hpp index f041d57e3..898a2df08 100644 --- a/src/include/kompute/Tensor.hpp +++ b/src/include/kompute/Tensor.hpp @@ -183,11 +183,21 @@ class Tensor return this->mDataType; } - // TODO: move to cpp - const void* getRawData() { + void* rawData() { return this->mRawData; } + // TODO: move to cpp + template + T* data() { + return this->mRawData; + } + + template + std::vector vector() { + return { (T*)this->mRawData, ((T*)this->mRawData) + this->size() }; + } + /** * Sets / resets the vector data of the tensor. This function does not * perform any copies into GPU memory and is only performed on the host. @@ -198,6 +208,14 @@ class Tensor memcpy(this->mRawData, data, this->memorySize()); } + protected: + // -------------- ALWAYS OWNED RESOURCES + TensorTypes mTensorType; + TensorDataTypes mDataType; + uint32_t mSize; + uint32_t mDataTypeMemorySize; + void* mRawData; + private: void rawMapData() { @@ -236,13 +254,6 @@ class Tensor std::shared_ptr mStagingMemory; bool mFreeStagingMemory = false; - // -------------- ALWAYS OWNED RESOURCES - TensorTypes mTensorType; - TensorDataTypes mDataType; - uint32_t mSize; - uint32_t mDataTypeMemorySize; - void* mRawData; - void allocateMemoryCreateGPUResources(); // Creates the vulkan buffer void createBuffer(std::shared_ptr buffer, vk::BufferUsageFlags bufferUsageFlags); @@ -266,10 +277,11 @@ class Tensor // TODO: Limit T to be only float, bool, double, etc template -class TensorView: public Tensor +class TensorT: public Tensor { + public: - TensorView(std::shared_ptr physicalDevice, + TensorT(std::shared_ptr physicalDevice, std::shared_ptr device, const std::vector& data, const TensorTypes& tensorType = TensorTypes::eDevice) @@ -278,35 +290,42 @@ class TensorView: public Tensor (void*)data.data(), data.size(), sizeof(T), - this->dataType()) + this->dataType(), + tensorType) { - KP_LOG_DEBUG("Kompute TensorView constructor with data size {}", data.size()); + KP_LOG_DEBUG("Kompute TensorT constructor with data size {}", data.size()); } - ~TensorView() { - KP_LOG_DEBUG("Kompute TensorView destructor"); + ~TensorT() { + KP_LOG_DEBUG("Kompute TensorT destructor"); } - std::vector data() { - return { (T*)this->getRawData(), ((T*)this->getRawData()) + this->size() }; + T* data() { + return (T*)this->mRawData; + } + + std::vector vector() { + return { (T*)this->mRawData, ((T*)this->mRawData) + this->size() }; } T& operator[](int index) { - return ((T*)this->mRawData)[index]; + return *(((T*)this->mRawData) + index); } void setData(const std::vector& data) { - KP_LOG_DEBUG("Kompute TensorView setting data with data size {}", data.size()); + KP_LOG_DEBUG("Kompute TensorT setting data with data size {}", data.size()); if (data.size() != this->mSize) { throw std::runtime_error( - "Kompute TensorView Cannot set data of different sizes"); + "Kompute TensorT Cannot set data of different sizes"); } - Tensor::setRawData(this->mData.data(), this->mData.size(), sizeof(T)); + Tensor::setRawData(data.data()); } + TensorDataTypes dataType(); + }; } // End namespace kp diff --git a/test/TestAsyncOperations.cpp b/test/TestAsyncOperations.cpp index 2f8c7d819..7feaaa30e 100644 --- a/test/TestAsyncOperations.cpp +++ b/test/TestAsyncOperations.cpp @@ -73,7 +73,7 @@ TEST(TestAsyncOperations, TestManagerParallelExecution) sq->eval(inputsSyncB); for (uint32_t i = 0; i < numParallel; i++) { - EXPECT_EQ(inputsSyncB[i]->data(), resultSync); + EXPECT_EQ(inputsSyncB[i]->vector(), resultSync); } kp::Manager mgrAsync(0, { 0, 2 }); @@ -111,7 +111,7 @@ TEST(TestAsyncOperations, TestManagerParallelExecution) sq->eval({ inputsAsyncB }); for (uint32_t i = 0; i < numParallel; i++) { - EXPECT_EQ(inputsAsyncB[i]->data(), resultAsync); + EXPECT_EQ((inputsAsyncB[i]->vector()), resultAsync); } // The speedup should be at least 40% @@ -152,8 +152,8 @@ TEST(TestAsyncOperations, TestManagerAsyncExecution) kp::Manager mgr; - std::shared_ptr tensorA = mgr.tensor(data); - std::shared_ptr tensorB = mgr.tensor(data); + std::shared_ptr> tensorA = mgr.tensor(data); + std::shared_ptr> tensorB = mgr.tensor(data); std::shared_ptr sq1 = mgr.sequence(); std::shared_ptr sq2 = mgr.sequence(); @@ -172,6 +172,6 @@ TEST(TestAsyncOperations, TestManagerAsyncExecution) sq1->evalAsync({ tensorA, tensorB }); sq1->evalAwait(); - EXPECT_EQ(tensorA->data(), resultAsync); - EXPECT_EQ(tensorB->data(), resultAsync); + EXPECT_EQ(tensorA->vector(), resultAsync); + EXPECT_EQ(tensorB->vector(), resultAsync); } diff --git a/test/TestDestroy.cpp b/test/TestDestroy.cpp index 0b948d64f..0ccfdb0f8 100644 --- a/test/TestDestroy.cpp +++ b/test/TestDestroy.cpp @@ -5,9 +5,9 @@ TEST(TestDestroy, TestDestroyTensorSingle) { - std::shared_ptr tensorA = nullptr; + std::shared_ptr> tensorA = nullptr; - std::string shader(R"( + std::string shader(R"( #version 450 layout (local_size_x = 1) in; layout(set = 0, binding = 0) buffer a { float pa[]; }; @@ -39,13 +39,13 @@ TEST(TestDestroy, TestDestroyTensorSingle) } EXPECT_FALSE(tensorA->isInit()); } - EXPECT_EQ(tensorA->data(), std::vector({ 1, 1, 1 })); + EXPECT_EQ(tensorA->vector(), std::vector({ 1, 1, 1 })); } TEST(TestDestroy, TestDestroyTensorVector) { - std::shared_ptr tensorA = nullptr; - std::shared_ptr tensorB = nullptr; + std::shared_ptr> tensorA = nullptr; + std::shared_ptr> tensorB = nullptr; std::string shader(R"( #version 450 @@ -84,13 +84,13 @@ TEST(TestDestroy, TestDestroyTensorVector) EXPECT_FALSE(tensorB->isInit()); } } - EXPECT_EQ(tensorA->data(), std::vector({ 2, 2, 2 })); - EXPECT_EQ(tensorB->data(), std::vector({ 3, 3, 3 })); + EXPECT_EQ(tensorA->vector(), std::vector({ 2, 2, 2 })); + EXPECT_EQ(tensorB->vector(), std::vector({ 3, 3, 3 })); } TEST(TestDestroy, TestDestroySequenceSingle) { - std::shared_ptr tensorA = nullptr; + std::shared_ptr> tensorA = nullptr; std::string shader(R"( #version 450 @@ -123,5 +123,5 @@ TEST(TestDestroy, TestDestroySequenceSingle) EXPECT_FALSE(sq->isInit()); } } - EXPECT_EQ(tensorA->data(), std::vector({ 1, 1, 1 })); + EXPECT_EQ(tensorA->vector(), std::vector({ 1, 1, 1 })); } diff --git a/test/TestLogisticRegression.cpp b/test/TestLogisticRegression.cpp index 980273246..a4402637f 100644 --- a/test/TestLogisticRegression.cpp +++ b/test/TestLogisticRegression.cpp @@ -14,19 +14,19 @@ TEST(TestLogisticRegression, TestMainLogisticRegression) { kp::Manager mgr; - std::shared_ptr xI = mgr.tensor({ 0, 1, 1, 1, 1 }); - std::shared_ptr xJ = mgr.tensor({ 0, 0, 0, 1, 1 }); + std::shared_ptr> xI = mgr.tensor({ 0, 1, 1, 1, 1 }); + std::shared_ptr> xJ = mgr.tensor({ 0, 0, 0, 1, 1 }); - std::shared_ptr y = mgr.tensor({ 0, 0, 0, 1, 1 }); + std::shared_ptr> y = mgr.tensor({ 0, 0, 0, 1, 1 }); - std::shared_ptr wIn = mgr.tensor({ 0.001, 0.001 }); - std::shared_ptr wOutI = mgr.tensor({ 0, 0, 0, 0, 0 }); - std::shared_ptr wOutJ = mgr.tensor({ 0, 0, 0, 0, 0 }); + std::shared_ptr> wIn = mgr.tensor({ 0.001, 0.001 }); + std::shared_ptr> wOutI = mgr.tensor({ 0, 0, 0, 0, 0 }); + std::shared_ptr> wOutJ = mgr.tensor({ 0, 0, 0, 0, 0 }); - std::shared_ptr bIn = mgr.tensor({ 0 }); - std::shared_ptr bOut = mgr.tensor({ 0, 0, 0, 0, 0 }); + std::shared_ptr> bIn = mgr.tensor({ 0 }); + std::shared_ptr> bOut = mgr.tensor({ 0, 0, 0, 0, 0 }); - std::shared_ptr lOut = mgr.tensor({ 0, 0, 0, 0, 0 }); + std::shared_ptr> lOut = mgr.tensor({ 0, 0, 0, 0, 0 }); std::vector> params = { xI, xJ, y, wIn, wOutI, wOutJ, @@ -88,21 +88,21 @@ TEST(TestLogisticRegression, TestMainLogisticRegressionManualCopy) { kp::Manager mgr; - std::shared_ptr xI = mgr.tensor({ 0, 1, 1, 1, 1 }); - std::shared_ptr xJ = mgr.tensor({ 0, 0, 0, 1, 1 }); + std::shared_ptr> xI = mgr.tensor({ 0, 1, 1, 1, 1 }); + std::shared_ptr> xJ = mgr.tensor({ 0, 0, 0, 1, 1 }); - std::shared_ptr y = mgr.tensor({ 0, 0, 0, 1, 1 }); + std::shared_ptr> y = mgr.tensor({ 0, 0, 0, 1, 1 }); - std::shared_ptr wIn = + std::shared_ptr> wIn = mgr.tensor({ 0.001, 0.001 }, kp::Tensor::TensorTypes::eHost); - std::shared_ptr wOutI = mgr.tensor({ 0, 0, 0, 0, 0 }); - std::shared_ptr wOutJ = mgr.tensor({ 0, 0, 0, 0, 0 }); + std::shared_ptr> wOutI = mgr.tensor({ 0, 0, 0, 0, 0 }); + std::shared_ptr> wOutJ = mgr.tensor({ 0, 0, 0, 0, 0 }); - std::shared_ptr bIn = + std::shared_ptr> bIn = mgr.tensor({ 0 }, kp::Tensor::TensorTypes::eHost); - std::shared_ptr bOut = mgr.tensor({ 0, 0, 0, 0, 0 }); + std::shared_ptr> bOut = mgr.tensor({ 0, 0, 0, 0, 0 }); - std::shared_ptr lOut = mgr.tensor({ 0, 0, 0, 0, 0 }); + std::shared_ptr> lOut = mgr.tensor({ 0, 0, 0, 0, 0 }); std::vector> params = { xI, xJ, y, wIn, wOutI, wOutJ, @@ -136,8 +136,6 @@ TEST(TestLogisticRegression, TestMainLogisticRegressionManualCopy) wIn->data()[1] -= learningRate * wOutJ->data()[j]; bIn->data()[0] -= learningRate * bOut->data()[j]; } - wIn->mapDataIntoHostMemory(); - bIn->mapDataIntoHostMemory(); } // Based on the inputs the outputs should be at least: diff --git a/test/TestManager.cpp b/test/TestManager.cpp index ce055ff8c..f759208aa 100644 --- a/test/TestManager.cpp +++ b/test/TestManager.cpp @@ -7,9 +7,9 @@ TEST(TestManager, EndToEndOpMultEvalFlow) { kp::Manager mgr; - std::shared_ptr tensorLHS = mgr.tensor({ 0, 1, 2 }); - std::shared_ptr tensorRHS = mgr.tensor({ 2, 4, 6 }); - std::shared_ptr tensorOutput = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorLHS = mgr.tensor({ 0, 1, 2 }); + std::shared_ptr> tensorRHS = mgr.tensor({ 2, 4, 6 }); + std::shared_ptr> tensorOutput = mgr.tensor({ 0, 0, 0 }); std::vector> params = { tensorLHS, tensorRHS, @@ -20,16 +20,16 @@ TEST(TestManager, EndToEndOpMultEvalFlow) ->eval(params, mgr.algorithm()) ->eval(params); - EXPECT_EQ(tensorOutput->data(), std::vector({ 0, 4, 12 })); + EXPECT_EQ(tensorOutput->vector(), std::vector({ 0, 4, 12 })); } TEST(TestManager, EndToEndOpMultSeqFlow) { kp::Manager mgr; - std::shared_ptr tensorLHS = mgr.tensor({ 0, 1, 2 }); - std::shared_ptr tensorRHS = mgr.tensor({ 2, 4, 6 }); - std::shared_ptr tensorOutput = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorLHS = mgr.tensor({ 0, 1, 2 }); + std::shared_ptr> tensorRHS = mgr.tensor({ 2, 4, 6 }); + std::shared_ptr> tensorOutput = mgr.tensor({ 0, 0, 0 }); std::vector> params = { tensorLHS, tensorRHS, @@ -41,16 +41,16 @@ TEST(TestManager, EndToEndOpMultSeqFlow) ->record(params) ->eval(); - EXPECT_EQ(tensorOutput->data(), std::vector({ 0, 4, 12 })); + EXPECT_EQ(tensorOutput->vector(), std::vector({ 0, 4, 12 })); } TEST(TestManager, TestMultipleSequences) { kp::Manager mgr; - std::shared_ptr tensorLHS = mgr.tensor({ 0, 1, 2 }); - std::shared_ptr tensorRHS = mgr.tensor({ 2, 4, 6 }); - std::shared_ptr tensorOutput = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorLHS = mgr.tensor({ 0, 1, 2 }); + std::shared_ptr> tensorRHS = mgr.tensor({ 2, 4, 6 }); + std::shared_ptr> tensorOutput = mgr.tensor({ 0, 0, 0 }); std::vector> params = { tensorLHS, tensorRHS, @@ -60,5 +60,5 @@ TEST(TestManager, TestMultipleSequences) mgr.sequence()->eval(params, mgr.algorithm()); mgr.sequence()->eval(params); - EXPECT_EQ(tensorOutput->data(), std::vector({ 0, 4, 12 })); + EXPECT_EQ(tensorOutput->vector(), std::vector({ 0, 4, 12 })); } diff --git a/test/TestMultipleAlgoExecutions.cpp b/test/TestMultipleAlgoExecutions.cpp index 63dd5f7fe..b934f7e83 100644 --- a/test/TestMultipleAlgoExecutions.cpp +++ b/test/TestMultipleAlgoExecutions.cpp @@ -64,8 +64,8 @@ TEST(TestMultipleAlgoExecutions, TestEndToEndFunctionality) sq->evalAwait(); - EXPECT_EQ(tensorOutA->data(), std::vector({ 4, 8, 12 })); - EXPECT_EQ(tensorOutB->data(), std::vector({ 10, 10, 10 })); + EXPECT_EQ(tensorOutA->vector(), std::vector({ 4, 8, 12 })); + EXPECT_EQ(tensorOutB->vector(), std::vector({ 10, 10, 10 })); } TEST(TestMultipleAlgoExecutions, SingleSequenceRecord) @@ -73,7 +73,7 @@ TEST(TestMultipleAlgoExecutions, SingleSequenceRecord) kp::Manager mgr; - std::shared_ptr tensorA = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorA = mgr.tensor({ 0, 0, 0 }); std::string shader(R"( #version 450 @@ -96,14 +96,14 @@ TEST(TestMultipleAlgoExecutions, SingleSequenceRecord) ->eval(); } - EXPECT_EQ(tensorA->data(), std::vector({ 3, 3, 3 })); + EXPECT_EQ(tensorA->vector(), std::vector({ 3, 3, 3 })); } TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords) { kp::Manager mgr; - std::shared_ptr tensorA = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorA = mgr.tensor({ 0, 0, 0 }); std::string shader(R"( #version 450 @@ -131,7 +131,7 @@ TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords) mgr.sequence()->record({ tensorA })->eval(); - EXPECT_EQ(tensorA->data(), std::vector({ 3, 3, 3 })); + EXPECT_EQ(tensorA->vector(), std::vector({ 3, 3, 3 })); } TEST(TestMultipleAlgoExecutions, MultipleSequences) @@ -139,7 +139,7 @@ TEST(TestMultipleAlgoExecutions, MultipleSequences) kp::Manager mgr; - std::shared_ptr tensorA = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorA = mgr.tensor({ 0, 0, 0 }); std::string shader(R"( #version 450 @@ -167,14 +167,14 @@ TEST(TestMultipleAlgoExecutions, MultipleSequences) sq->record({ tensorA })->eval(); - EXPECT_EQ(tensorA->data(), std::vector({ 3, 3, 3 })); + EXPECT_EQ(tensorA->vector(), std::vector({ 3, 3, 3 })); } TEST(TestMultipleAlgoExecutions, SingleRecordMultipleEval) { kp::Manager mgr; - std::shared_ptr tensorA = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorA = mgr.tensor({ 0, 0, 0 }); std::string shader(R"( #version 450 @@ -198,12 +198,12 @@ TEST(TestMultipleAlgoExecutions, SingleRecordMultipleEval) sq->record({ tensorA })->eval(); - EXPECT_EQ(tensorA->data(), std::vector({ 3, 3, 3 })); + EXPECT_EQ(tensorA->vector(), std::vector({ 3, 3, 3 })); } TEST(TestMultipleAlgoExecutions, SequenceAlgoDestroyOutsideManagerScope) { - std::shared_ptr tensorA = nullptr; + std::shared_ptr> tensorA = nullptr; { std::shared_ptr sq = nullptr; @@ -236,5 +236,5 @@ TEST(TestMultipleAlgoExecutions, SequenceAlgoDestroyOutsideManagerScope) } } - EXPECT_EQ(tensorA->data(), std::vector({ 3, 3, 3 })); + EXPECT_EQ(tensorA->vector(), std::vector({ 3, 3, 3 })); } diff --git a/test/TestOpShadersFromStringAndFile.cpp b/test/TestOpShadersFromStringAndFile.cpp index e766c8efb..a1f8eda99 100644 --- a/test/TestOpShadersFromStringAndFile.cpp +++ b/test/TestOpShadersFromStringAndFile.cpp @@ -9,8 +9,8 @@ TEST(TestOpAlgoCreate, ShaderRawDataFromConstructor) { kp::Manager mgr; - std::shared_ptr tensorA = mgr.tensor({ 3, 4, 5 }); - std::shared_ptr tensorB = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorA = mgr.tensor({ 3, 4, 5 }); + std::shared_ptr> tensorB = mgr.tensor({ 0, 0, 0 }); std::string shader(R"( #version 450 @@ -36,16 +36,16 @@ TEST(TestOpAlgoCreate, ShaderRawDataFromConstructor) ->eval(mgr.algorithm(params, spirv)) ->eval(params); - EXPECT_EQ(tensorA->data(), std::vector({ 0, 1, 2 })); - EXPECT_EQ(tensorB->data(), std::vector({ 3, 4, 5 })); + EXPECT_EQ(tensorA->vector(), std::vector({ 0, 1, 2 })); + EXPECT_EQ(tensorB->vector(), std::vector({ 3, 4, 5 })); } TEST(TestOpAlgoCreate, ShaderCompiledDataFromConstructor) { kp::Manager mgr; - std::shared_ptr tensorA = mgr.tensor({ 3, 4, 5 }); - std::shared_ptr tensorB = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorA = mgr.tensor({ 3, 4, 5 }); + std::shared_ptr> tensorB = mgr.tensor({ 0, 0, 0 }); std::vector spirv = std::vector( (uint32_t*) @@ -62,8 +62,8 @@ TEST(TestOpAlgoCreate, ShaderCompiledDataFromConstructor) ->eval(mgr.algorithm(params, spirv)) ->eval(params); - EXPECT_EQ(tensorA->data(), std::vector({ 0, 1, 2 })); - EXPECT_EQ(tensorB->data(), std::vector({ 3, 4, 5 })); + EXPECT_EQ(tensorA->vector(), std::vector({ 0, 1, 2 })); + EXPECT_EQ(tensorB->vector(), std::vector({ 3, 4, 5 })); } // TODO: Add support to read from file for shader @@ -71,8 +71,8 @@ TEST(TestOpAlgoCreate, ShaderCompiledDataFromConstructor) //{ // kp::Manager mgr; // -// std::shared_ptr tensorA{ new kp::Tensor({ 3, 4, 5 }) }; -// std::shared_ptr tensorB{ new kp::Tensor({ 0, 0, 0 }) }; +// std::shared_ptr> tensorA{ new kp::Tensor({ 3, 4, 5 }) }; +// std::shared_ptr> tensorB{ new kp::Tensor({ 0, 0, 0 }) }; // mgr.rebuild({ tensorA, tensorB }); // // mgr.evalOpDefault( @@ -81,6 +81,6 @@ TEST(TestOpAlgoCreate, ShaderCompiledDataFromConstructor) // // mgr.evalOpDefault({ tensorA, tensorB }); // -// EXPECT_EQ(tensorA->data(), std::vector({ 0, 1, 2 })); -// EXPECT_EQ(tensorB->data(), std::vector({ 3, 4, 5 })); +// EXPECT_EQ(tensorA->vector(), std::vector({ 0, 1, 2 })); +// EXPECT_EQ(tensorB->vector(), std::vector({ 3, 4, 5 })); //} diff --git a/test/TestOpTensorCopy.cpp b/test/TestOpTensorCopy.cpp index 85e0b545b..6978eeeea 100644 --- a/test/TestOpTensorCopy.cpp +++ b/test/TestOpTensorCopy.cpp @@ -11,8 +11,8 @@ TEST(TestOpTensorCopy, CopyDeviceToDeviceTensor) std::vector testVecA{ 1, 2, 3 }; std::vector testVecB{ 0, 0, 0 }; - std::shared_ptr tensorA = mgr.tensor(testVecA); - std::shared_ptr tensorB = mgr.tensor(testVecB); + std::shared_ptr> tensorA = mgr.tensor(testVecA); + std::shared_ptr> tensorB = mgr.tensor(testVecB); EXPECT_TRUE(tensorA->isInit()); EXPECT_TRUE(tensorB->isInit()); @@ -22,8 +22,8 @@ TEST(TestOpTensorCopy, CopyDeviceToDeviceTensor) ->eval({ tensorA, tensorB }) ->eval({ tensorA, tensorB }); - // Making sure the GPU holds the same data - EXPECT_EQ(tensorA->data(), tensorB->data()); + // Making sure the GPU holds the same vector + EXPECT_EQ(tensorA->vector(), tensorB->vector()); } TEST(TestOpTensorCopy, CopyDeviceToDeviceTensorMulti) @@ -35,9 +35,9 @@ TEST(TestOpTensorCopy, CopyDeviceToDeviceTensorMulti) std::vector testVecB{ 0, 0, 0 }; std::vector testVecC{ 0, 0, 0 }; - std::shared_ptr tensorA = mgr.tensor(testVecA); - std::shared_ptr tensorB = mgr.tensor(testVecB); - std::shared_ptr tensorC = mgr.tensor(testVecC); + std::shared_ptr> tensorA = mgr.tensor(testVecA); + std::shared_ptr> tensorB = mgr.tensor(testVecB); + std::shared_ptr> tensorC = mgr.tensor(testVecC); EXPECT_TRUE(tensorA->isInit()); EXPECT_TRUE(tensorB->isInit()); @@ -47,14 +47,14 @@ TEST(TestOpTensorCopy, CopyDeviceToDeviceTensorMulti) ->eval({ tensorA, tensorB, tensorC }) ->eval({ tensorA, tensorB, tensorC }); - EXPECT_EQ(tensorA->data(), tensorB->data()); - EXPECT_EQ(tensorA->data(), tensorC->data()); + EXPECT_EQ(tensorA->vector(), tensorB->vector()); + EXPECT_EQ(tensorA->vector(), tensorC->vector()); - // Making sure the GPU holds the same data + // Making sure the GPU holds the same vector mgr.sequence()->eval({ tensorB, tensorC }); - EXPECT_EQ(tensorA->data(), tensorB->data()); - EXPECT_EQ(tensorA->data(), tensorC->data()); + EXPECT_EQ(tensorA->vector(), tensorB->vector()); + EXPECT_EQ(tensorA->vector(), tensorC->vector()); } TEST(TestOpTensorCopy, CopyDeviceToHostTensor) @@ -65,8 +65,8 @@ TEST(TestOpTensorCopy, CopyDeviceToHostTensor) std::vector testVecA{ 3, 4, 5 }; std::vector testVecB{ 0, 0, 0 }; - std::shared_ptr tensorA = mgr.tensor(testVecA); - std::shared_ptr tensorB = + std::shared_ptr> tensorA = mgr.tensor(testVecA); + std::shared_ptr> tensorB = mgr.tensor(testVecB, kp::Tensor::TensorTypes::eHost); // Only calling sync on device type tensor @@ -77,11 +77,11 @@ TEST(TestOpTensorCopy, CopyDeviceToHostTensor) mgr.sequence()->eval({ tensorA, tensorB }); - EXPECT_EQ(tensorA->data(), tensorB->data()); + EXPECT_EQ(tensorA->vector(), tensorB->vector()); - // Making sure the GPU holds the same data + // Making sure the GPU holds the same vector mgr.sequence()->eval({ tensorB }); - EXPECT_EQ(tensorA->data(), tensorB->data()); + EXPECT_EQ(tensorA->vector(), tensorB->vector()); } TEST(TestOpTensorCopy, CopyHostToDeviceTensor) @@ -92,9 +92,9 @@ TEST(TestOpTensorCopy, CopyHostToDeviceTensor) std::vector testVecA{ 4, 5, 6 }; std::vector testVecB{ 0, 0, 0 }; - std::shared_ptr tensorA = + std::shared_ptr> tensorA = mgr.tensor(testVecA, kp::Tensor::TensorTypes::eHost); - std::shared_ptr tensorB = mgr.tensor(testVecB); + std::shared_ptr> tensorB = mgr.tensor(testVecB); // Only calling sync on device type tensor mgr.sequence()->eval({ tensorA, tensorB }); @@ -104,11 +104,11 @@ TEST(TestOpTensorCopy, CopyHostToDeviceTensor) mgr.sequence()->eval({ tensorA, tensorB }); - EXPECT_EQ(tensorA->data(), tensorB->data()); + EXPECT_EQ(tensorA->vector(), tensorB->vector()); - // Making sure the GPU holds the same data + // Making sure the GPU holds the same vector mgr.sequence()->eval({ tensorB }); - EXPECT_EQ(tensorA->data(), tensorB->data()); + EXPECT_EQ(tensorA->vector(), tensorB->vector()); } TEST(TestOpTensorCopy, CopyHostToHostTensor) @@ -119,9 +119,9 @@ TEST(TestOpTensorCopy, CopyHostToHostTensor) std::vector testVecA{ 5, 6, 7 }; std::vector testVecB{ 0, 0, 0 }; - std::shared_ptr tensorA = + std::shared_ptr> tensorA = mgr.tensor(testVecA, kp::Tensor::TensorTypes::eHost); - std::shared_ptr tensorB = + std::shared_ptr> tensorB = mgr.tensor(testVecB, kp::Tensor::TensorTypes::eHost); EXPECT_TRUE(tensorA->isInit()); @@ -131,11 +131,11 @@ TEST(TestOpTensorCopy, CopyHostToHostTensor) ->eval({ tensorA }) ->eval({ tensorA, tensorB }); - EXPECT_EQ(tensorA->data(), tensorB->data()); + EXPECT_EQ(tensorA->vector(), tensorB->vector()); - // Making sure the GPU holds the same data + // Making sure the GPU holds the same vector mgr.sequence()->eval({ tensorB }); - EXPECT_EQ(tensorA->data(), tensorB->data()); + EXPECT_EQ(tensorA->vector(), tensorB->vector()); } TEST(TestOpTensorCopy, SingleTensorShouldFail) @@ -145,7 +145,7 @@ TEST(TestOpTensorCopy, SingleTensorShouldFail) std::vector testVecA{ 6, 7, 8 }; - std::shared_ptr tensorA = + std::shared_ptr> tensorA = mgr.tensor(testVecA, kp::Tensor::TensorTypes::eHost); EXPECT_TRUE(tensorA->isInit()); diff --git a/test/TestOpTensorCreate.cpp b/test/TestOpTensorCreate.cpp index 14153427e..7ba1be615 100644 --- a/test/TestOpTensorCreate.cpp +++ b/test/TestOpTensorCreate.cpp @@ -6,7 +6,7 @@ TEST(TestOpTensorCreate, CreateSingleTensorSingleOp) { std::vector testVecA{ 9, 8, 7 }; - std::shared_ptr tensorA = nullptr; + std::shared_ptr> tensorA = nullptr; { kp::Manager mgr; @@ -15,7 +15,7 @@ TEST(TestOpTensorCreate, CreateSingleTensorSingleOp) EXPECT_TRUE(tensorA->isInit()); - EXPECT_EQ(tensorA->data(), testVecA); + EXPECT_EQ(tensorA->vector(), testVecA); } EXPECT_FALSE(tensorA->isInit()); @@ -29,11 +29,11 @@ TEST(TestOpTensorCreate, NoErrorIfTensorFreedBefore) kp::Manager mgr; - std::shared_ptr tensorA = mgr.tensor(testVecA); - std::shared_ptr tensorB = mgr.tensor(testVecB); + std::shared_ptr> tensorA = mgr.tensor(testVecA); + std::shared_ptr> tensorB = mgr.tensor(testVecB); - EXPECT_EQ(tensorA->data(), testVecA); - EXPECT_EQ(tensorB->data(), testVecB); + EXPECT_EQ(tensorA->vector(), testVecA); + EXPECT_EQ(tensorB->vector(), testVecB); tensorA->destroy(); tensorB->destroy(); @@ -49,7 +49,7 @@ TEST(TestOpTensorCreate, ExceptionOnZeroSizeTensor) kp::Manager mgr; try { - std::shared_ptr tensorA = mgr.tensor(testVecA); + std::shared_ptr> tensorA = mgr.tensor(testVecA); } catch (const std::runtime_error& err) { // check exception ASSERT_TRUE(std::string(err.what()).find("zero-sized") != diff --git a/test/TestOpTensorSync.cpp b/test/TestOpTensorSync.cpp index 55e02ad13..02271c618 100644 --- a/test/TestOpTensorSync.cpp +++ b/test/TestOpTensorSync.cpp @@ -11,7 +11,7 @@ TEST(TestOpTensorSync, SyncToDeviceMemorySingleTensor) std::vector testVecPreA{ 0, 0, 0 }; std::vector testVecPostA{ 9, 8, 7 }; - std::shared_ptr tensorA = mgr.tensor(testVecPreA); + std::shared_ptr> tensorA = mgr.tensor(testVecPreA); EXPECT_TRUE(tensorA->isInit()); @@ -21,7 +21,7 @@ TEST(TestOpTensorSync, SyncToDeviceMemorySingleTensor) mgr.sequence()->eval({ tensorA }); - EXPECT_EQ(tensorA->data(), testVecPostA); + EXPECT_EQ(tensorA->vector(), testVecPostA); } TEST(TestOpTensorSync, SyncToDeviceMemoryMultiTensor) @@ -31,9 +31,9 @@ TEST(TestOpTensorSync, SyncToDeviceMemoryMultiTensor) std::vector testVec{ 9, 8, 7 }; - std::shared_ptr tensorA = mgr.tensor({ 0, 0, 0 }); - std::shared_ptr tensorB = mgr.tensor({ 0, 0, 0 }); - std::shared_ptr tensorC = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorA = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorB = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorC = mgr.tensor({ 0, 0, 0 }); EXPECT_TRUE(tensorA->isInit()); EXPECT_TRUE(tensorB->isInit()); @@ -47,7 +47,7 @@ TEST(TestOpTensorSync, SyncToDeviceMemoryMultiTensor) mgr.sequence()->eval({ tensorA, tensorB, tensorC }); - EXPECT_EQ(tensorA->data(), testVec); - EXPECT_EQ(tensorB->data(), testVec); - EXPECT_EQ(tensorC->data(), testVec); + EXPECT_EQ(tensorA->vector(), testVec); + EXPECT_EQ(tensorB->vector(), testVec); + EXPECT_EQ(tensorC->vector(), testVec); } diff --git a/test/TestPushConstant.cpp b/test/TestPushConstant.cpp index b37fe4d72..9599596ed 100644 --- a/test/TestPushConstant.cpp +++ b/test/TestPushConstant.cpp @@ -29,7 +29,7 @@ TEST(TestPushConstants, TestConstantsAlgoDispatchOverride) { kp::Manager mgr; - std::shared_ptr tensor = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensor = mgr.tensor({ 0, 0, 0 }); std::shared_ptr algo = mgr.algorithm({ tensor }, spirv, kp::Workgroup({ 1 }), {}, { 0.0, 0.0, 0.0 }); @@ -42,7 +42,7 @@ TEST(TestPushConstants, TestConstantsAlgoDispatchOverride) sq->eval(algo, kp::Constants{ 0.3, 0.2, 0.1 }); sq->eval({ tensor }); - EXPECT_EQ(tensor->data(), kp::Constants({ 0.4, 0.4, 0.4 })); + EXPECT_EQ(tensor->vector(), kp::Constants({ 0.4, 0.4, 0.4 })); } } } @@ -72,7 +72,7 @@ TEST(TestPushConstants, TestConstantsAlgoDispatchNoOverride) { kp::Manager mgr; - std::shared_ptr tensor = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensor = mgr.tensor({ 0, 0, 0 }); std::shared_ptr algo = mgr.algorithm({ tensor }, spirv, kp::Workgroup({ 1 }), {}, { 0.1, 0.2, 0.3 }); @@ -85,7 +85,7 @@ TEST(TestPushConstants, TestConstantsAlgoDispatchNoOverride) sq->eval(algo, kp::Constants{ 0.3, 0.2, 0.1 }); sq->eval({ tensor }); - EXPECT_EQ(tensor->data(), kp::Constants({ 0.4, 0.4, 0.4 })); + EXPECT_EQ(tensor->vector(), kp::Constants({ 0.4, 0.4, 0.4 })); } } } @@ -115,7 +115,7 @@ TEST(TestPushConstants, TestConstantsWrongSize) { kp::Manager mgr; - std::shared_ptr tensor = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensor = mgr.tensor({ 0, 0, 0 }); std::shared_ptr algo = mgr.algorithm({ tensor }, spirv, kp::Workgroup({ 1 }), {}, { 0.0 }); diff --git a/test/TestSequence.cpp b/test/TestSequence.cpp index 7d70a477b..090a6317b 100644 --- a/test/TestSequence.cpp +++ b/test/TestSequence.cpp @@ -60,9 +60,9 @@ TEST(TestSequence, RerecordSequence) std::shared_ptr sq = mgr.sequence(); - std::shared_ptr tensorA = mgr.tensor({1, 2, 3}); - std::shared_ptr tensorB = mgr.tensor({2, 2, 2}); - std::shared_ptr tensorOut = mgr.tensor({0, 0, 0}); + std::shared_ptr> tensorA = mgr.tensor({1, 2, 3}); + std::shared_ptr> tensorB = mgr.tensor({2, 2, 2}); + std::shared_ptr> tensorOut = mgr.tensor({0, 0, 0}); sq->eval({ tensorA, tensorB, tensorOut }); @@ -90,7 +90,7 @@ TEST(TestSequence, RerecordSequence) sq->eval(); - EXPECT_EQ(tensorOut->data(), std::vector({2, 4, 6})); + EXPECT_EQ(tensorOut->vector(), std::vector({2, 4, 6})); algo->rebuild({tensorOut, tensorA, tensorB}, spirv); @@ -98,7 +98,7 @@ TEST(TestSequence, RerecordSequence) sq->rerecord(); sq->eval(); - EXPECT_EQ(tensorB->data(), std::vector({2, 8, 18})); + EXPECT_EQ(tensorB->vector(), std::vector({2, 8, 18})); } diff --git a/test/TestSpecializationConstant.cpp b/test/TestSpecializationConstant.cpp index 2c6e284d2..fe40fb5ea 100644 --- a/test/TestSpecializationConstant.cpp +++ b/test/TestSpecializationConstant.cpp @@ -25,8 +25,8 @@ TEST(TestSpecializationConstants, TestTwoConstants) { kp::Manager mgr; - std::shared_ptr tensorA = mgr.tensor({ 0, 0, 0 }); - std::shared_ptr tensorB = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorA = mgr.tensor({ 0, 0, 0 }); + std::shared_ptr> tensorB = mgr.tensor({ 0, 0, 0 }); std::vector> params = { tensorA, tensorB }; @@ -42,8 +42,8 @@ TEST(TestSpecializationConstants, TestTwoConstants) ->record(params) ->eval(); - EXPECT_EQ(tensorA->data(), std::vector({ 5, 5, 5 })); - EXPECT_EQ(tensorB->data(), std::vector({ 0.3, 0.3, 0.3 })); + EXPECT_EQ(tensorA->vector(), std::vector({ 5, 5, 5 })); + EXPECT_EQ(tensorB->vector(), std::vector({ 0.3, 0.3, 0.3 })); } } } diff --git a/test/TestTensor.cpp b/test/TestTensor.cpp index d33367722..c267024db 100644 --- a/test/TestTensor.cpp +++ b/test/TestTensor.cpp @@ -7,7 +7,7 @@ TEST(TestTensor, ConstructorData) { kp::Manager mgr; std::vector vec{ 0, 1, 2 }; - std::shared_ptr tensor = mgr.tensor(vec); + std::shared_ptr> tensor = mgr.tensor(vec); EXPECT_EQ(tensor->size(), vec.size()); - EXPECT_EQ(tensor->data(), vec); + EXPECT_EQ(tensor->vector(), vec); } diff --git a/test/TestWorkgroup.cpp b/test/TestWorkgroup.cpp index 3eb9147a1..8836840a6 100644 --- a/test/TestWorkgroup.cpp +++ b/test/TestWorkgroup.cpp @@ -7,8 +7,8 @@ TEST(TestWorkgroup, TestSimpleWorkgroup) { - std::shared_ptr tensorA = nullptr; - std::shared_ptr tensorB = nullptr; + std::shared_ptr> tensorA = nullptr; + std::shared_ptr> tensorB = nullptr; { std::shared_ptr sq = nullptr; @@ -39,29 +39,29 @@ TEST(TestWorkgroup, TestSimpleWorkgroup) sq->record(algorithm); sq->record(params); sq->eval(); + + std::vector expectedA = { + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, + 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, + 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, + 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, + 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, + 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, + 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15 + }; + + std::vector expectedB = { + 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, + 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, + 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, + 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, + 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, + 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7 + }; + + EXPECT_EQ(tensorA->vector(), expectedA); + EXPECT_EQ(tensorB->vector(), expectedB); } } - - std::vector expectedA = { - 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, - 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, - 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, - 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, - 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, - 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, - 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, - 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15 - }; - - std::vector expectedB = { - 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, - 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, - 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, - 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, - 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, - 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7 - }; - - EXPECT_EQ(tensorA->data(), expectedA); - EXPECT_EQ(tensorB->data(), expectedB); }