thek0tyara/llama-cpp-turboquant
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 4

Initial base set of tests aligned with new interface

Browse source
This commit is contained in:
Alejandro Saucedo 2021-02-25 23:09:54 +00:00
parent 6378583a23
commit fb617d1722
16 changed files with 908 additions and 1071 deletions
Download patch file Download diff file Expand all files Collapse all files

7
single_include/kompute/Kompute.hpp
View file

@ -1341,6 +1341,7 @@ class Sequence: public std::enable_shared_from_this<Sequence>
*
* @return shared_ptr<Sequence> of the Sequence class itself
*/
// TODO: Aim to have only a single function with tensors/algorithm
template<typename T, typename... TArgs>
std::shared_ptr<Sequence>
eval(std::vector<std::shared_ptr<Tensor>> tensors, TArgs&&... params)
@ -1355,6 +1356,7 @@ class Sequence: public std::enable_shared_from_this<Sequence>
std::shared_ptr<T> op{
new T(tensors, std::forward<TArgs>(params)...) };
// TODO: Aim to be able to handle errors when returning without throw except
return this->eval(op);
}
// Needded as otherise can't use initialiser list
@ -1383,6 +1385,7 @@ class Sequence: public std::enable_shared_from_this<Sequence>
* @return Boolean stating whether execution was successful.
*/
std::shared_ptr<Sequence> evalAsync();
std::shared_ptr<Sequence> evalAsync(std::shared_ptr<OpBase> op);
/**
* Eval sends all the recorded and stored operations in the vector of
@ -1742,7 +1745,7 @@ class OpMult : public OpAlgoDispatch
* @param komputeWorkgroup Optional parameter to specify the layout for processing
*/
OpMult(std::vector<std::shared_ptr<Tensor>> tensors, std::shared_ptr<Algorithm> algorithm)
: OpAlgoDispatch(tensors, algorithm)
: OpAlgoDispatch(algorithm)
{
KP_LOG_DEBUG("Kompute OpMult constructor with params");
@ -1755,7 +1758,7 @@ class OpMult : public OpAlgoDispatch
(uint32_t*)(shader_data::shaders_glsl_opmult_comp_spv +
kp::shader_data::shaders_glsl_opmult_comp_spv_len));
algorithm->rebuild(tensors, spirv, Workgroup({tensors[0]->size()}));
algorithm->rebuild(tensors, spirv);
}
/**

19
src/Sequence.cpp
View file

@ -23,7 +23,7 @@ Sequence::~Sequence()
{
KP_LOG_DEBUG("Kompute Sequence Destructor started");
this->freeMemoryDestroyGPUResources();
this->destroy();
}
void
@ -112,6 +112,15 @@ Sequence::evalAsync()
return shared_from_this();
}
std::shared_ptr<Sequence>
Sequence::evalAsync(std::shared_ptr<OpBase> op)
{
this->clear();
this->record(op);
this->evalAsync();
return shared_from_this();
}
std::shared_ptr<Sequence>
Sequence::evalAwait(uint64_t waitFor)
{
@ -162,10 +171,10 @@ Sequence::isInit() {
void
Sequence::destroy()
{
KP_LOG_DEBUG("Kompute Sequence freeMemoryDestroyGPUResources called");
KP_LOG_DEBUG("Kompute Sequence destroy called");
if (!this->mDevice) {
KP_LOG_ERROR("Kompute Sequence freeMemoryDestroyGPUResources called "
KP_LOG_ERROR("Kompute Sequence destroy called "
"with null Device pointer");
return;
}
@ -174,7 +183,7 @@ Sequence::destroy()
KP_LOG_INFO("Freeing CommandBuffer");
if (!this->mCommandBuffer) {
KP_LOG_ERROR(
"Kompute Sequence freeMemoryDestroyGPUResources called with null "
"Kompute Sequence destroy called with null "
"CommandPool pointer");
return;
}
@ -191,7 +200,7 @@ Sequence::destroy()
KP_LOG_INFO("Destroying CommandPool");
if (this->mCommandPool == nullptr) {
KP_LOG_ERROR(
"Kompute Sequence freeMemoryDestroyGPUResources called with null "
"Kompute Sequence destroy called with null "
"CommandPool pointer");
return;
}

8
src/Tensor.cpp
View file

@ -23,7 +23,7 @@ Tensor::~Tensor()
KP_LOG_DEBUG("Kompute Tensor destructor started. Type: {}",
this->tensorType());
this->freeMemoryDestroyGPUResources();
this->destroy();
KP_LOG_DEBUG("Kompute Tensor destructor success");
}
@ -40,7 +40,7 @@ Tensor::rebuild(const std::vector<float>& data,
if (this->mPrimaryBuffer || this->mPrimaryMemory) {
KP_LOG_DEBUG("Kompute Tensor destroying existing resources before rebuild");
this->freeMemoryDestroyGPUResources();
this->destroy();
}
this->allocateMemoryCreateGPUResources();
@ -440,7 +440,7 @@ Tensor::allocateBindMemory(std::shared_ptr<vk::Buffer> buffer,
void
Tensor::destroy()
{
KP_LOG_DEBUG("Kompute Tensor started freeMemoryDestroyGPUResources()");
KP_LOG_DEBUG("Kompute Tensor started destroy()");
if (!this->mDevice) {
KP_LOG_ERROR(
@ -508,7 +508,7 @@ Tensor::destroy()
this->mDevice = nullptr;
}
KP_LOG_DEBUG("Kompute Tensor successful freeMemoryDestroyGPUResources()");
KP_LOG_DEBUG("Kompute Tensor successful destroy()");
}
}

1
src/include/kompute/Sequence.hpp
View file

@ -138,6 +138,7 @@ class Sequence: public std::enable_shared_from_this<Sequence>
* @return Boolean stating whether execution was successful.
*/
std::shared_ptr<Sequence> evalAsync();
std::shared_ptr<Sequence> evalAsync(std::shared_ptr<OpBase> op);
/**
* Eval sends all the recorded and stored operations in the vector of

4
src/include/kompute/operations/OpMult.hpp
View file

@ -33,7 +33,7 @@ class OpMult : public OpAlgoDispatch
* @param komputeWorkgroup Optional parameter to specify the layout for processing
*/
OpMult(std::vector<std::shared_ptr<Tensor>> tensors, std::shared_ptr<Algorithm> algorithm)
: OpAlgoDispatch(tensors, algorithm)
: OpAlgoDispatch(algorithm)
{
KP_LOG_DEBUG("Kompute OpMult constructor with params");
@ -46,7 +46,7 @@ class OpMult : public OpAlgoDispatch
(uint32_t*)(shader_data::shaders_glsl_opmult_comp_spv +
kp::shader_data::shaders_glsl_opmult_comp_spv_len));
algorithm->rebuild(tensors, spirv, Workgroup({tensors[0]->size()}));
algorithm->rebuild(tensors, spirv);
}
/**

128
test/TestManager.cpp
View file

@ -3,53 +3,41 @@
#include "kompute/Kompute.hpp"
TEST(TestManager, EndToEndOpMultFlow)
TEST(TestManager, EndToEndOpMultEvalFlow)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorLHS{ new kp::Tensor({ 0, 1, 2 }) };
mgr.rebuild({ tensorLHS });
std::shared_ptr<kp::Tensor> tensorLHS = mgr.tensor({ 0, 1, 2 });
std::shared_ptr<kp::Tensor> tensorRHS = mgr.tensor({ 2, 4, 6 });
std::shared_ptr<kp::Tensor> tensorOutput = mgr.tensor({ 0, 0, 0 });
std::shared_ptr<kp::Tensor> tensorRHS{ new kp::Tensor({ 2, 4, 6 }) };
mgr.rebuild({ tensorRHS });
std::vector<std::shared_ptr<kp::Tensor>> params =
{ tensorLHS, tensorRHS, tensorOutput };
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor({ 0, 0, 0 }) };
mgr.rebuild({ tensorOutput });
mgr.evalOpDefault<kp::OpMult>({ tensorLHS, tensorRHS, tensorOutput });
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorOutput });
mgr.sequence()
->eval<kp::OpTensorSyncDevice>(params)
->eval<kp::OpMult>(params, mgr.algorithm())
->eval<kp::OpTensorSyncLocal>(params);
EXPECT_EQ(tensorOutput->data(), std::vector<float>({ 0, 4, 12 }));
}
TEST(TestManager, OpMultSequenceFlow)
TEST(TestManager, EndToEndOpMultSeqFlow)
{
std::shared_ptr<kp::Tensor> tensorLHS{ new kp::Tensor({ 0, 1, 2 }) };
std::shared_ptr<kp::Tensor> tensorRHS{ new kp::Tensor({ 2, 4, 6 }) };
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor({ 0, 0, 0 }) };
kp::Manager mgr;
{
mgr.rebuild({ tensorLHS, tensorRHS, tensorOutput });
std::shared_ptr<kp::Tensor> tensorLHS = mgr.tensor({ 0, 1, 2 });
std::shared_ptr<kp::Tensor> tensorRHS = mgr.tensor({ 2, 4, 6 });
std::shared_ptr<kp::Tensor> tensorOutput = mgr.tensor({ 0, 0, 0 });
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("newSequence");
std::vector<std::shared_ptr<kp::Tensor>> params =
{ tensorLHS, tensorRHS, tensorOutput };
sq->begin();
sq->record<kp::OpMult>({ tensorLHS, tensorRHS, tensorOutput });
sq->record<kp::OpTensorSyncLocal>({ tensorOutput });
sq->end();
sq->eval();
}
mgr.sequence()
->record<kp::OpTensorSyncDevice>(params)
->record<kp::OpMult>(params, mgr.algorithm())
->record<kp::OpTensorSyncLocal>(params)
->eval();
EXPECT_EQ(tensorOutput->data(), std::vector<float>({ 0, 4, 12 }));
}
@ -58,75 +46,17 @@ TEST(TestManager, TestMultipleSequences)
{
kp::Manager mgr;
std::shared_ptr<kp::Sequence> sqOne =
mgr.sequence("sqOne");
std::shared_ptr<kp::Tensor> tensorLHS = mgr.tensor({ 0, 1, 2 });
std::shared_ptr<kp::Tensor> tensorRHS = mgr.tensor({ 2, 4, 6 });
std::shared_ptr<kp::Tensor> tensorOutput = mgr.tensor({ 0, 0, 0 });
std::shared_ptr<kp::Sequence> sqTwo =
mgr.sequence("sqTwo");
std::vector<std::shared_ptr<kp::Tensor>> params =
{ tensorLHS, tensorRHS, tensorOutput };
std::shared_ptr<kp::Sequence> sqOneRef =
mgr.sequence("sqOne");
std::shared_ptr<kp::Sequence> sqTwoRef =
mgr.sequence("sqTwo");
EXPECT_EQ(sqOne, sqOneRef);
EXPECT_NE(sqTwo, sqOneRef);
EXPECT_EQ(sqTwo, sqTwoRef);
EXPECT_NE(sqOneRef, sqTwoRef);
}
TEST(TestManager, TestMultipleTensorsAtOnce)
{
std::shared_ptr<kp::Tensor> tensorLHS{ new kp::Tensor({ 0, 1, 2 }) };
std::shared_ptr<kp::Tensor> tensorRHS{ new kp::Tensor({ 2, 4, 6 }) };
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor({ 0, 0, 0 }) };
kp::Manager mgr;
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("newSequence");
{
mgr.rebuild({ tensorLHS, tensorRHS, tensorOutput });
EXPECT_TRUE(tensorLHS->isInit());
EXPECT_TRUE(tensorRHS->isInit());
EXPECT_TRUE(tensorOutput->isInit());
sq->begin();
sq->record<kp::OpMult>({ tensorLHS, tensorRHS, tensorOutput });
sq->record<kp::OpTensorSyncLocal>({ tensorOutput });
sq->end();
sq->eval();
}
mgr.sequence()->eval<kp::OpTensorSyncDevice>(params);
mgr.sequence()->eval<kp::OpMult>(params, mgr.algorithm());
mgr.sequence()->eval<kp::OpTensorSyncLocal>(params);
EXPECT_EQ(tensorOutput->data(), std::vector<float>({ 0, 4, 12 }));
}
TEST(TestManager, TestCreateInitTensor)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA = mgr.tensor({ 0, 1, 2 });
std::shared_ptr<kp::Tensor> tensorB = mgr.tensor({ 0, 0, 0 });
mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
EXPECT_EQ(tensorB->data(), std::vector<float>({ 0, 1, 2 }));
std::shared_ptr<kp::Tensor> tensorC =
mgr.tensor({ 0, 0, 0 }, kp::Tensor::TensorTypes::eHost);
mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorC });
EXPECT_EQ(tensorC->data(), std::vector<float>({ 0, 1, 2 }));
}

696
test/TestMultipleAlgoExecutions.cpp
View file

@ -3,351 +3,351 @@
#include "kompute/Kompute.hpp"
TEST(TestMultipleAlgoExecutions, SingleSequenceRecord)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
std::string shader(R"(
#version 450
layout (local_size_x = 1) in;
layout(set = 0, binding = 0) buffer a { float pa[]; };
void main() {
uint index = gl_GlobalInvocationID.x;
pa[index] = pa[index] + 1;
})");
mgr.rebuild({ tensorA });
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("newSequence");
{
sq->begin();
sq->record<kp::OpAlgoCreate>(
{ tensorA }, kp::Shader::compile_source(shader));
sq->record<kp::OpAlgoCreate>(
{ tensorA }, kp::Shader::compile_source(shader));
sq->record<kp::OpAlgoCreate>(
{ tensorA }, kp::Shader::compile_source(shader));
sq->record<kp::OpTensorSyncLocal>({ tensorA });
sq->end();
sq->eval();
}
EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
}
TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
std::string shader(R"(
#version 450
layout (local_size_x = 1) in;
layout(set = 0, binding = 0) buffer a { float pa[]; };
void main() {
uint index = gl_GlobalInvocationID.x;
pa[index] = pa[index] + 1;
})");
mgr.rebuild({ tensorA }, false);
std::shared_ptr<kp::Sequence> sqTensor = mgr.sequence();
std::shared_ptr<kp::Sequence> sq = mgr.sequence();
// First create the tensor in a separate sequence
sqTensor->begin();
sqTensor->record<kp::OpTensorSyncDevice>({ tensorA });
sqTensor->end();
sqTensor->eval();
// Then perform the computations
sq->begin();
sq->record<kp::OpAlgoCreate>({ tensorA },
kp::Shader::compile_source(shader));
sq->end();
sq->eval();
sq->begin();
sq->record<kp::OpAlgoCreate>({ tensorA },
kp::Shader::compile_source(shader));
sq->end();
sq->eval();
sq->begin();
sq->record<kp::OpAlgoCreate>({ tensorA },
kp::Shader::compile_source(shader));
sq->end();
sq->eval();
sq->begin();
sq->record<kp::OpTensorSyncLocal>({ tensorA });
sq->end();
sq->eval();
EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
}
TEST(TestMultipleAlgoExecutions, MultipleSequences)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
std::string shader(R"(
#version 450
layout (local_size_x = 1) in;
layout(set = 0, binding = 0) buffer a { float pa[]; };
void main() {
uint index = gl_GlobalInvocationID.x;
pa[index] = pa[index] + 1;
})");
mgr.rebuild({ tensorA });
{
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("newSequence");
sq->begin();
sq->record<kp::OpAlgoCreate>(
{ tensorA }, kp::Shader::compile_source(shader));
sq->end();
sq->eval();
}
{
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("newSequence2");
sq->begin();
sq->record<kp::OpAlgoCreate>(
{ tensorA }, kp::Shader::compile_source(shader));
sq->end();
sq->eval();
}
{
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("newSequence3");
sq->begin();
sq->record<kp::OpAlgoCreate>(
{ tensorA }, kp::Shader::compile_source(shader));
sq->end();
sq->eval();
}
{
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("newSequence5");
sq->begin();
sq->record<kp::OpTensorSyncLocal>({ tensorA });
sq->end();
sq->eval();
}
EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
}
TEST(TestMultipleAlgoExecutions, SingleRecordMultipleEval)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
std::string shader(R"(
#version 450
layout (local_size_x = 1) in;
layout(set = 0, binding = 0) buffer a { float pa[]; };
void main() {
uint index = gl_GlobalInvocationID.x;
pa[index] = pa[index] + 1;
})");
mgr.rebuild({ tensorA }, false);
{
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("newSequence");
sq->begin();
sq->record<kp::OpTensorSyncDevice>({ tensorA });
sq->end();
sq->eval();
}
{
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("newSequence2");
sq->begin();
sq->record<kp::OpAlgoCreate>(
{ tensorA }, kp::Shader::compile_source(shader));
sq->end();
sq->eval();
sq->eval();
sq->eval();
}
{
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("newSequence3");
sq->begin();
sq->record<kp::OpTensorSyncLocal>({ tensorA });
sq->end();
sq->eval();
sq->eval();
sq->eval();
}
EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
}
TEST(TestMultipleAlgoExecutions, ManagerEvalMultSourceStrOpCreate)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorInA{ new kp::Tensor({ 2.0, 4.0, 6.0 }) };
std::shared_ptr<kp::Tensor> tensorInB{ new kp::Tensor({ 0.0, 1.0, 2.0 }) };
std::shared_ptr<kp::Tensor> tensorOut{ new kp::Tensor({ 0.0, 0.0, 0.0 }) };
mgr.rebuild({ tensorInA, tensorInB, tensorOut });
std::string shader(R"(
// The version to use
#version 450
// The execution structure
layout (local_size_x = 1) in;
// The buffers are provided via the tensors
layout(binding = 0) buffer bufA { float a[]; };
layout(binding = 1) buffer bufB { float b[]; };
layout(binding = 2) buffer bufOut { float o[]; };
void main() {
uint index = gl_GlobalInvocationID.x;
o[index] = a[index] * b[index];
}
)");
mgr.evalOpDefault<kp::OpAlgoCreate>(
{ tensorInA, tensorInB, tensorOut },
kp::Shader::compile_source(shader));
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorOut });
EXPECT_EQ(tensorOut->data(), std::vector<float>({ 0.0, 4.0, 12.0 }));
}
TEST(TestMultipleAlgoExecutions, ManagerEvalMultSourceStrMgrCreate)
{
kp::Manager mgr;
auto tensorInA = mgr.tensor(
{ 2.0, 4.0, 6.0 }, kp::Tensor::TensorTypes::eDevice, false);
auto tensorInB = mgr.tensor(
{ 0.0, 1.0, 2.0 }, kp::Tensor::TensorTypes::eDevice, false);
auto tensorOut = mgr.tensor(
{ 0.0, 0.0, 0.0 }, kp::Tensor::TensorTypes::eDevice, false);
std::string shader(R"(
// The version to use
#version 450
// The execution structure
layout (local_size_x = 1) in;
// The buffers are provided via the tensors
layout(binding = 0) buffer bufA { float a[]; };
layout(binding = 1) buffer bufB { float b[]; };
layout(binding = 2) buffer bufOut { float o[]; };
void main() {
uint index = gl_GlobalInvocationID.x;
o[index] = a[index] * b[index];
}
)");
mgr.evalOpDefault<kp::OpTensorSyncDevice>(
{ tensorInA, tensorInB, tensorOut });
mgr.evalOpDefault<kp::OpAlgoCreate>(
{ tensorInA, tensorInB, tensorOut },
kp::Shader::compile_source(shader));
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorOut });
EXPECT_EQ(tensorOut->data(), std::vector<float>({ 0.0, 4.0, 12.0 }));
}
TEST(TestMultipleAlgoExecutions, SequenceAlgoDestroyOutsideManagerScope)
{
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
std::string shader(R"(
#version 450
layout (local_size_x = 1) in;
layout(set = 0, binding = 0) buffer a { float pa[]; };
void main() {
uint index = gl_GlobalInvocationID.x;
pa[index] = pa[index] + 1;
})");
{
std::shared_ptr<kp::Sequence> sq = nullptr;
{
kp::Manager mgr;
mgr.rebuild({ tensorA });
sq = mgr.sequence();
sq->begin();
sq->record<kp::OpAlgoCreate>(
{ tensorA }, kp::Shader::compile_source(shader));
sq->end();
sq->eval();
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA });
}
}
EXPECT_EQ(tensorA->data(), std::vector<float>({ 1, 1, 1 }));
}
//TEST(TestMultipleAlgoExecutions, SingleSequenceRecord)
//{
//
// kp::Manager mgr;
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
//
// std::string shader(R"(
// #version 450
// layout (local_size_x = 1) in;
// layout(set = 0, binding = 0) buffer a { float pa[]; };
// void main() {
// uint index = gl_GlobalInvocationID.x;
// pa[index] = pa[index] + 1;
// })");
//
// mgr.rebuild({ tensorA });
//
// std::shared_ptr<kp::Sequence> sq =
// mgr.sequence("newSequence");
//
// {
// sq->begin();
//
// sq->record<kp::OpAlgoCreate>(
// { tensorA }, kp::Shader::compile_source(shader));
// sq->record<kp::OpAlgoCreate>(
// { tensorA }, kp::Shader::compile_source(shader));
// sq->record<kp::OpAlgoCreate>(
// { tensorA }, kp::Shader::compile_source(shader));
//
// sq->record<kp::OpTensorSyncLocal>({ tensorA });
//
// sq->end();
// sq->eval();
// }
//
// EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
//}
//
//TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords)
//{
// kp::Manager mgr;
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
//
// std::string shader(R"(
// #version 450
// layout (local_size_x = 1) in;
// layout(set = 0, binding = 0) buffer a { float pa[]; };
// void main() {
// uint index = gl_GlobalInvocationID.x;
// pa[index] = pa[index] + 1;
// })");
//
// mgr.rebuild({ tensorA }, false);
//
// std::shared_ptr<kp::Sequence> sqTensor = mgr.sequence();
//
// std::shared_ptr<kp::Sequence> sq = mgr.sequence();
//
// // First create the tensor in a separate sequence
// sqTensor->begin();
// sqTensor->record<kp::OpTensorSyncDevice>({ tensorA });
// sqTensor->end();
// sqTensor->eval();
//
// // Then perform the computations
// sq->begin();
// sq->record<kp::OpAlgoCreate>({ tensorA },
// kp::Shader::compile_source(shader));
// sq->end();
// sq->eval();
//
// sq->begin();
// sq->record<kp::OpAlgoCreate>({ tensorA },
// kp::Shader::compile_source(shader));
// sq->end();
// sq->eval();
//
// sq->begin();
// sq->record<kp::OpAlgoCreate>({ tensorA },
// kp::Shader::compile_source(shader));
// sq->end();
// sq->eval();
//
// sq->begin();
// sq->record<kp::OpTensorSyncLocal>({ tensorA });
// sq->end();
// sq->eval();
//
// EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
//}
//
//TEST(TestMultipleAlgoExecutions, MultipleSequences)
//{
//
// kp::Manager mgr;
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
//
// std::string shader(R"(
// #version 450
// layout (local_size_x = 1) in;
// layout(set = 0, binding = 0) buffer a { float pa[]; };
// void main() {
// uint index = gl_GlobalInvocationID.x;
// pa[index] = pa[index] + 1;
// })");
//
// mgr.rebuild({ tensorA });
//
// {
// std::shared_ptr<kp::Sequence> sq =
// mgr.sequence("newSequence");
//
// sq->begin();
//
// sq->record<kp::OpAlgoCreate>(
// { tensorA }, kp::Shader::compile_source(shader));
//
// sq->end();
// sq->eval();
// }
//
// {
// std::shared_ptr<kp::Sequence> sq =
// mgr.sequence("newSequence2");
//
// sq->begin();
//
// sq->record<kp::OpAlgoCreate>(
// { tensorA }, kp::Shader::compile_source(shader));
//
// sq->end();
// sq->eval();
// }
//
// {
// std::shared_ptr<kp::Sequence> sq =
// mgr.sequence("newSequence3");
//
// sq->begin();
//
// sq->record<kp::OpAlgoCreate>(
// { tensorA }, kp::Shader::compile_source(shader));
//
// sq->end();
// sq->eval();
// }
//
// {
// std::shared_ptr<kp::Sequence> sq =
// mgr.sequence("newSequence5");
//
// sq->begin();
//
// sq->record<kp::OpTensorSyncLocal>({ tensorA });
//
// sq->end();
// sq->eval();
// }
//
// EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
//}
//
//TEST(TestMultipleAlgoExecutions, SingleRecordMultipleEval)
//{
//
// kp::Manager mgr;
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
//
// std::string shader(R"(
// #version 450
// layout (local_size_x = 1) in;
// layout(set = 0, binding = 0) buffer a { float pa[]; };
// void main() {
// uint index = gl_GlobalInvocationID.x;
// pa[index] = pa[index] + 1;
// })");
//
// mgr.rebuild({ tensorA }, false);
//
// {
// std::shared_ptr<kp::Sequence> sq =
// mgr.sequence("newSequence");
//
// sq->begin();
//
// sq->record<kp::OpTensorSyncDevice>({ tensorA });
//
// sq->end();
// sq->eval();
// }
//
// {
// std::shared_ptr<kp::Sequence> sq =
// mgr.sequence("newSequence2");
//
// sq->begin();
//
// sq->record<kp::OpAlgoCreate>(
// { tensorA }, kp::Shader::compile_source(shader));
//
// sq->end();
//
// sq->eval();
// sq->eval();
// sq->eval();
// }
//
// {
// std::shared_ptr<kp::Sequence> sq =
// mgr.sequence("newSequence3");
//
// sq->begin();
//
// sq->record<kp::OpTensorSyncLocal>({ tensorA });
//
// sq->end();
//
// sq->eval();
// sq->eval();
// sq->eval();
// }
//
// EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
//}
//
//TEST(TestMultipleAlgoExecutions, ManagerEvalMultSourceStrOpCreate)
//{
//
// kp::Manager mgr;
//
// std::shared_ptr<kp::Tensor> tensorInA{ new kp::Tensor({ 2.0, 4.0, 6.0 }) };
// std::shared_ptr<kp::Tensor> tensorInB{ new kp::Tensor({ 0.0, 1.0, 2.0 }) };
// std::shared_ptr<kp::Tensor> tensorOut{ new kp::Tensor({ 0.0, 0.0, 0.0 }) };
//
// mgr.rebuild({ tensorInA, tensorInB, tensorOut });
//
// std::string shader(R"(
// // The version to use
// #version 450
//
// // The execution structure
// layout (local_size_x = 1) in;
//
// // The buffers are provided via the tensors
// layout(binding = 0) buffer bufA { float a[]; };
// layout(binding = 1) buffer bufB { float b[]; };
// layout(binding = 2) buffer bufOut { float o[]; };
//
// void main() {
// uint index = gl_GlobalInvocationID.x;
//
// o[index] = a[index] * b[index];
// }
// )");
//
// mgr.evalOpDefault<kp::OpAlgoCreate>(
// { tensorInA, tensorInB, tensorOut },
// kp::Shader::compile_source(shader));
//
// mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorOut });
//
// EXPECT_EQ(tensorOut->data(), std::vector<float>({ 0.0, 4.0, 12.0 }));
//}
//
//TEST(TestMultipleAlgoExecutions, ManagerEvalMultSourceStrMgrCreate)
//{
//
// kp::Manager mgr;
//
// auto tensorInA = mgr.tensor(
// { 2.0, 4.0, 6.0 }, kp::Tensor::TensorTypes::eDevice, false);
// auto tensorInB = mgr.tensor(
// { 0.0, 1.0, 2.0 }, kp::Tensor::TensorTypes::eDevice, false);
// auto tensorOut = mgr.tensor(
// { 0.0, 0.0, 0.0 }, kp::Tensor::TensorTypes::eDevice, false);
//
// std::string shader(R"(
// // The version to use
// #version 450
//
// // The execution structure
// layout (local_size_x = 1) in;
//
// // The buffers are provided via the tensors
// layout(binding = 0) buffer bufA { float a[]; };
// layout(binding = 1) buffer bufB { float b[]; };
// layout(binding = 2) buffer bufOut { float o[]; };
//
// void main() {
// uint index = gl_GlobalInvocationID.x;
//
// o[index] = a[index] * b[index];
// }
// )");
//
// mgr.evalOpDefault<kp::OpTensorSyncDevice>(
// { tensorInA, tensorInB, tensorOut });
//
// mgr.evalOpDefault<kp::OpAlgoCreate>(
// { tensorInA, tensorInB, tensorOut },
// kp::Shader::compile_source(shader));
//
// mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorOut });
//
// EXPECT_EQ(tensorOut->data(), std::vector<float>({ 0.0, 4.0, 12.0 }));
//}
//
//TEST(TestMultipleAlgoExecutions, SequenceAlgoDestroyOutsideManagerScope)
//{
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
//
// std::string shader(R"(
// #version 450
// layout (local_size_x = 1) in;
// layout(set = 0, binding = 0) buffer a { float pa[]; };
// void main() {
// uint index = gl_GlobalInvocationID.x;
// pa[index] = pa[index] + 1;
// })");
//
// {
// std::shared_ptr<kp::Sequence> sq = nullptr;
//
// {
// kp::Manager mgr;
//
// mgr.rebuild({ tensorA });
//
// sq = mgr.sequence();
//
// sq->begin();
// sq->record<kp::OpAlgoCreate>(
// { tensorA }, kp::Shader::compile_source(shader));
// sq->end();
//
// sq->eval();
//
// mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA });
// }
// }
// EXPECT_EQ(tensorA->data(), std::vector<float>({ 1, 1, 1 }));
//}
//

80
test/TestOpAlgoLoopsPassingData.cpp
View file

@ -1,80 +0,0 @@
#include "gtest/gtest.h"
#include "kompute/Kompute.hpp"
TEST(TestProcessingIterations, IterateThroughMultipleSumAndCopies)
{
kp::Manager mgr;
float TOTAL_ITER = 10;
std::vector<float> testExpectedOutVec = { TOTAL_ITER,
TOTAL_ITER,
TOTAL_ITER };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor({ 0, 0, 0 }) };
std::string shader(R"(
#version 450
layout (local_size_x = 1) in;
layout(set = 0, binding = 0) buffer a { float pa[]; };
layout(set = 0, binding = 1) buffer b { float pb[]; };
void main() {
uint index = gl_GlobalInvocationID.x;
pb[index] = pa[index] + 1;
}
)");
mgr.rebuild({ tensorA, tensorB }, false);
{
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("default");
sq->begin();
sq->record<kp::OpTensorSyncDevice>({ tensorA, tensorB });
sq->end();
sq->eval();
}
{
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("run");
sq->begin();
sq->record<kp::OpAlgoCreate>(
{ tensorA, tensorB },
kp::Shader::compile_source(shader));
sq->record<kp::OpTensorCopy>({ tensorB, tensorA });
sq->end();
for (size_t i = 0; i < TOTAL_ITER; i++) {
sq->eval();
}
}
{
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("export");
sq->begin();
sq->record<kp::OpTensorSyncLocal>({ tensorA, tensorB });
sq->end();
sq->eval();
}
EXPECT_EQ(tensorA->data(), testExpectedOutVec);
}

140
test/TestOpShadersFromStringAndFile.cpp
View file

@ -5,73 +5,73 @@
#include "kompute_test/shaders/shadertest_op_custom_shader.hpp"
TEST(TestOpAlgoCreate, ShaderRawDataFromConstructor)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 3, 4, 5 }) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor({ 0, 0, 0 }) };
mgr.rebuild({ tensorA, tensorB });
std::string shader(R"(
#version 450
layout (local_size_x = 1) in;
layout(set = 0, binding = 0) buffer a { float pa[]; };
layout(set = 0, binding = 1) buffer b { float pb[]; };
void main() {
uint index = gl_GlobalInvocationID.x;
pb[index] = pa[index];
pa[index] = index;
}
)");
mgr.evalOpDefault<kp::OpAlgoCreate>(
{ tensorA, tensorB }, kp::Shader::compile_source(shader));
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA, tensorB });
EXPECT_EQ(tensorA->data(), std::vector<float>({ 0, 1, 2 }));
EXPECT_EQ(tensorB->data(), std::vector<float>({ 3, 4, 5 }));
}
TEST(TestOpAlgoCreate, ShaderCompiledDataFromConstructor)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 3, 4, 5 }) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor({ 0, 0, 0 }) };
mgr.rebuild({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpAlgoCreate>(
{ tensorA, tensorB },
std::vector<uint32_t>(
(uint32_t*)kp::shader_data::test_shaders_glsl_test_op_custom_shader_comp_spv,
(uint32_t*)(kp::shader_data::test_shaders_glsl_test_op_custom_shader_comp_spv +
kp::shader_data::
test_shaders_glsl_test_op_custom_shader_comp_spv_len)));
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA, tensorB });
EXPECT_EQ(tensorA->data(), std::vector<float>({ 0, 1, 2 }));
EXPECT_EQ(tensorB->data(), std::vector<float>({ 3, 4, 5 }));
}
TEST(TestOpAlgoCreate, ShaderCompiledDataFromFile)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 3, 4, 5 }) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor({ 0, 0, 0 }) };
mgr.rebuild({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpAlgoCreate>(
{ tensorA, tensorB }, "test/shaders/glsl/test_op_custom_shader.comp.spv");
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA, tensorB });
EXPECT_EQ(tensorA->data(), std::vector<float>({ 0, 1, 2 }));
EXPECT_EQ(tensorB->data(), std::vector<float>({ 3, 4, 5 }));
}
//TEST(TestOpAlgoCreate, ShaderRawDataFromConstructor)
//{
// kp::Manager mgr;
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 3, 4, 5 }) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor({ 0, 0, 0 }) };
// mgr.rebuild({ tensorA, tensorB });
//
// std::string shader(R"(
// #version 450
//
// layout (local_size_x = 1) in;
//
// layout(set = 0, binding = 0) buffer a { float pa[]; };
// layout(set = 0, binding = 1) buffer b { float pb[]; };
//
// void main() {
// uint index = gl_GlobalInvocationID.x;
// pb[index] = pa[index];
// pa[index] = index;
// }
// )");
//
// mgr.evalOpDefault<kp::OpAlgoCreate>(
// { tensorA, tensorB }, kp::Shader::compile_source(shader));
//
// mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA, tensorB });
//
// EXPECT_EQ(tensorA->data(), std::vector<float>({ 0, 1, 2 }));
// EXPECT_EQ(tensorB->data(), std::vector<float>({ 3, 4, 5 }));
//}
//
//TEST(TestOpAlgoCreate, ShaderCompiledDataFromConstructor)
//{
// kp::Manager mgr;
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 3, 4, 5 }) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor({ 0, 0, 0 }) };
// mgr.rebuild({ tensorA, tensorB });
//
// mgr.evalOpDefault<kp::OpAlgoCreate>(
// { tensorA, tensorB },
// std::vector<uint32_t>(
// (uint32_t*)kp::shader_data::test_shaders_glsl_test_op_custom_shader_comp_spv,
// (uint32_t*)(kp::shader_data::test_shaders_glsl_test_op_custom_shader_comp_spv +
// kp::shader_data::
// test_shaders_glsl_test_op_custom_shader_comp_spv_len)));
//
// mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA, tensorB });
//
// EXPECT_EQ(tensorA->data(), std::vector<float>({ 0, 1, 2 }));
// EXPECT_EQ(tensorB->data(), std::vector<float>({ 3, 4, 5 }));
//}
//
//TEST(TestOpAlgoCreate, ShaderCompiledDataFromFile)
//{
// kp::Manager mgr;
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 3, 4, 5 }) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor({ 0, 0, 0 }) };
// mgr.rebuild({ tensorA, tensorB });
//
// mgr.evalOpDefault<kp::OpAlgoCreate>(
// { tensorA, tensorB }, "test/shaders/glsl/test_op_custom_shader.comp.spv");
//
// mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA, tensorB });
//
// EXPECT_EQ(tensorA->data(), std::vector<float>({ 0, 1, 2 }));
// EXPECT_EQ(tensorB->data(), std::vector<float>({ 3, 4, 5 }));
//}

320
test/TestOpTensorCopy.cpp
View file

@ -3,163 +3,163 @@
#include "kompute/Kompute.hpp"
TEST(TestOpTensorCopy, CopyDeviceToDeviceTensor)
{
kp::Manager mgr;
std::vector<float> testVecA{ 1, 2, 3 };
std::vector<float> testVecB{ 0, 0, 0 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
mgr.rebuild({ tensorA, tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB });
EXPECT_EQ(tensorA->data(), tensorB->data());
// Making sure the GPU holds the same data
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
EXPECT_EQ(tensorA->data(), tensorB->data());
}
TEST(TestOpTensorCopy, CopyDeviceToDeviceTensorMulti)
{
kp::Manager mgr;
std::vector<float> testVecA{ 2, 3, 4 };
std::vector<float> testVecB{ 0, 0, 0 };
std::vector<float> testVecC{ 0, 0, 0 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
std::shared_ptr<kp::Tensor> tensorC{ new kp::Tensor(testVecC) };
mgr.rebuild({ tensorA, tensorB, tensorC });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
EXPECT_TRUE(tensorC->isInit());
mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB, tensorC });
EXPECT_EQ(tensorA->data(), tensorB->data());
EXPECT_EQ(tensorA->data(), tensorC->data());
// Making sure the GPU holds the same data
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB, tensorC });
EXPECT_EQ(tensorA->data(), tensorB->data());
EXPECT_EQ(tensorA->data(), tensorC->data());
}
TEST(TestOpTensorCopy, CopyDeviceToHostTensor)
{
kp::Manager mgr;
std::vector<float> testVecA{ 3, 4, 5 };
std::vector<float> testVecB{ 0, 0, 0 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(
testVecB, kp::Tensor::TensorTypes::eHost) };
mgr.rebuild({ tensorA, tensorB }, false);
// Only calling sync on device type tensor
mgr.evalOpDefault<kp::OpTensorSyncDevice>({ tensorA });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB });
EXPECT_EQ(tensorA->data(), tensorB->data());
// Making sure the GPU holds the same data
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
EXPECT_EQ(tensorA->data(), tensorB->data());
}
TEST(TestOpTensorCopy, CopyHostToDeviceTensor)
{
kp::Manager mgr;
std::vector<float> testVecA{ 4, 5, 6 };
std::vector<float> testVecB{ 0, 0, 0 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(
testVecA, kp::Tensor::TensorTypes::eHost) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
mgr.rebuild({ tensorA, tensorB }, false);
// Manually copy data into host memory of Tensor
tensorA->mapDataIntoHostMemory();
// Only calling sync on device type tensor
mgr.evalOpDefault<kp::OpTensorSyncDevice>({ tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB });
EXPECT_EQ(tensorA->data(), tensorB->data());
// Making sure the GPU holds the same data
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
EXPECT_EQ(tensorA->data(), tensorB->data());
}
TEST(TestOpTensorCopy, CopyHostToHostTensor)
{
kp::Manager mgr;
std::vector<float> testVecA{ 5, 6, 7 };
std::vector<float> testVecB{ 0, 0, 0 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(
testVecA, kp::Tensor::TensorTypes::eHost) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(
testVecB, kp::Tensor::TensorTypes::eHost) };
mgr.rebuild({ tensorA, tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB });
EXPECT_EQ(tensorA->data(), tensorB->data());
// Making sure the GPU holds the same data
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
EXPECT_EQ(tensorA->data(), tensorB->data());
}
TEST(TestOpTensorCopy, SingleTensorShouldFail)
{
kp::Manager mgr;
std::vector<float> testVecA{ 6, 7, 8 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(
testVecA, kp::Tensor::TensorTypes::eHost) };
mgr.rebuild({ tensorA }, false);
EXPECT_TRUE(tensorA->isInit());
EXPECT_THROW(mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA }),
std::runtime_error);
}
//TEST(TestOpTensorCopy, CopyDeviceToDeviceTensor)
//{
//
// kp::Manager mgr;
//
// std::vector<float> testVecA{ 1, 2, 3 };
// std::vector<float> testVecB{ 0, 0, 0 };
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
//
// mgr.rebuild({ tensorA, tensorB });
//
// EXPECT_TRUE(tensorA->isInit());
// EXPECT_TRUE(tensorB->isInit());
//
// mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB });
//
// EXPECT_EQ(tensorA->data(), tensorB->data());
//
// // Making sure the GPU holds the same data
// mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
// EXPECT_EQ(tensorA->data(), tensorB->data());
//}
//
//TEST(TestOpTensorCopy, CopyDeviceToDeviceTensorMulti)
//{
//
// kp::Manager mgr;
//
// std::vector<float> testVecA{ 2, 3, 4 };
// std::vector<float> testVecB{ 0, 0, 0 };
// std::vector<float> testVecC{ 0, 0, 0 };
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
// std::shared_ptr<kp::Tensor> tensorC{ new kp::Tensor(testVecC) };
//
// mgr.rebuild({ tensorA, tensorB, tensorC });
//
// EXPECT_TRUE(tensorA->isInit());
// EXPECT_TRUE(tensorB->isInit());
// EXPECT_TRUE(tensorC->isInit());
//
// mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB, tensorC });
//
// EXPECT_EQ(tensorA->data(), tensorB->data());
// EXPECT_EQ(tensorA->data(), tensorC->data());
//
// // Making sure the GPU holds the same data
// mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB, tensorC });
// EXPECT_EQ(tensorA->data(), tensorB->data());
// EXPECT_EQ(tensorA->data(), tensorC->data());
//}
//
//TEST(TestOpTensorCopy, CopyDeviceToHostTensor)
//{
//
// kp::Manager mgr;
//
// std::vector<float> testVecA{ 3, 4, 5 };
// std::vector<float> testVecB{ 0, 0, 0 };
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(
// testVecB, kp::Tensor::TensorTypes::eHost) };
//
// mgr.rebuild({ tensorA, tensorB }, false);
//
// // Only calling sync on device type tensor
// mgr.evalOpDefault<kp::OpTensorSyncDevice>({ tensorA });
//
// EXPECT_TRUE(tensorA->isInit());
// EXPECT_TRUE(tensorB->isInit());
//
// mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB });
//
// EXPECT_EQ(tensorA->data(), tensorB->data());
//
// // Making sure the GPU holds the same data
// mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
// EXPECT_EQ(tensorA->data(), tensorB->data());
//}
//
//TEST(TestOpTensorCopy, CopyHostToDeviceTensor)
//{
//
// kp::Manager mgr;
//
// std::vector<float> testVecA{ 4, 5, 6 };
// std::vector<float> testVecB{ 0, 0, 0 };
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(
// testVecA, kp::Tensor::TensorTypes::eHost) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
//
// mgr.rebuild({ tensorA, tensorB }, false);
//
// // Manually copy data into host memory of Tensor
// tensorA->mapDataIntoHostMemory();
//
// // Only calling sync on device type tensor
// mgr.evalOpDefault<kp::OpTensorSyncDevice>({ tensorB });
//
// EXPECT_TRUE(tensorA->isInit());
// EXPECT_TRUE(tensorB->isInit());
//
// mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB });
//
// EXPECT_EQ(tensorA->data(), tensorB->data());
//
// // Making sure the GPU holds the same data
// mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
// EXPECT_EQ(tensorA->data(), tensorB->data());
//}
//
//TEST(TestOpTensorCopy, CopyHostToHostTensor)
//{
//
// kp::Manager mgr;
//
// std::vector<float> testVecA{ 5, 6, 7 };
// std::vector<float> testVecB{ 0, 0, 0 };
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(
// testVecA, kp::Tensor::TensorTypes::eHost) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(
// testVecB, kp::Tensor::TensorTypes::eHost) };
//
// mgr.rebuild({ tensorA, tensorB });
//
// EXPECT_TRUE(tensorA->isInit());
// EXPECT_TRUE(tensorB->isInit());
//
// mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB });
//
// EXPECT_EQ(tensorA->data(), tensorB->data());
//
// // Making sure the GPU holds the same data
// mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
// EXPECT_EQ(tensorA->data(), tensorB->data());
//}
//
//TEST(TestOpTensorCopy, SingleTensorShouldFail)
//{
//
// kp::Manager mgr;
//
// std::vector<float> testVecA{ 6, 7, 8 };
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(
// testVecA, kp::Tensor::TensorTypes::eHost) };
//
// mgr.rebuild({ tensorA }, false);
//
// EXPECT_TRUE(tensorA->isInit());
//
// EXPECT_THROW(mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA }),
// std::runtime_error);
//}

304
test/TestOpTensorCreate.cpp
View file

@ -3,155 +3,155 @@
#include "kompute/Kompute.hpp"
TEST(TestOpTensorCreate, CreateSingleTensorSingleOp)
{
std::vector<float> testVecA{ 9, 8, 7 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
{
kp::Manager mgr;
mgr.rebuild({ tensorA });
EXPECT_TRUE(tensorA->isInit());
EXPECT_EQ(tensorA->data(), testVecA);
}
EXPECT_FALSE(tensorA->isInit());
}
TEST(TestOpTensorCreate, CreateMultipleTensorSingleOp)
{
kp::Manager mgr;
std::vector<float> testVecA{ 9, 8, 7 };
std::vector<float> testVecB{ 6, 5, 4 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
mgr.rebuild({ tensorA, tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
EXPECT_EQ(tensorA->data(), testVecA);
EXPECT_EQ(tensorB->data(), testVecB);
}
TEST(TestOpTensorCreate, CreateMultipleTensorMultipleOp)
{
kp::Manager mgr;
std::vector<float> testVecA{ 9, 8, 7 };
std::vector<float> testVecB{ 6, 5, 4 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
mgr.rebuild({ tensorA });
mgr.rebuild({ tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
EXPECT_EQ(tensorA->data(), testVecA);
EXPECT_EQ(tensorB->data(), testVecB);
}
TEST(TestOpTensorCreate, TestTensorMemoryManagedByManagerDestroyed)
{
std::vector<float> testVecA{ 9, 8, 7 };
std::vector<float> testVecB{ 6, 5, 4 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
{
kp::Manager mgr;
mgr.rebuild({ tensorA });
mgr.rebuild({ tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
EXPECT_EQ(tensorA->data(), testVecA);
EXPECT_EQ(tensorB->data(), testVecB);
}
EXPECT_FALSE(tensorA->isInit());
EXPECT_FALSE(tensorB->isInit());
}
TEST(TestOpTensorCreate, TestTensorMemoryManagedByManagerNOTDestroyed)
{
std::vector<float> testVecA{ 9, 8, 7 };
std::vector<float> testVecB{ 6, 5, 4 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
kp::Manager mgr;
{
mgr.rebuild({ tensorA });
mgr.rebuild({ tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
EXPECT_EQ(tensorA->data(), testVecA);
EXPECT_EQ(tensorB->data(), testVecB);
}
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
}
TEST(TestOpTensorCreate, NoErrorIfTensorFreedBefore)
{
std::vector<float> testVecA{ 9, 8, 7 };
std::vector<float> testVecB{ 6, 5, 4 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
kp::Manager mgr;
mgr.rebuild({ tensorA });
mgr.rebuild({ tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
EXPECT_EQ(tensorA->data(), testVecA);
EXPECT_EQ(tensorB->data(), testVecB);
tensorA->freeMemoryDestroyGPUResources();
tensorB->freeMemoryDestroyGPUResources();
EXPECT_FALSE(tensorA->isInit());
EXPECT_FALSE(tensorB->isInit());
}
TEST(TestOpTensorCreate, ExceptionOnZeroSizeTensor)
{
std::vector<float> testVecA;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
kp::Manager mgr;
try {
mgr.rebuild({ tensorA });
} catch (const std::runtime_error& err) {
// check exception
ASSERT_TRUE(std::string(err.what()).find("zero-sized") !=
std::string::npos);
}
}
//TEST(TestOpTensorCreate, CreateSingleTensorSingleOp)
//{
// std::vector<float> testVecA{ 9, 8, 7 };
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
//
// {
// kp::Manager mgr;
//
// mgr.rebuild({ tensorA });
//
// EXPECT_TRUE(tensorA->isInit());
//
// EXPECT_EQ(tensorA->data(), testVecA);
// }
//
// EXPECT_FALSE(tensorA->isInit());
//}
//
//TEST(TestOpTensorCreate, CreateMultipleTensorSingleOp)
//{
//
// kp::Manager mgr;
//
// std::vector<float> testVecA{ 9, 8, 7 };
// std::vector<float> testVecB{ 6, 5, 4 };
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
//
// mgr.rebuild({ tensorA, tensorB });
//
// EXPECT_TRUE(tensorA->isInit());
// EXPECT_TRUE(tensorB->isInit());
//
// EXPECT_EQ(tensorA->data(), testVecA);
// EXPECT_EQ(tensorB->data(), testVecB);
//}
//
//TEST(TestOpTensorCreate, CreateMultipleTensorMultipleOp)
//{
//
// kp::Manager mgr;
//
// std::vector<float> testVecA{ 9, 8, 7 };
// std::vector<float> testVecB{ 6, 5, 4 };
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
//
// mgr.rebuild({ tensorA });
// mgr.rebuild({ tensorB });
//
// EXPECT_TRUE(tensorA->isInit());
// EXPECT_TRUE(tensorB->isInit());
//
// EXPECT_EQ(tensorA->data(), testVecA);
// EXPECT_EQ(tensorB->data(), testVecB);
//}
//
//TEST(TestOpTensorCreate, TestTensorMemoryManagedByManagerDestroyed)
//{
//
// std::vector<float> testVecA{ 9, 8, 7 };
// std::vector<float> testVecB{ 6, 5, 4 };
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
//
// {
// kp::Manager mgr;
// mgr.rebuild({ tensorA });
// mgr.rebuild({ tensorB });
//
// EXPECT_TRUE(tensorA->isInit());
// EXPECT_TRUE(tensorB->isInit());
//
// EXPECT_EQ(tensorA->data(), testVecA);
// EXPECT_EQ(tensorB->data(), testVecB);
// }
//
// EXPECT_FALSE(tensorA->isInit());
// EXPECT_FALSE(tensorB->isInit());
//}
//
//TEST(TestOpTensorCreate, TestTensorMemoryManagedByManagerNOTDestroyed)
//{
//
// std::vector<float> testVecA{ 9, 8, 7 };
// std::vector<float> testVecB{ 6, 5, 4 };
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
//
// kp::Manager mgr;
//
// {
// mgr.rebuild({ tensorA });
// mgr.rebuild({ tensorB });
//
// EXPECT_TRUE(tensorA->isInit());
// EXPECT_TRUE(tensorB->isInit());
//
// EXPECT_EQ(tensorA->data(), testVecA);
// EXPECT_EQ(tensorB->data(), testVecB);
// }
//
// EXPECT_TRUE(tensorA->isInit());
// EXPECT_TRUE(tensorB->isInit());
//}
//
//TEST(TestOpTensorCreate, NoErrorIfTensorFreedBefore)
//{
//
// std::vector<float> testVecA{ 9, 8, 7 };
// std::vector<float> testVecB{ 6, 5, 4 };
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
//
// kp::Manager mgr;
//
// mgr.rebuild({ tensorA });
// mgr.rebuild({ tensorB });
//
// EXPECT_TRUE(tensorA->isInit());
// EXPECT_TRUE(tensorB->isInit());
//
// EXPECT_EQ(tensorA->data(), testVecA);
// EXPECT_EQ(tensorB->data(), testVecB);
//
// tensorA->freeMemoryDestroyGPUResources();
// tensorB->freeMemoryDestroyGPUResources();
// EXPECT_FALSE(tensorA->isInit());
// EXPECT_FALSE(tensorB->isInit());
//}
//
//TEST(TestOpTensorCreate, ExceptionOnZeroSizeTensor)
//{
// std::vector<float> testVecA;
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
//
// kp::Manager mgr;
//
// try {
// mgr.rebuild({ tensorA });
// } catch (const std::runtime_error& err) {
// // check exception
// ASSERT_TRUE(std::string(err.what()).find("zero-sized") !=
// std::string::npos);
// }
//}

104
test/TestOpTensorSync.cpp
View file

@ -3,55 +3,55 @@
#include "kompute/Kompute.hpp"
TEST(TestOpTensorSync, SyncToDeviceMemorySingleTensor)
{
kp::Manager mgr;
std::vector<float> testVecPreA{ 0, 0, 0 };
std::vector<float> testVecPostA{ 9, 8, 7 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecPreA) };
mgr.rebuild({ tensorA }, false);
EXPECT_TRUE(tensorA->isInit());
tensorA->setData(testVecPostA);
mgr.evalOpDefault<kp::OpTensorSyncDevice>({ tensorA });
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA });
EXPECT_EQ(tensorA->data(), testVecPostA);
}
TEST(TestOpTensorSync, SyncToDeviceMemoryMultiTensor)
{
kp::Manager mgr;
std::vector<float> testVec{ 9, 8, 7 };
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor({ 0, 0, 0 }) };
std::shared_ptr<kp::Tensor> tensorC{ new kp::Tensor({ 0, 0, 0 }) };
mgr.rebuild({ tensorA, tensorB, tensorC }, false);
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
EXPECT_TRUE(tensorC->isInit());
tensorA->setData(testVec);
mgr.evalOpDefault<kp::OpTensorSyncDevice>({ tensorA });
mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB, tensorC });
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA, tensorB, tensorC });
EXPECT_EQ(tensorA->data(), testVec);
EXPECT_EQ(tensorB->data(), testVec);
EXPECT_EQ(tensorC->data(), testVec);
}
//TEST(TestOpTensorSync, SyncToDeviceMemorySingleTensor)
//{
//
// kp::Manager mgr;
//
// std::vector<float> testVecPreA{ 0, 0, 0 };
// std::vector<float> testVecPostA{ 9, 8, 7 };
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecPreA) };
//
// mgr.rebuild({ tensorA }, false);
//
// EXPECT_TRUE(tensorA->isInit());
//
// tensorA->setData(testVecPostA);
//
// mgr.evalOpDefault<kp::OpTensorSyncDevice>({ tensorA });
//
// mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA });
//
// EXPECT_EQ(tensorA->data(), testVecPostA);
//}
//
//TEST(TestOpTensorSync, SyncToDeviceMemoryMultiTensor)
//{
//
// kp::Manager mgr;
//
// std::vector<float> testVec{ 9, 8, 7 };
//
// std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
// std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor({ 0, 0, 0 }) };
// std::shared_ptr<kp::Tensor> tensorC{ new kp::Tensor({ 0, 0, 0 }) };
//
// mgr.rebuild({ tensorA, tensorB, tensorC }, false);
//
// EXPECT_TRUE(tensorA->isInit());
// EXPECT_TRUE(tensorB->isInit());
// EXPECT_TRUE(tensorC->isInit());
//
// tensorA->setData(testVec);
//
// mgr.evalOpDefault<kp::OpTensorSyncDevice>({ tensorA });
//
// mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB, tensorC });
//
// mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA, tensorB, tensorC });
//
// EXPECT_EQ(tensorA->data(), testVec);
// EXPECT_EQ(tensorB->data(), testVec);
// EXPECT_EQ(tensorC->data(), testVec);
//}

72
test/TestSequence.cpp
View file

@ -3,40 +3,40 @@
#include "kompute/Kompute.hpp"
TEST(TestSequence, CmdBufSequenceBeginEnd)
{
kp::Manager mgr;
{
std::shared_ptr<kp::Sequence> sq =
mgr.sequence("newSequence");
EXPECT_TRUE(sq->eval());
EXPECT_TRUE(!sq->isRecording());
EXPECT_TRUE(sq->begin());
EXPECT_TRUE(sq->isRecording());
EXPECT_TRUE(!sq->begin());
EXPECT_TRUE(sq->isRecording());
EXPECT_TRUE(sq->end());
EXPECT_TRUE(!sq->isRecording());
EXPECT_TRUE(!sq->end());
EXPECT_TRUE(!sq->isRecording());
EXPECT_TRUE(sq->eval());
}
}
TEST(TestSequence, SequenceDestructorViaManager)
{
std::shared_ptr<kp::Sequence> sq = nullptr;
{
kp::Manager mgr;
sq = mgr.sequence("newSequence");
EXPECT_TRUE(sq->isInit());
}
EXPECT_FALSE(sq->isInit());
}
//TEST(TestSequence, CmdBufSequenceBeginEnd)
//{
// kp::Manager mgr;
//
// {
// std::shared_ptr<kp::Sequence> sq =
// mgr.sequence("newSequence");
//
// EXPECT_TRUE(sq->eval());
// EXPECT_TRUE(!sq->isRecording());
// EXPECT_TRUE(sq->begin());
// EXPECT_TRUE(sq->isRecording());
// EXPECT_TRUE(!sq->begin());
// EXPECT_TRUE(sq->isRecording());
// EXPECT_TRUE(sq->end());
// EXPECT_TRUE(!sq->isRecording());
// EXPECT_TRUE(!sq->end());
// EXPECT_TRUE(!sq->isRecording());
// EXPECT_TRUE(sq->eval());
// }
//}
//
//TEST(TestSequence, SequenceDestructorViaManager)
//{
// std::shared_ptr<kp::Sequence> sq = nullptr;
//
// {
// kp::Manager mgr;
//
// sq = mgr.sequence("newSequence");
//
// EXPECT_TRUE(sq->isInit());
// }
//
// EXPECT_FALSE(sq->isInit());
//}

56
test/TestSpecializationConstant.cpp
View file

@ -4,46 +4,44 @@
TEST(TestSpecializationConstants, TestTwoConstants)
{
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor({ 0, 0, 0 }) };
std::string shader(R"(
#version 450
layout (constant_id = 0) const float cOne = 1;
layout (constant_id = 1) const float cTwo = 1;
layout (local_size_x = 1) in;
layout(set = 0, binding = 0) buffer a { float pa[]; };
layout(set = 0, binding = 1) buffer b { float pb[]; };
void main() {
uint index = gl_GlobalInvocationID.x;
pa[index] = cOne;
pb[index] = cTwo;
})");
{
std::string shader(R"(
#version 450
layout (constant_id = 0) const float cOne = 1;
layout (constant_id = 1) const float cTwo = 1;
layout (local_size_x = 1) in;
layout(set = 0, binding = 0) buffer a { float pa[]; };
layout(set = 0, binding = 1) buffer b { float pb[]; };
void main() {
uint index = gl_GlobalInvocationID.x;
pa[index] = cOne;
pb[index] = cTwo;
})");
std::vector<uint32_t> spirv = kp::Shader::compile_source(shader);
std::shared_ptr<kp::Sequence> sq = nullptr;
{
kp::Manager mgr;
mgr.rebuild({ tensorA, tensorB });
std::shared_ptr<kp::Tensor> tensorA = mgr.tensor({ 0, 0, 0 });
std::shared_ptr<kp::Tensor> tensorB = mgr.tensor({ 0, 0, 0 });
sq = mgr.sequence();
std::vector<std::shared_ptr<kp::Tensor>> params = {tensorA, tensorB};
auto spec = kp::Constants({5.0, 0.3});
kp::Constants spec = kp::Constants({5.0, 0.3});
sq->begin();
sq->record<kp::OpAlgoCreate>(
{ tensorA, tensorB },
kp::Shader::compile_source(shader),
kp::Workgroup(), spec);
sq->end();
std::shared_ptr<kp::Algorithm> algo = mgr.algorithm(params, spirv, {}, spec);
sq->eval();
sq = mgr.sequence()
->record<kp::OpTensorSyncDevice>(params)
->record<kp::OpAlgoDispatch>(algo)
->record<kp::OpTensorSyncLocal>(params)
->eval();
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA, tensorB });
EXPECT_EQ(tensorA->data(), std::vector<float>({ 5, 5, 5 }));
EXPECT_EQ(tensorB->data(), std::vector<float>({ 0.3, 0.3, 0.3 }));
}
}
EXPECT_EQ(tensorA->data(), std::vector<float>({ 5, 5, 5 }));
EXPECT_EQ(tensorB->data(), std::vector<float>({ 0.3, 0.3, 0.3 }));
}

36
test/TestTensor.cpp
View file

@ -5,36 +5,10 @@
TEST(TestTensor, ConstructorData)
{
std::vector<float> vec{ 0, 1, 2 };
kp::Tensor tensor(vec);
EXPECT_EQ(tensor.size(), vec.size());
EXPECT_EQ(tensor.data(), vec);
}
TEST(TestTensor, CopyFromHostData)
{
std::vector<float> vecA{ 0, 1, 2 };
std::vector<float> vecB{ 0, 0, 0 };
std::shared_ptr<kp::Tensor> tensorA =
std::make_shared<kp::Tensor>(vecA, kp::Tensor::TensorTypes::eHost);
std::shared_ptr<kp::Tensor> tensorB =
std::make_shared<kp::Tensor>(vecB, kp::Tensor::TensorTypes::eHost);
kp::Manager mgr;
mgr.rebuild({ tensorA, tensorB });
if (std::shared_ptr<kp::Sequence> sq =
mgr.sequence("new")) {
sq->begin();
sq->record<kp::OpTensorCopy>({ tensorA, tensorB });
sq->end();
sq->eval();
}
EXPECT_EQ(tensorA->data(), tensorB->data());
std::vector<float> vec{ 0, 1, 2 };
std::shared_ptr<kp::Tensor> tensor = mgr.tensor(vec);
EXPECT_EQ(tensor->size(), vec.size());
EXPECT_EQ(tensor->data(), vec);
}

4
test/TestWorkgroup.cpp
View file

@ -3,6 +3,8 @@
#include "kompute/Kompute.hpp"
#include "kompute_test/shaders/shadertest_workgroup.hpp"
TEST(TestWorkgroup, TestSimpleWorkgroup)
{
std::shared_ptr<kp::Tensor> tensorA = nullptr;
@ -29,7 +31,7 @@ TEST(TestWorkgroup, TestSimpleWorkgroup)
sq = mgr.sequence();
sq->record<kp::OpTensorSyncDevice>(params);
sq->record<kp::OpAlgoDispatch>(params, algorithm);
sq->record<kp::OpAlgoDispatch>(algorithm);
sq->record<kp::OpTensorSyncLocal>(params);
sq->eval();
}