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

Reformatted

Browse source
This commit is contained in:
Alejandro Saucedo 2020-09-12 17:21:50 +01:00
parent c5df89c17b
commit fdc1d3b91a
23 changed files with 455 additions and 418 deletions
Download patch file Download diff file Expand all files Collapse all files

94
test/TestLogisticRegression.cpp
View file

@ -4,33 +4,35 @@
#include "fmt/ranges.h"
#include "kompute/Kompute.hpp"
TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegression) {
TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegression)
{
uint32_t ITERATIONS = 100;
float learningRate = 0.1;
std::shared_ptr<kp::Tensor> xI{ new kp::Tensor({ 0, 1, 1, 1, 1 })};
std::shared_ptr<kp::Tensor> xJ{ new kp::Tensor({ 0, 0, 0, 1, 1 })};
std::shared_ptr<kp::Tensor> xI{ new kp::Tensor({ 0, 1, 1, 1, 1 }) };
std::shared_ptr<kp::Tensor> xJ{ new kp::Tensor({ 0, 0, 0, 1, 1 }) };
std::shared_ptr<kp::Tensor> y{ new kp::Tensor({ 0, 0, 0, 1, 1 })};
std::shared_ptr<kp::Tensor> y{ new kp::Tensor({ 0, 0, 0, 1, 1 }) };
std::shared_ptr<kp::Tensor> wIn{ new kp::Tensor({ 0.001, 0.001 })};
std::shared_ptr<kp::Tensor> wOutI{ new kp::Tensor({ 0, 0, 0, 0, 0 })};
std::shared_ptr<kp::Tensor> wOutJ{ new kp::Tensor({ 0, 0, 0, 0, 0 })};
std::shared_ptr<kp::Tensor> wIn{ new kp::Tensor({ 0.001, 0.001 }) };
std::shared_ptr<kp::Tensor> wOutI{ new kp::Tensor({ 0, 0, 0, 0, 0 }) };
std::shared_ptr<kp::Tensor> wOutJ{ new kp::Tensor({ 0, 0, 0, 0, 0 }) };
std::shared_ptr<kp::Tensor> bIn{ new kp::Tensor({ 0 })};
std::shared_ptr<kp::Tensor> bOut{ new kp::Tensor({ 0, 0, 0, 0, 0 })};
std::shared_ptr<kp::Tensor> bIn{ new kp::Tensor({ 0 }) };
std::shared_ptr<kp::Tensor> bOut{ new kp::Tensor({ 0, 0, 0, 0, 0 }) };
std::shared_ptr<kp::Tensor> lOut{ new kp::Tensor({ 0, 0, 0, 0, 0 })};
std::shared_ptr<kp::Tensor> lOut{ new kp::Tensor({ 0, 0, 0, 0, 0 }) };
std::vector<std::shared_ptr<kp::Tensor>> params =
{xI, xJ, y, wIn, wOutI, wOutJ, bIn, bOut, lOut};
std::vector<std::shared_ptr<kp::Tensor>> params = { xI, xJ, y,
wIn, wOutI, wOutJ,
bIn, bOut, lOut };
{
kp::Manager mgr;
if (std::shared_ptr<kp::Sequence> sq =
mgr.getOrCreateManagedSequence("createTensors").lock()) {
if (std::shared_ptr<kp::Sequence> sq =
mgr.getOrCreateManagedSequence("createTensors").lock()) {
sq->begin();
@ -42,13 +44,12 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegression) {
// Record op algo base
sq->begin();
sq->record<kp::OpTensorSyncDevice>({wIn, bIn});
sq->record<kp::OpTensorSyncDevice>({ wIn, bIn });
sq->record<kp::OpAlgoBase<>>(
params,
"test/shaders/glsl/test_logistic_regression.comp");
params, "test/shaders/glsl/test_logistic_regression.comp");
sq->record<kp::OpTensorSyncLocal>({wOutI, wOutJ, bOut, lOut});
sq->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
sq->end();
@ -57,7 +58,7 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegression) {
sq->eval();
for(size_t j = 0; j < bOut->size(); j++) {
for (size_t j = 0; j < bOut->size(); j++) {
wIn->data()[0] -= learningRate * wOutI->data()[j];
wIn->data()[1] -= learningRate * wOutJ->data()[j];
bIn->data()[0] -= learningRate * bOut->data()[j];
@ -66,7 +67,6 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegression) {
}
}
// Based on the inputs the outputs should be at least:
// * wi < 0.01
// * wj > 1.0
@ -77,11 +77,14 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegression) {
EXPECT_LT(bIn->data()[0], 0.0);
EXPECT_LT(bIn->data()[0], 0.0);
SPDLOG_WARN("Result wIn: {}, bIn: {}, loss: {}",
wIn->data(), bIn->data(), lOut->data());
SPDLOG_WARN("Result wIn: {}, bIn: {}, loss: {}",
wIn->data(),
bIn->data(),
lOut->data());
}
TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegressionManualCopy) {
TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegressionManualCopy)
{
uint32_t ITERATIONS = 100;
float learningRate = 0.1;
@ -89,30 +92,31 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegressionManualCopy) {
std::vector<float> wInVec = { 0.001, 0.001 };
std::vector<float> bInVec = { 0 };
std::shared_ptr<kp::Tensor> xI{ new kp::Tensor({ 0, 1, 1, 1, 1 })};
std::shared_ptr<kp::Tensor> xJ{ new kp::Tensor({ 0, 0, 0, 1, 1 })};
std::shared_ptr<kp::Tensor> xI{ new kp::Tensor({ 0, 1, 1, 1, 1 }) };
std::shared_ptr<kp::Tensor> xJ{ new kp::Tensor({ 0, 0, 0, 1, 1 }) };
std::shared_ptr<kp::Tensor> y{ new kp::Tensor({ 0, 0, 0, 1, 1 })};
std::shared_ptr<kp::Tensor> y{ new kp::Tensor({ 0, 0, 0, 1, 1 }) };
std::shared_ptr<kp::Tensor> wIn{
new kp::Tensor(wInVec, kp::Tensor::TensorTypes::eStaging)};
std::shared_ptr<kp::Tensor> wOutI{ new kp::Tensor({ 0, 0, 0, 0, 0 })};
std::shared_ptr<kp::Tensor> wOutJ{ new kp::Tensor({ 0, 0, 0, 0, 0 })};
std::shared_ptr<kp::Tensor> wIn{ new kp::Tensor(
wInVec, kp::Tensor::TensorTypes::eStaging) };
std::shared_ptr<kp::Tensor> wOutI{ new kp::Tensor({ 0, 0, 0, 0, 0 }) };
std::shared_ptr<kp::Tensor> wOutJ{ new kp::Tensor({ 0, 0, 0, 0, 0 }) };
std::shared_ptr<kp::Tensor> bIn{
new kp::Tensor(bInVec, kp::Tensor::TensorTypes::eStaging)};
std::shared_ptr<kp::Tensor> bOut{ new kp::Tensor({ 0, 0, 0, 0, 0 })};
std::shared_ptr<kp::Tensor> bIn{ new kp::Tensor(
bInVec, kp::Tensor::TensorTypes::eStaging) };
std::shared_ptr<kp::Tensor> bOut{ new kp::Tensor({ 0, 0, 0, 0, 0 }) };
std::shared_ptr<kp::Tensor> lOut{ new kp::Tensor({ 0, 0, 0, 0, 0 })};
std::shared_ptr<kp::Tensor> lOut{ new kp::Tensor({ 0, 0, 0, 0, 0 }) };
std::vector<std::shared_ptr<kp::Tensor>> params =
{xI, xJ, y, wIn, wOutI, wOutJ, bIn, bOut, lOut};
std::vector<std::shared_ptr<kp::Tensor>> params = { xI, xJ, y,
wIn, wOutI, wOutJ,
bIn, bOut, lOut };
{
kp::Manager mgr;
if (std::shared_ptr<kp::Sequence> sq =
mgr.getOrCreateManagedSequence("createTensors").lock()) {
if (std::shared_ptr<kp::Sequence> sq =
mgr.getOrCreateManagedSequence("createTensors").lock()) {
sq->begin();
@ -125,10 +129,9 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegressionManualCopy) {
sq->begin();
sq->record<kp::OpAlgoBase<>>(
params,
"test/shaders/glsl/test_logistic_regression.comp");
params, "test/shaders/glsl/test_logistic_regression.comp");
sq->record<kp::OpTensorSyncLocal>({wOutI, wOutJ, bOut, lOut});
sq->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
sq->end();
@ -137,7 +140,7 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegressionManualCopy) {
sq->eval();
for(size_t j = 0; j < bOut->size(); j++) {
for (size_t j = 0; j < bOut->size(); j++) {
wIn->data()[0] -= learningRate * wOutI->data()[j];
wIn->data()[1] -= learningRate * wOutJ->data()[j];
bIn->data()[0] -= learningRate * bOut->data()[j];
@ -148,7 +151,6 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegressionManualCopy) {
}
}
// Based on the inputs the outputs should be at least:
// * wi < 0.01
// * wj > 1.0
@ -158,6 +160,8 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegressionManualCopy) {
EXPECT_GT(wIn->data()[1], 1.0);
EXPECT_LT(bIn->data()[0], 0.0);
SPDLOG_WARN("Result wIn: {}, bIn: {}, loss: {}",
wIn->data(), bIn->data(), lOut->data());
SPDLOG_WARN("Result wIn: {}, bIn: {}, loss: {}",
wIn->data(),
bIn->data(),
lOut->data());
}

7
test/TestMain.cpp
View file

@ -3,12 +3,15 @@
#include <kompute/Kompute.hpp>
int main(int argc, char *argv[]) {
int
main(int argc, char* argv[])
{
testing::InitGoogleTest(&argc, argv);
testing::InitGoogleMock(&argc, argv);
#if KOMPUTE_ENABLE_SPDLOG
spdlog::set_level(static_cast<spdlog::level::level_enum>(SPDLOG_ACTIVE_LEVEL));
spdlog::set_level(
static_cast<spdlog::level::level_enum>(SPDLOG_ACTIVE_LEVEL));
#endif
return RUN_ALL_TESTS();

80
test/TestManager.cpp Executable file → Normal file
View file

@ -10,10 +10,10 @@ TEST(TestManager, EndToEndOpMultFlow)
std::shared_ptr<kp::Tensor> tensorLHS{ new kp::Tensor({ 0, 1, 2 }) };
mgr.evalOp<kp::OpTensorCreate>({ tensorLHS });
std::shared_ptr<kp::Tensor> tensorRHS{ new kp::Tensor( { 2, 4, 6 }) };
std::shared_ptr<kp::Tensor> tensorRHS{ new kp::Tensor({ 2, 4, 6 }) };
mgr.evalOp<kp::OpTensorCreate>({ tensorRHS });
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor( { 0, 0, 0 }) };
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor({ 0, 0, 0 }) };
mgr.evalOp<kp::OpTensorCreate>({ tensorOutput });
@ -21,23 +21,22 @@ TEST(TestManager, EndToEndOpMultFlow)
mgr.evalOp<kp::OpTensorSyncLocal>({ tensorOutput });
EXPECT_EQ(tensorOutput->data(), std::vector<float>({0, 4, 12}));
EXPECT_EQ(tensorOutput->data(), std::vector<float>({ 0, 4, 12 }));
}
TEST(TestManager, OpMultSequenceFlow) {
TEST(TestManager, OpMultSequenceFlow)
{
std::shared_ptr<kp::Tensor> tensorLHS{ new kp::Tensor(
{ 0, 1, 2 }) };
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> tensorRHS{ new kp::Tensor({ 2, 4, 6 }) };
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor(
{ 0, 0, 0 }) };
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor({ 0, 0, 0 }) };
kp::Manager mgr;
std::weak_ptr<kp::Sequence> sqWeakPtr = mgr.getOrCreateManagedSequence("newSequence");
std::weak_ptr<kp::Sequence> sqWeakPtr =
mgr.getOrCreateManagedSequence("newSequence");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
@ -54,23 +53,24 @@ TEST(TestManager, OpMultSequenceFlow) {
}
sqWeakPtr.reset();
EXPECT_EQ(tensorOutput->data(), std::vector<float>({0, 4, 12}));
EXPECT_EQ(tensorOutput->data(), std::vector<float>({ 0, 4, 12 }));
}
TEST(TestManager, TestMultipleSequences) {
TEST(TestManager, TestMultipleSequences)
{
kp::Manager mgr;
std::weak_ptr<kp::Sequence> sqWeakPtrOne =
mgr.getOrCreateManagedSequence("sqOne");
std::weak_ptr<kp::Sequence> sqWeakPtrOne =
mgr.getOrCreateManagedSequence("sqOne");
std::weak_ptr<kp::Sequence> sqWeakPtrTwo =
mgr.getOrCreateManagedSequence("sqTwo");
std::weak_ptr<kp::Sequence> sqWeakPtrTwo =
mgr.getOrCreateManagedSequence("sqTwo");
std::weak_ptr<kp::Sequence> sqWeakPtrOneRef =
mgr.getOrCreateManagedSequence("sqOne");
std::weak_ptr<kp::Sequence> sqWeakPtrOneRef =
mgr.getOrCreateManagedSequence("sqOne");
std::weak_ptr<kp::Sequence> sqWeakPtrTwoRef =
mgr.getOrCreateManagedSequence("sqTwo");
std::weak_ptr<kp::Sequence> sqWeakPtrTwoRef =
mgr.getOrCreateManagedSequence("sqTwo");
EXPECT_EQ(sqWeakPtrOne.lock(), sqWeakPtrOneRef.lock());
EXPECT_NE(sqWeakPtrTwo.lock(), sqWeakPtrOneRef.lock());
@ -78,20 +78,19 @@ TEST(TestManager, TestMultipleSequences) {
EXPECT_NE(sqWeakPtrOneRef.lock(), sqWeakPtrTwoRef.lock());
}
TEST(TestManager, TestMultipleTensorsAtOnce) {
TEST(TestManager, TestMultipleTensorsAtOnce)
{
std::shared_ptr<kp::Tensor> tensorLHS{ new kp::Tensor(
{ 0, 1, 2 }) };
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> tensorRHS{ new kp::Tensor({ 2, 4, 6 }) };
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor(
{ 0, 0, 0 }) };
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor({ 0, 0, 0 }) };
kp::Manager mgr;
std::weak_ptr<kp::Sequence> sqWeakPtr = mgr.getOrCreateManagedSequence("newSequence");
std::weak_ptr<kp::Sequence> sqWeakPtr =
mgr.getOrCreateManagedSequence("newSequence");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
@ -110,25 +109,26 @@ TEST(TestManager, TestMultipleTensorsAtOnce) {
}
sqWeakPtr.reset();
EXPECT_EQ(tensorOutput->data(), std::vector<float>({0, 4, 12}));
EXPECT_EQ(tensorOutput->data(), std::vector<float>({ 0, 4, 12 }));
}
TEST(TestManager, TestCreateInitTensor) {
TEST(TestManager, TestCreateInitTensor)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA = mgr.buildTensor({0,1,2});
std::shared_ptr<kp::Tensor> tensorB = mgr.buildTensor({0,0,0});
std::shared_ptr<kp::Tensor> tensorA = mgr.buildTensor({ 0, 1, 2 });
std::shared_ptr<kp::Tensor> tensorB = mgr.buildTensor({ 0, 0, 0 });
mgr.evalOpDefault<kp::OpTensorCopy>({tensorA, tensorB});
mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpTensorSyncLocal>({tensorB});
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
EXPECT_EQ(tensorB->data(), std::vector<float>({0,1,2}));
EXPECT_EQ(tensorB->data(), std::vector<float>({ 0, 1, 2 }));
std::shared_ptr<kp::Tensor> tensorC = mgr.buildTensor({0,0,0}, kp::Tensor::TensorTypes::eStaging);
std::shared_ptr<kp::Tensor> tensorC =
mgr.buildTensor({ 0, 0, 0 }, kp::Tensor::TensorTypes::eStaging);
mgr.evalOpDefault<kp::OpTensorCopy>({tensorA, tensorC});
mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorC });
EXPECT_EQ(tensorC->data(), std::vector<float>({0,1,2}));
EXPECT_EQ(tensorC->data(), std::vector<float>({ 0, 1, 2 }));
}

157
test/TestMultipleAlgoExecutions.cpp
View file

@ -3,37 +3,35 @@
#include "kompute/Kompute.hpp"
TEST(TestMultipleAlgoExecutions, SingleSequenceRecord) {
TEST(TestMultipleAlgoExecutions, SingleSequenceRecord)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 })};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
std::string shader(
"#version 450\n"
"layout (local_size_x = 1) in;\n"
"layout(set = 0, binding = 0) buffer a { float pa[]; };\n"
"void main() {\n"
" uint index = gl_GlobalInvocationID.x;\n"
" pa[index] = pa[index] + 1;\n"
"}\n"
);
"#version 450\n"
"layout (local_size_x = 1) in;\n"
"layout(set = 0, binding = 0) buffer a { float pa[]; };\n"
"void main() {\n"
" uint index = gl_GlobalInvocationID.x;\n"
" pa[index] = pa[index] + 1;\n"
"}\n");
std::weak_ptr<kp::Sequence> sqWeakPtr = mgr.getOrCreateManagedSequence("newSequence");
std::weak_ptr<kp::Sequence> sqWeakPtr =
mgr.getOrCreateManagedSequence("newSequence");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
sq->record<kp::OpTensorCreate>({ tensorA });
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA },
std::vector<char>(shader.begin(), shader.end()));
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA },
std::vector<char>(shader.begin(), shader.end()));
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA },
std::vector<char>(shader.begin(), shader.end()));
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->record<kp::OpTensorSyncLocal>({ tensorA });
@ -42,34 +40,34 @@ TEST(TestMultipleAlgoExecutions, SingleSequenceRecord) {
}
sqWeakPtr.reset();
EXPECT_EQ(tensorA->data(), std::vector<float>({3, 3, 3}));
EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
}
TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords) {
TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 })};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
std::string shader(
"#version 450\n"
"layout (local_size_x = 1) in;\n"
"layout(set = 0, binding = 0) buffer a { float pa[]; };\n"
"void main() {\n"
" uint index = gl_GlobalInvocationID.x;\n"
" pa[index] = pa[index] + 1;\n"
"}\n"
);
"#version 450\n"
"layout (local_size_x = 1) in;\n"
"layout(set = 0, binding = 0) buffer a { float pa[]; };\n"
"void main() {\n"
" uint index = gl_GlobalInvocationID.x;\n"
" pa[index] = pa[index] + 1;\n"
"}\n");
std::weak_ptr<kp::Sequence> sqWeakPtr = mgr.getOrCreateManagedSequence("newSequence");
std::weak_ptr<kp::Sequence> sqWeakPtr =
mgr.getOrCreateManagedSequence("newSequence");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
sq->record<kp::OpTensorCreate>({ tensorA });
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA },
std::vector<char>(shader.begin(), shader.end()));
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->end();
sq->eval();
@ -77,8 +75,7 @@ TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords) {
sq->begin();
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA },
std::vector<char>(shader.begin(), shader.end()));
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->end();
sq->eval();
@ -86,112 +83,109 @@ TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords) {
sq->begin();
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA },
std::vector<char>(shader.begin(), shader.end()));
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->end();
sq->eval();
sq->begin();
sq->record<kp::OpTensorSyncLocal>(
{ tensorA });
sq->record<kp::OpTensorSyncLocal>({ tensorA });
sq->end();
sq->eval();
}
sqWeakPtr.reset();
EXPECT_EQ(tensorA->data(), std::vector<float>({3, 3, 3}));
EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
}
TEST(TestMultipleAlgoExecutions, MultipleSequences) {
TEST(TestMultipleAlgoExecutions, MultipleSequences)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 })};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
std::string shader(
"#version 450\n"
"layout (local_size_x = 1) in;\n"
"layout(set = 0, binding = 0) buffer a { float pa[]; };\n"
"void main() {\n"
" uint index = gl_GlobalInvocationID.x;\n"
" pa[index] = pa[index] + 1;\n"
"}\n"
);
"#version 450\n"
"layout (local_size_x = 1) in;\n"
"layout(set = 0, binding = 0) buffer a { float pa[]; };\n"
"void main() {\n"
" uint index = gl_GlobalInvocationID.x;\n"
" pa[index] = pa[index] + 1;\n"
"}\n");
std::weak_ptr<kp::Sequence> sqWeakPtr = mgr.getOrCreateManagedSequence("newSequence");
std::weak_ptr<kp::Sequence> sqWeakPtr =
mgr.getOrCreateManagedSequence("newSequence");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
sq->record<kp::OpTensorCreate>({ tensorA });
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA },
std::vector<char>(shader.begin(), shader.end()));
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->end();
sq->eval();
}
std::weak_ptr<kp::Sequence> sqWeakPtr2 = mgr.getOrCreateManagedSequence("newSequence2");
std::weak_ptr<kp::Sequence> sqWeakPtr2 =
mgr.getOrCreateManagedSequence("newSequence2");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr2.lock()) {
sq->begin();
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA },
std::vector<char>(shader.begin(), shader.end()));
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->end();
sq->eval();
}
std::weak_ptr<kp::Sequence> sqWeakPtr3 = mgr.getOrCreateManagedSequence("newSequence3");
std::weak_ptr<kp::Sequence> sqWeakPtr3 =
mgr.getOrCreateManagedSequence("newSequence3");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr3.lock()) {
sq->begin();
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA },
std::vector<char>(shader.begin(), shader.end()));
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->end();
sq->eval();
}
std::weak_ptr<kp::Sequence> sqWeakPtr4 = mgr.getOrCreateManagedSequence("newSequence5");
std::weak_ptr<kp::Sequence> sqWeakPtr4 =
mgr.getOrCreateManagedSequence("newSequence5");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr4.lock()) {
sq->begin();
sq->record<kp::OpTensorSyncLocal>(
{ tensorA });
sq->record<kp::OpTensorSyncLocal>({ tensorA });
sq->end();
sq->eval();
}
EXPECT_EQ(tensorA->data(), std::vector<float>({3, 3, 3}));
EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
}
TEST(TestMultipleAlgoExecutions, SingleRecordMultipleEval) {
TEST(TestMultipleAlgoExecutions, SingleRecordMultipleEval)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 })};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
std::string shader(
"#version 450\n"
"layout (local_size_x = 1) in;\n"
"layout(set = 0, binding = 0) buffer a { float pa[]; };\n"
"void main() {\n"
" uint index = gl_GlobalInvocationID.x;\n"
" pa[index] = pa[index] + 1;\n"
"}\n"
);
"#version 450\n"
"layout (local_size_x = 1) in;\n"
"layout(set = 0, binding = 0) buffer a { float pa[]; };\n"
"void main() {\n"
" uint index = gl_GlobalInvocationID.x;\n"
" pa[index] = pa[index] + 1;\n"
"}\n");
std::weak_ptr<kp::Sequence> sqWeakPtr = mgr.getOrCreateManagedSequence("newSequence");
std::weak_ptr<kp::Sequence> sqWeakPtr =
mgr.getOrCreateManagedSequence("newSequence");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
@ -201,13 +195,13 @@ TEST(TestMultipleAlgoExecutions, SingleRecordMultipleEval) {
sq->eval();
}
std::weak_ptr<kp::Sequence> sqWeakPtr2 = mgr.getOrCreateManagedSequence("newSequence2");
std::weak_ptr<kp::Sequence> sqWeakPtr2 =
mgr.getOrCreateManagedSequence("newSequence2");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr2.lock()) {
sq->begin();
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA },
std::vector<char>(shader.begin(), shader.end()));
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->end();
@ -216,12 +210,12 @@ TEST(TestMultipleAlgoExecutions, SingleRecordMultipleEval) {
sq->eval();
}
std::weak_ptr<kp::Sequence> sqWeakPtr3 = mgr.getOrCreateManagedSequence("newSequence3");
std::weak_ptr<kp::Sequence> sqWeakPtr3 =
mgr.getOrCreateManagedSequence("newSequence3");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr2.lock()) {
sq->begin();
sq->record<kp::OpTensorSyncLocal>(
{ tensorA });
sq->record<kp::OpTensorSyncLocal>({ tensorA });
sq->end();
@ -230,6 +224,5 @@ TEST(TestMultipleAlgoExecutions, SingleRecordMultipleEval) {
sq->eval();
}
EXPECT_EQ(tensorA->data(), std::vector<float>({3, 3, 3}));
EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
}

41
test/TestOpAlgoLoopsPassingData.cpp
View file

@ -3,15 +3,18 @@
#include "kompute/Kompute.hpp"
TEST(TestProcessingIterations, IterateThroughMultipleSumAndCopies) {
TEST(TestProcessingIterations, IterateThroughMultipleSumAndCopies)
{
kp::Manager mgr;
float TOTAL_ITER = 10;
std::vector<float> testExpectedOutVec = {TOTAL_ITER, TOTAL_ITER, TOTAL_ITER};
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::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
@ -27,11 +30,10 @@ TEST(TestProcessingIterations, IterateThroughMultipleSumAndCopies) {
}
)");
std::weak_ptr<kp::Sequence> sqWeakPtr =
mgr.getOrCreateManagedSequence("default");
std::weak_ptr<kp::Sequence> sqWeakPtr =
mgr.getOrCreateManagedSequence("default");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock())
{
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
sq->record<kp::OpTensorCreate>({ tensorA, tensorB });
@ -41,18 +43,17 @@ TEST(TestProcessingIterations, IterateThroughMultipleSumAndCopies) {
sq->eval();
}
std::weak_ptr<kp::Sequence> sqWeakPtr2 =
mgr.getOrCreateManagedSequence("run");
std::weak_ptr<kp::Sequence> sqWeakPtr2 =
mgr.getOrCreateManagedSequence("run");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr2.lock())
{
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr2.lock()) {
sq->begin();
sq->record<kp::OpAlgoBase<>>(
{ tensorA, tensorB },
std::vector<char>(shader.begin(), shader.end()));
{ tensorA, tensorB },
std::vector<char>(shader.begin(), shader.end()));
sq->record<kp::OpTensorCopy>({tensorB, tensorA});
sq->record<kp::OpTensorCopy>({ tensorB, tensorA });
sq->end();
for (size_t i = 0; i < TOTAL_ITER; i++) {
@ -60,14 +61,13 @@ TEST(TestProcessingIterations, IterateThroughMultipleSumAndCopies) {
}
}
std::weak_ptr<kp::Sequence> sqWeakPtr3 =
mgr.getOrCreateManagedSequence("export");
std::weak_ptr<kp::Sequence> sqWeakPtr3 =
mgr.getOrCreateManagedSequence("export");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr3.lock())
{
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr3.lock()) {
sq->begin();
sq->record<kp::OpTensorSyncLocal>({tensorA, tensorB});
sq->record<kp::OpTensorSyncLocal>({ tensorA, tensorB });
sq->end();
@ -76,4 +76,3 @@ TEST(TestProcessingIterations, IterateThroughMultipleSumAndCopies) {
EXPECT_EQ(tensorA->data(), testExpectedOutVec);
}

72
test/TestOpShadersFromStringAndFile.cpp
View file

@ -5,11 +5,12 @@
#include "kompute_test/shaders/shadertest_op_custom_shader.hpp"
TEST(TestOpAlgoBase, ShaderRawDataFromConstructor) {
TEST(TestOpAlgoBase, 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 })};
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.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
std::string shader(R"(
@ -28,65 +29,66 @@ TEST(TestOpAlgoBase, ShaderRawDataFromConstructor) {
)");
mgr.evalOpDefault<kp::OpAlgoBase<>>(
{ tensorA, tensorB },
std::vector<char>(shader.begin(), shader.end()));
{ tensorA, tensorB }, std::vector<char>(shader.begin(), shader.end()));
mgr.evalOpDefault<kp::OpTensorSyncLocal>({tensorA, tensorB});
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}));
EXPECT_EQ(tensorA->data(), std::vector<float>({ 0, 1, 2 }));
EXPECT_EQ(tensorB->data(), std::vector<float>({ 3, 4, 5 }));
}
TEST(TestOpAlgoBase, ShaderCompiledDataFromConstructor) {
TEST(TestOpAlgoBase, 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 })};
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.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpAlgoBase<>>(
{ tensorA, tensorB },
std::vector<char>(
kp::shader_data::test_shaders_glsl_test_op_custom_shader_comp_spv,
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));
{ tensorA, tensorB },
std::vector<char>(
kp::shader_data::test_shaders_glsl_test_op_custom_shader_comp_spv,
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});
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}));
EXPECT_EQ(tensorA->data(), std::vector<float>({ 0, 1, 2 }));
EXPECT_EQ(tensorB->data(), std::vector<float>({ 3, 4, 5 }));
}
TEST(TestOpAlgoBase, ShaderRawDataFromFile) {
TEST(TestOpAlgoBase, ShaderRawDataFromFile)
{
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 })};
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.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpAlgoBase<>>(
{ tensorA, tensorB },
"test/shaders/glsl/test_op_custom_shader.comp");
{ tensorA, tensorB }, "test/shaders/glsl/test_op_custom_shader.comp");
mgr.evalOpDefault<kp::OpTensorSyncLocal>({tensorA, tensorB});
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}));
EXPECT_EQ(tensorA->data(), std::vector<float>({ 0, 1, 2 }));
EXPECT_EQ(tensorB->data(), std::vector<float>({ 3, 4, 5 }));
}
TEST(TestOpAlgoBase, ShaderCompiledDataFromFile) {
TEST(TestOpAlgoBase, 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 })};
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.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpAlgoBase<>>(
{ tensorA, tensorB },
"test/shaders/glsl/test_op_custom_shader.comp.spv");
{ tensorA, tensorB }, "test/shaders/glsl/test_op_custom_shader.comp.spv");
mgr.evalOpDefault<kp::OpTensorSyncLocal>({tensorA, tensorB});
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}));
EXPECT_EQ(tensorA->data(), std::vector<float>({ 0, 1, 2 }));
EXPECT_EQ(tensorB->data(), std::vector<float>({ 3, 4, 5 }));
}

85
test/TestOpTensorCopy.cpp
View file

@ -3,31 +3,33 @@
#include "kompute/Kompute.hpp"
TEST(TestOpTensorCopy, CopyDeviceToDeviceTensor) {
TEST(TestOpTensorCopy, CopyDeviceToDeviceTensor)
{
kp::Manager mgr;
std::vector<float> testVecA{ 9, 8, 7 };
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)};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA, tensorB});
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
mgr.evalOpDefault<kp::OpTensorCopy>({tensorA, tensorB});
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});
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
EXPECT_EQ(tensorA->data(), tensorB->data());
}
TEST(TestOpTensorCopy, CopyDeviceToDeviceTensorMulti) {
TEST(TestOpTensorCopy, CopyDeviceToDeviceTensorMulti)
{
kp::Manager mgr;
@ -35,113 +37,120 @@ TEST(TestOpTensorCopy, CopyDeviceToDeviceTensorMulti) {
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)};
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.evalOpDefault<kp::OpTensorCreate>({tensorA, tensorB, tensorC});
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB, tensorC });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
EXPECT_TRUE(tensorC->isInit());
mgr.evalOpDefault<kp::OpTensorCopy>({tensorA, tensorB, tensorC});
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});
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB, tensorC });
EXPECT_EQ(tensorA->data(), tensorB->data());
EXPECT_EQ(tensorA->data(), tensorC->data());
}
TEST(TestOpTensorCopy, CopyDeviceToStagingTensor) {
TEST(TestOpTensorCopy, CopyDeviceToStagingTensor)
{
kp::Manager mgr;
std::vector<float> testVecA{ 9, 8, 7 };
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::eStaging)};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(
testVecB, kp::Tensor::TensorTypes::eStaging) };
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA, tensorB});
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
mgr.evalOpDefault<kp::OpTensorCopy>({tensorA, tensorB});
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});
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
EXPECT_EQ(tensorA->data(), tensorB->data());
}
TEST(TestOpTensorCopy, CopyStagingToDeviceTensor) {
TEST(TestOpTensorCopy, CopyStagingToDeviceTensor)
{
kp::Manager mgr;
std::vector<float> testVecA{ 9, 8, 7 };
std::vector<float> testVecB{ 0, 0, 0 };
std::shared_ptr<kp::Tensor> tensorA{new kp::Tensor(testVecA, kp::Tensor::TensorTypes::eStaging)};
std::shared_ptr<kp::Tensor> tensorB{new kp::Tensor(testVecB)};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(
testVecA, kp::Tensor::TensorTypes::eStaging) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA, tensorB});
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
mgr.evalOpDefault<kp::OpTensorCopy>({tensorA, tensorB});
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});
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
EXPECT_EQ(tensorA->data(), tensorB->data());
}
TEST(TestOpTensorCopy, CopyStagingToStagingTensor) {
TEST(TestOpTensorCopy, CopyStagingToStagingTensor)
{
kp::Manager mgr;
std::vector<float> testVecA{ 9, 8, 7 };
std::vector<float> testVecB{ 0, 0, 0 };
std::shared_ptr<kp::Tensor> tensorA{new kp::Tensor(testVecA, kp::Tensor::TensorTypes::eStaging)};
std::shared_ptr<kp::Tensor> tensorB{new kp::Tensor(testVecB, kp::Tensor::TensorTypes::eStaging)};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(
testVecA, kp::Tensor::TensorTypes::eStaging) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(
testVecB, kp::Tensor::TensorTypes::eStaging) };
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA, tensorB});
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
mgr.evalOpDefault<kp::OpTensorCopy>({tensorA, tensorB});
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});
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB });
EXPECT_EQ(tensorA->data(), tensorB->data());
}
TEST(TestOpTensorCopy, SingleTensorShouldFail) {
TEST(TestOpTensorCopy, SingleTensorShouldFail)
{
kp::Manager mgr;
std::vector<float> testVecA{ 9, 8, 7 };
std::shared_ptr<kp::Tensor> tensorA{new kp::Tensor(testVecA, kp::Tensor::TensorTypes::eStaging)};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(
testVecA, kp::Tensor::TensorTypes::eStaging) };
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA});
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA });
EXPECT_TRUE(tensorA->isInit());
EXPECT_THROW(
mgr.evalOpDefault<kp::OpTensorCopy>({tensorA}),
std::runtime_error);
EXPECT_THROW(mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA }),
std::runtime_error);
}

50
test/TestOpTensorCreate.cpp
View file

@ -3,15 +3,16 @@
#include "kompute/Kompute.hpp"
TEST(TestOpTensorCreate, CreateSingleTensorSingleOp) {
TEST(TestOpTensorCreate, CreateSingleTensorSingleOp)
{
kp::Manager mgr;
std::vector<float> testVecA{ 9, 8, 7 };
std::shared_ptr<kp::Tensor> tensorA{new kp::Tensor(testVecA)};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA});
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA });
EXPECT_TRUE(tensorA->isInit());
@ -21,17 +22,18 @@ TEST(TestOpTensorCreate, CreateSingleTensorSingleOp) {
EXPECT_FALSE(tensorA->isInit());
}
TEST(TestOpTensorCreate, CreateMultipleTensorSingleOp) {
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)};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA, tensorB});
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
@ -40,18 +42,19 @@ TEST(TestOpTensorCreate, CreateMultipleTensorSingleOp) {
EXPECT_EQ(tensorB->data(), testVecB);
}
TEST(TestOpTensorCreate, CreateMultipleTensorMultipleOp) {
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)};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA});
mgr.evalOpDefault<kp::OpTensorCreate>({tensorB});
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA });
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
@ -60,18 +63,19 @@ TEST(TestOpTensorCreate, CreateMultipleTensorMultipleOp) {
EXPECT_EQ(tensorB->data(), testVecB);
}
TEST(TestOpTensorCreate, ManageTensorMemoryWhenOpTensorCreateDestroyed) {
TEST(TestOpTensorCreate, ManageTensorMemoryWhenOpTensorCreateDestroyed)
{
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)};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
{
kp::Manager mgr;
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA});
mgr.evalOpDefault<kp::OpTensorCreate>({tensorB});
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA });
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
@ -84,18 +88,19 @@ TEST(TestOpTensorCreate, ManageTensorMemoryWhenOpTensorCreateDestroyed) {
EXPECT_FALSE(tensorB->isInit());
}
TEST(TestOpTensorCreate, NoErrorIfTensorFreedBefore) {
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)};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecA) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(testVecB) };
kp::Manager mgr;
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA});
mgr.evalOpDefault<kp::OpTensorCreate>({tensorB});
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA });
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorB });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
@ -108,4 +113,3 @@ TEST(TestOpTensorCreate, NoErrorIfTensorFreedBefore) {
EXPECT_FALSE(tensorA->isInit());
EXPECT_FALSE(tensorB->isInit());
}

30
test/TestOpTensorSync.cpp
View file

@ -3,39 +3,41 @@
#include "kompute/Kompute.hpp"
TEST(TestOpTensorSync, SyncToDeviceMemorySingleTensor) {
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)};
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(testVecPreA) };
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA});
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA });
EXPECT_TRUE(tensorA->isInit());
tensorA->setData(testVecPostA);
mgr.evalOpDefault<kp::OpTensorSyncDevice>({tensorA});
mgr.evalOpDefault<kp::OpTensorSyncDevice>({ tensorA });
mgr.evalOpDefault<kp::OpTensorSyncLocal>({tensorA});
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA });
EXPECT_EQ(tensorA->data(), testVecPostA);
}
TEST(TestOpTensorSync, SyncToDeviceMemoryMultiTensor) {
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})};
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.evalOpDefault<kp::OpTensorCreate>({tensorA, tensorB, tensorC});
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB, tensorC });
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
@ -43,15 +45,13 @@ TEST(TestOpTensorSync, SyncToDeviceMemoryMultiTensor) {
tensorA->setData(testVec);
mgr.evalOpDefault<kp::OpTensorSyncDevice>({tensorA});
mgr.evalOpDefault<kp::OpTensorSyncDevice>({ tensorA });
mgr.evalOpDefault<kp::OpTensorCopy>({tensorA, tensorB, tensorC});
mgr.evalOpDefault<kp::OpTensorCopy>({ tensorA, tensorB, tensorC });
mgr.evalOpDefault<kp::OpTensorSyncLocal>({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);
}

8
test/TestSequence.cpp
View file

@ -3,11 +3,12 @@
#include "kompute/Kompute.hpp"
TEST(TestSequence, CmdBufSequenceBeginEnd) {
TEST(TestSequence, CmdBufSequenceBeginEnd)
{
kp::Manager mgr;
std::weak_ptr<kp::Sequence> sqWeakPtr =
mgr.getOrCreateManagedSequence("newSequence");
std::weak_ptr<kp::Sequence> sqWeakPtr =
mgr.getOrCreateManagedSequence("newSequence");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
EXPECT_TRUE(sq->eval());
@ -23,4 +24,3 @@ TEST(TestSequence, CmdBufSequenceBeginEnd) {
EXPECT_TRUE(sq->eval());
}
}

36
test/TestTensor.cpp
View file

@ -3,34 +3,33 @@
#include "kompute/Kompute.hpp"
TEST(TestTensor, ConstructorData) {
std::vector<float> vec{0,1,2};
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 );
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};
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::eStaging);
std::shared_ptr<kp::Tensor> tensorB = std::make_shared<kp::Tensor>(
vecB,
kp::Tensor::TensorTypes::eStaging);
std::shared_ptr<kp::Tensor> tensorA =
std::make_shared<kp::Tensor>(vecA, kp::Tensor::TensorTypes::eStaging);
std::shared_ptr<kp::Tensor> tensorB =
std::make_shared<kp::Tensor>(vecB, kp::Tensor::TensorTypes::eStaging);
kp::Manager mgr;
if(std::shared_ptr<kp::Sequence> sq =
mgr.getOrCreateManagedSequence("new").lock())
{
if (std::shared_ptr<kp::Sequence> sq =
mgr.getOrCreateManagedSequence("new").lock()) {
sq->begin();
sq->record<kp::OpTensorCreate>({tensorA, tensorB});
sq->record<kp::OpTensorCreate>({ tensorA, tensorB });
sq->record<kp::OpTensorCopy>({tensorA, tensorB});
sq->record<kp::OpTensorCopy>({ tensorA, tensorB });
sq->end();
@ -39,4 +38,3 @@ TEST(TestTensor, CopyFromHostData) {
EXPECT_EQ(tensorA->data(), tensorB->data());
}