Further tests added to new structure
This commit is contained in:
Alejandro Saucedo
parent
3f1288271d
commit
6378583a23
17 changed files with 636 additions and 514 deletions
|
|
@ -11,8 +11,7 @@ else()
|
|||
endif()
|
||||
|
||||
file(GLOB test_kompute_CPP
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/TestMain.cpp"
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/TestWorkgroup.cpp"
|
||||
"${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
|
||||
)
|
||||
|
||||
add_executable(test_kompute ${test_kompute_CPP})
|
||||
|
|
|
|||
|
|
@ -37,25 +37,32 @@ TEST(TestAsyncOperations, TestManagerParallelExecution)
|
|||
}
|
||||
)");
|
||||
|
||||
std::vector<uint32_t> spirv = kp::Shader::compile_source(shader);
|
||||
|
||||
std::vector<float> data(size, 0.0);
|
||||
std::vector<float> resultSync(size, 100000000);
|
||||
std::vector<float> resultAsync(size, 100000000);
|
||||
|
||||
kp::Manager mgr;
|
||||
|
||||
std::shared_ptr<kp::Sequence> sq = mgr.sequence();
|
||||
|
||||
std::vector<std::shared_ptr<kp::Tensor>> inputsSyncB;
|
||||
std::vector<std::shared_ptr<kp::Algorithm>> algorithms;
|
||||
|
||||
for (uint32_t i = 0; i < numParallel; i++) {
|
||||
inputsSyncB.push_back(std::make_shared<kp::Tensor>(kp::Tensor(data)));
|
||||
inputsSyncB.push_back(mgr.tensor(data));
|
||||
algorithms.push_back(mgr.algorithm({ inputsSyncB[i] }, spirv));
|
||||
}
|
||||
|
||||
mgr.rebuild(inputsSyncB);
|
||||
sq->eval<kp::OpTensorSyncDevice>(inputsSyncB);
|
||||
|
||||
mgr.sequence()->eval<kp::OpTensorSyncDevice>(inputsSyncB);
|
||||
|
||||
auto startSync = std::chrono::high_resolution_clock::now();
|
||||
|
||||
for (uint32_t i = 0; i < numParallel; i++) {
|
||||
mgr.evalOpDefault<kp::OpAlgoCreate>(
|
||||
{ inputsSyncB[i] }, kp::Shader::compile_source(shader));
|
||||
sq->eval<kp::OpAlgoDispatch>(algorithms[i]);
|
||||
}
|
||||
|
||||
auto endSync = std::chrono::high_resolution_clock::now();
|
||||
|
|
@ -63,7 +70,7 @@ TEST(TestAsyncOperations, TestManagerParallelExecution)
|
|||
std::chrono::duration_cast<std::chrono::microseconds>(endSync - startSync)
|
||||
.count();
|
||||
|
||||
mgr.evalOpDefault<kp::OpTensorSyncLocal>(inputsSyncB);
|
||||
sq->eval<kp::OpTensorSyncLocal>(inputsSyncB);
|
||||
|
||||
for (uint32_t i = 0; i < numParallel; i++) {
|
||||
EXPECT_EQ(inputsSyncB[i]->data(), resultSync);
|
||||
|
|
@ -74,26 +81,23 @@ TEST(TestAsyncOperations, TestManagerParallelExecution)
|
|||
std::vector<std::shared_ptr<kp::Tensor>> inputsAsyncB;
|
||||
|
||||
for (uint32_t i = 0; i < numParallel; i++) {
|
||||
inputsAsyncB.push_back(std::make_shared<kp::Tensor>(kp::Tensor(data)));
|
||||
inputsAsyncB.push_back(mgr.tensor(data));
|
||||
}
|
||||
|
||||
mgrAsync.rebuild(inputsAsyncB);
|
||||
std::vector<std::shared_ptr<kp::Sequence>> sqs;
|
||||
|
||||
for (uint32_t i = 0; i < numParallel; i++) {
|
||||
mgrAsync.sequence("async" + std::to_string(i), i);
|
||||
sqs.push_back(mgrAsync.sequence(i));
|
||||
}
|
||||
|
||||
auto startAsync = std::chrono::high_resolution_clock::now();
|
||||
|
||||
for (uint32_t i = 0; i < numParallel; i++) {
|
||||
mgrAsync.evalOpAsync<kp::OpAlgoCreate>(
|
||||
{ inputsAsyncB[i] },
|
||||
"async" + std::to_string(i),
|
||||
kp::Shader::compile_source(shader));
|
||||
sqs[i]->evalAsync<kp::OpAlgoDispatch>(algorithms[i]);
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < numParallel; i++) {
|
||||
mgrAsync.evalOpAwait("async" + std::to_string(i));
|
||||
sqs[i]->evalAwait();
|
||||
}
|
||||
|
||||
auto endAsync = std::chrono::high_resolution_clock::now();
|
||||
|
|
@ -101,7 +105,7 @@ TEST(TestAsyncOperations, TestManagerParallelExecution)
|
|||
endAsync - startAsync)
|
||||
.count();
|
||||
|
||||
mgrAsync.evalOpDefault<kp::OpTensorSyncLocal>({ inputsAsyncB });
|
||||
sq->eval<kp::OpTensorSyncLocal>({ inputsAsyncB });
|
||||
|
||||
for (uint32_t i = 0; i < numParallel; i++) {
|
||||
EXPECT_EQ(inputsAsyncB[i]->data(), resultAsync);
|
||||
|
|
@ -138,32 +142,32 @@ TEST(TestAsyncOperations, TestManagerAsyncExecution)
|
|||
}
|
||||
)");
|
||||
|
||||
std::vector<uint32_t> spirv = kp::Shader::compile_source(shader);
|
||||
|
||||
std::vector<float> data(size, 0.0);
|
||||
std::vector<float> resultAsync(size, 100000000);
|
||||
|
||||
kp::Manager mgr;
|
||||
|
||||
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(data) };
|
||||
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(data) };
|
||||
std::shared_ptr<kp::Tensor> tensorA = mgr.tensor(data);
|
||||
std::shared_ptr<kp::Tensor> tensorB = mgr.tensor(data);
|
||||
|
||||
mgr.sequence("asyncOne");
|
||||
mgr.sequence("asyncTwo");
|
||||
std::shared_ptr<kp::Sequence> sq1 = mgr.sequence();
|
||||
std::shared_ptr<kp::Sequence> sq2 = mgr.sequence();
|
||||
|
||||
mgr.rebuild({ tensorA, tensorB });
|
||||
sq1->eval<kp::OpTensorSyncLocal>({ tensorA, tensorB });
|
||||
|
||||
std::vector<uint32_t> result = kp::Shader::compile_source(shader);
|
||||
std::shared_ptr<kp::Algorithm> algo1 = mgr.algorithm({tensorA});
|
||||
std::shared_ptr<kp::Algorithm> algo2 = mgr.algorithm({tensorB});
|
||||
|
||||
mgr.evalOpAsync<kp::OpAlgoCreate>(
|
||||
{ tensorA }, "asyncOne", kp::Shader::compile_source(shader));
|
||||
sq1->evalAsync<kp::OpAlgoDispatch>(algo1);
|
||||
sq2->evalAsync<kp::OpAlgoDispatch>(algo2);
|
||||
|
||||
mgr.evalOpAsync<kp::OpAlgoCreate>(
|
||||
{ tensorB }, "asyncTwo", kp::Shader::compile_source(shader));
|
||||
sq1->evalAwait();
|
||||
sq2->evalAwait();
|
||||
|
||||
mgr.evalOpAwait("asyncOne");
|
||||
mgr.evalOpAwait("asyncTwo");
|
||||
|
||||
mgr.evalOpAsyncDefault<kp::OpTensorSyncLocal>({ tensorA, tensorB });
|
||||
mgr.evalOpAwaitDefault();
|
||||
sq1->evalAsync<kp::OpTensorSyncLocal>({ tensorA, tensorB });
|
||||
sq1->evalAwait();
|
||||
|
||||
EXPECT_EQ(tensorA->data(), resultAsync);
|
||||
EXPECT_EQ(tensorB->data(), resultAsync);
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@
|
|||
|
||||
TEST(TestDestroy, TestDestroyTensorSingle)
|
||||
{
|
||||
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
|
||||
std::shared_ptr<kp::Tensor> tensorA = nullptr;
|
||||
|
||||
std::string shader(R"(
|
||||
#version 450
|
||||
|
|
@ -16,37 +16,36 @@ TEST(TestDestroy, TestDestroyTensorSingle)
|
|||
pa[index] = pa[index] + 1;
|
||||
})");
|
||||
|
||||
std::vector<uint32_t> spirv = kp::Shader::compile_source(shader);
|
||||
|
||||
{
|
||||
std::shared_ptr<kp::Sequence> sq = nullptr;
|
||||
|
||||
{
|
||||
kp::Manager mgr;
|
||||
|
||||
mgr.rebuild({ tensorA });
|
||||
tensorA = mgr.tensor({ 0, 0, 0 });
|
||||
|
||||
sq = mgr.sequence();
|
||||
std::shared_ptr<kp::Algorithm> algo =
|
||||
mgr.algorithm({ tensorA }, spirv);
|
||||
|
||||
sq->begin();
|
||||
sq->record<kp::OpAlgoCreate>(
|
||||
{ tensorA }, kp::Shader::compile_source(shader));
|
||||
sq->end();
|
||||
|
||||
sq->eval();
|
||||
|
||||
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA });
|
||||
|
||||
mgr.destroy(tensorA);
|
||||
mgr.sequence()
|
||||
->record<kp::OpAlgoDispatch>(algo)
|
||||
->eval()
|
||||
->eval<kp::OpTensorSyncLocal>(algo->getTensors());
|
||||
|
||||
tensorA->destroy();
|
||||
EXPECT_FALSE(tensorA->isInit());
|
||||
}
|
||||
EXPECT_FALSE(tensorA->isInit());
|
||||
}
|
||||
EXPECT_EQ(tensorA->data(), std::vector<float>({ 1, 1, 1 }));
|
||||
}
|
||||
|
||||
TEST(TestDestroy, TestDestroyTensorVector)
|
||||
{
|
||||
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 1, 1, 1 }) };
|
||||
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor({ 1, 1, 1 }) };
|
||||
std::shared_ptr<kp::Tensor> tensorA = nullptr;
|
||||
std::shared_ptr<kp::Tensor> tensorB = nullptr;
|
||||
|
||||
std::string shader(R"(
|
||||
#version 450
|
||||
|
|
@ -58,6 +57,7 @@ TEST(TestDestroy, TestDestroyTensorVector)
|
|||
pa[index] = pa[index] + 1;
|
||||
pb[index] = pb[index] + 2;
|
||||
})");
|
||||
std::vector<uint32_t> spirv = kp::Shader::compile_source(shader);
|
||||
|
||||
{
|
||||
std::shared_ptr<kp::Sequence> sq = nullptr;
|
||||
|
|
@ -65,20 +65,20 @@ TEST(TestDestroy, TestDestroyTensorVector)
|
|||
{
|
||||
kp::Manager mgr;
|
||||
|
||||
mgr.rebuild({ tensorA, tensorB });
|
||||
tensorA = mgr.tensor({ 1, 1, 1 });
|
||||
tensorB = mgr.tensor({ 1, 1, 1 });
|
||||
|
||||
sq = mgr.sequence();
|
||||
std::shared_ptr<kp::Algorithm> algo =
|
||||
mgr.algorithm({tensorA, tensorB}, spirv);
|
||||
|
||||
sq->begin();
|
||||
sq->record<kp::OpAlgoCreate>(
|
||||
{ tensorA, tensorB }, kp::Shader::compile_source(shader));
|
||||
sq->end();
|
||||
mgr.sequence()
|
||||
->record<kp::OpTensorSyncDevice>(algo->getTensors())
|
||||
->record<kp::OpAlgoDispatch>(algo)
|
||||
->record<kp::OpTensorSyncDevice>(algo->getTensors())
|
||||
->eval();
|
||||
|
||||
sq->eval();
|
||||
|
||||
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA, tensorB });
|
||||
|
||||
mgr.destroy({ tensorA, tensorB });
|
||||
tensorA->destroy();
|
||||
tensorB->destroy();
|
||||
|
||||
EXPECT_FALSE(tensorA->isInit());
|
||||
EXPECT_FALSE(tensorB->isInit());
|
||||
|
|
@ -88,32 +88,9 @@ TEST(TestDestroy, TestDestroyTensorVector)
|
|||
EXPECT_EQ(tensorB->data(), std::vector<float>({ 3, 3, 3 }));
|
||||
}
|
||||
|
||||
TEST(TestDestroy, TestDestroyTensorVectorUninitialised)
|
||||
{
|
||||
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 1, 1, 1 }) };
|
||||
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor({ 1, 1, 1 }) };
|
||||
|
||||
{
|
||||
std::shared_ptr<kp::Sequence> sq = nullptr;
|
||||
|
||||
{
|
||||
kp::Manager mgr;
|
||||
|
||||
mgr.rebuild({ tensorA, tensorB });
|
||||
|
||||
mgr.destroy({ tensorA, tensorB });
|
||||
|
||||
EXPECT_FALSE(tensorA->isInit());
|
||||
EXPECT_FALSE(tensorB->isInit());
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(tensorA->data(), std::vector<float>({ 1, 1, 1 }));
|
||||
EXPECT_EQ(tensorA->data(), std::vector<float>({ 1, 1, 1 }));
|
||||
}
|
||||
|
||||
TEST(TestDestroy, TestDestroySequenceSingle)
|
||||
{
|
||||
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
|
||||
std::shared_ptr<kp::Tensor> tensorA = nullptr;
|
||||
|
||||
std::string shader(R"(
|
||||
#version 450
|
||||
|
|
@ -124,26 +101,21 @@ TEST(TestDestroy, TestDestroySequenceSingle)
|
|||
pa[index] = pa[index] + 1;
|
||||
})");
|
||||
|
||||
std::vector<uint32_t> spirv = kp::Shader::compile_source(shader);
|
||||
|
||||
{
|
||||
std::shared_ptr<kp::Sequence> sq = nullptr;
|
||||
|
||||
{
|
||||
kp::Manager mgr;
|
||||
|
||||
mgr.rebuild({ tensorA });
|
||||
tensorA = mgr.tensor({0, 0, 0});
|
||||
|
||||
sq = mgr.sequence();
|
||||
|
||||
sq->begin();
|
||||
sq->record<kp::OpAlgoCreate>(
|
||||
{ tensorA }, kp::Shader::compile_source(shader));
|
||||
sq->end();
|
||||
|
||||
sq->eval();
|
||||
|
||||
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA });
|
||||
|
||||
mgr.destroy(sq);
|
||||
mgr.sequence()
|
||||
->record<kp::OpTensorSyncDevice>({tensorA})
|
||||
->record<kp::OpAlgoDispatch>(mgr.algorithm({tensorA}, spirv))
|
||||
->record<kp::OpTensorSyncLocal>({tensorA})
|
||||
->eval();
|
||||
|
||||
EXPECT_FALSE(sq->isInit());
|
||||
}
|
||||
|
|
@ -151,220 +123,3 @@ TEST(TestDestroy, TestDestroySequenceSingle)
|
|||
EXPECT_EQ(tensorA->data(), std::vector<float>({ 1, 1, 1 }));
|
||||
}
|
||||
|
||||
TEST(TestDestroy, TestDestroySequenceVector)
|
||||
{
|
||||
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> sq1 = nullptr;
|
||||
std::shared_ptr<kp::Sequence> sq2 = nullptr;
|
||||
|
||||
{
|
||||
kp::Manager mgr;
|
||||
|
||||
mgr.rebuild({ tensorA });
|
||||
|
||||
sq1 = mgr.sequence("One");
|
||||
sq1->begin();
|
||||
sq1->record<kp::OpAlgoCreate>(
|
||||
{ tensorA }, kp::Shader::compile_source(shader));
|
||||
sq1->end();
|
||||
sq1->eval();
|
||||
|
||||
sq2 = mgr.sequence("Two");
|
||||
sq2->begin();
|
||||
sq2->record<kp::OpAlgoCreate>(
|
||||
{ tensorA }, kp::Shader::compile_source(shader));
|
||||
sq2->end();
|
||||
sq2->eval();
|
||||
|
||||
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA });
|
||||
|
||||
mgr.destroy({ sq1, sq2 });
|
||||
|
||||
EXPECT_FALSE(sq1->isInit());
|
||||
EXPECT_FALSE(sq2->isInit());
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(tensorA->data(), std::vector<float>({ 2, 2, 2 }));
|
||||
}
|
||||
|
||||
TEST(TestDestroy, TestDestroySequenceNameSingleInsideManager)
|
||||
{
|
||||
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;
|
||||
})");
|
||||
|
||||
{
|
||||
kp::Manager mgr;
|
||||
{
|
||||
mgr.rebuild({ tensorA });
|
||||
|
||||
mgr.evalOp<kp::OpAlgoCreate>(
|
||||
{ tensorA }, "one",
|
||||
kp::Shader::compile_source(shader));
|
||||
|
||||
mgr.evalOp<kp::OpAlgoCreate>(
|
||||
{ tensorA }, "two",
|
||||
kp::Shader::compile_source(shader));
|
||||
|
||||
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA });
|
||||
|
||||
mgr.destroy("one");
|
||||
mgr.destroy("two");
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(tensorA->data(), std::vector<float>({ 2, 2, 2 }));
|
||||
}
|
||||
|
||||
TEST(TestDestroy, TestDestroySequenceNameSingleOutsideManager)
|
||||
{
|
||||
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> sq1 = nullptr;
|
||||
|
||||
{
|
||||
kp::Manager mgr;
|
||||
|
||||
mgr.rebuild({ tensorA });
|
||||
|
||||
sq1 = mgr.sequence("One");
|
||||
sq1->begin();
|
||||
sq1->record<kp::OpAlgoCreate>(
|
||||
{ tensorA }, kp::Shader::compile_source(shader));
|
||||
sq1->end();
|
||||
sq1->eval();
|
||||
|
||||
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA });
|
||||
|
||||
mgr.destroy("One");
|
||||
|
||||
EXPECT_FALSE(sq1->isInit());
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(tensorA->data(), std::vector<float>({ 1, 1, 1 }));
|
||||
}
|
||||
|
||||
TEST(TestDestroy, TestDestroySequenceNameVectorInsideManager)
|
||||
{
|
||||
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;
|
||||
})");
|
||||
|
||||
{
|
||||
kp::Manager mgr;
|
||||
{
|
||||
mgr.rebuild({ tensorA });
|
||||
|
||||
mgr.evalOp<kp::OpAlgoCreate>(
|
||||
{ tensorA }, "one",
|
||||
kp::Shader::compile_source(shader));
|
||||
|
||||
mgr.evalOp<kp::OpAlgoCreate>(
|
||||
{ tensorA }, "two",
|
||||
kp::Shader::compile_source(shader));
|
||||
|
||||
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA });
|
||||
|
||||
mgr.destroy(std::vector<std::string>({"one", "two"}));
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(tensorA->data(), std::vector<float>({ 2, 2, 2 }));
|
||||
}
|
||||
|
||||
TEST(TestDestroy, TestDestroySequenceNameVectorOutsideManager)
|
||||
{
|
||||
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;
|
||||
})");
|
||||
|
||||
{
|
||||
kp::Manager mgr;
|
||||
{
|
||||
mgr.rebuild({ tensorA });
|
||||
|
||||
mgr.evalOp<kp::OpAlgoCreate>(
|
||||
{ tensorA }, "one",
|
||||
kp::Shader::compile_source(shader));
|
||||
|
||||
mgr.evalOp<kp::OpAlgoCreate>(
|
||||
{ tensorA }, "two",
|
||||
kp::Shader::compile_source(shader));
|
||||
|
||||
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA });
|
||||
|
||||
mgr.destroy(std::vector<std::string>({"one", "two"}));
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(tensorA->data(), std::vector<float>({ 2, 2, 2 }));
|
||||
}
|
||||
|
||||
TEST(TestDestroy, TestDestroySequenceNameDefaultOutsideManager)
|
||||
{
|
||||
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;
|
||||
})");
|
||||
|
||||
{
|
||||
kp::Manager mgr;
|
||||
{
|
||||
mgr.rebuild({ tensorA });
|
||||
|
||||
mgr.evalOpDefault<kp::OpAlgoCreate>(
|
||||
{ tensorA },
|
||||
kp::Shader::compile_source(shader));
|
||||
|
||||
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorA });
|
||||
|
||||
mgr.destroy(KP_DEFAULT_SESSION);
|
||||
}
|
||||
}
|
||||
EXPECT_EQ(tensorA->data(), std::vector<float>({ 1, 1, 1 }));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,47 +11,40 @@ TEST(TestLogisticRegression, 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> 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> 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::vector<std::shared_ptr<kp::Tensor>> params = { xI, xJ, y,
|
||||
wIn, wOutI, wOutJ,
|
||||
bIn, bOut, lOut };
|
||||
|
||||
{
|
||||
kp::Manager mgr;
|
||||
|
||||
mgr.rebuild(params);
|
||||
std::shared_ptr<kp::Tensor> xI = mgr.tensor({ 0, 1, 1, 1, 1 });
|
||||
std::shared_ptr<kp::Tensor> xJ = mgr.tensor({ 0, 0, 0, 1, 1 });
|
||||
|
||||
std::shared_ptr<kp::Sequence> sq = mgr.sequence();
|
||||
std::shared_ptr<kp::Tensor> y = mgr.tensor({ 0, 0, 0, 1, 1 });
|
||||
|
||||
// Record op algo base
|
||||
sq->begin();
|
||||
std::shared_ptr<kp::Tensor> wIn = mgr.tensor({ 0.001, 0.001 });
|
||||
std::shared_ptr<kp::Tensor> wOutI = mgr.tensor({ 0, 0, 0, 0, 0 });
|
||||
std::shared_ptr<kp::Tensor> wOutJ = mgr.tensor({ 0, 0, 0, 0, 0 });
|
||||
|
||||
sq->record<kp::OpTensorSyncDevice>({ wIn, bIn });
|
||||
std::shared_ptr<kp::Tensor> bIn = mgr.tensor({ 0 });
|
||||
std::shared_ptr<kp::Tensor> bOut = mgr.tensor({ 0, 0, 0, 0, 0 });
|
||||
|
||||
sq->record<kp::OpAlgoCreate>(
|
||||
params,
|
||||
std::vector<uint32_t>(
|
||||
std::shared_ptr<kp::Tensor> lOut = mgr.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<uint32_t> spirv = std::vector<uint32_t>(
|
||||
(uint32_t*)kp::shader_data::shaders_glsl_logisticregression_comp_spv,
|
||||
(uint32_t*)(kp::shader_data::shaders_glsl_logisticregression_comp_spv +
|
||||
kp::shader_data::shaders_glsl_logisticregression_comp_spv_len)),
|
||||
kp::Workgroup(), kp::Constants({5.0}));
|
||||
kp::shader_data::shaders_glsl_logisticregression_comp_spv_len));
|
||||
|
||||
sq->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
|
||||
std::shared_ptr<kp::Algorithm> algorithm =
|
||||
mgr.algorithm(params, spirv, kp::Workgroup(), kp::Constants({5.0}));
|
||||
|
||||
sq->end();
|
||||
std::shared_ptr<kp::Sequence> sq =
|
||||
mgr.sequence()
|
||||
->record<kp::OpTensorSyncDevice>({ wIn, bIn })
|
||||
->record<kp::OpAlgoDispatch>(algorithm)
|
||||
->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
|
||||
|
||||
// Iterate across all expected iterations
|
||||
for (size_t i = 0; i < ITERATIONS; i++) {
|
||||
|
|
@ -64,21 +57,21 @@ TEST(TestLogisticRegression, TestMainLogisticRegression)
|
|||
bIn->data()[0] -= learningRate * bOut->data()[j];
|
||||
}
|
||||
}
|
||||
|
||||
// Based on the inputs the outputs should be at least:
|
||||
// * wi < 0.01
|
||||
// * wj > 1.0
|
||||
// * b < 0
|
||||
// TODO: Add EXPECT_DOUBLE_EQ instead
|
||||
EXPECT_LT(wIn->data()[0], 0.01);
|
||||
EXPECT_GT(wIn->data()[1], 1.0);
|
||||
EXPECT_LT(bIn->data()[0], 0.0);
|
||||
|
||||
KP_LOG_WARN("Result wIn i: {}, wIn j: {}, bIn: {}",
|
||||
wIn->data()[0],
|
||||
wIn->data()[1],
|
||||
bIn->data()[0]);
|
||||
}
|
||||
|
||||
// Based on the inputs the outputs should be at least:
|
||||
// * wi < 0.01
|
||||
// * wj > 1.0
|
||||
// * b < 0
|
||||
// TODO: Add EXPECT_DOUBLE_EQ instead
|
||||
EXPECT_LT(wIn->data()[0], 0.01);
|
||||
EXPECT_GT(wIn->data()[1], 1.0);
|
||||
EXPECT_LT(bIn->data()[0], 0.0);
|
||||
|
||||
KP_LOG_WARN("Result wIn i: {}, wIn j: {}, bIn: {}",
|
||||
wIn->data()[0],
|
||||
wIn->data()[1],
|
||||
bIn->data()[0]);
|
||||
}
|
||||
|
||||
TEST(TestLogisticRegression, TestMainLogisticRegressionManualCopy)
|
||||
|
|
@ -87,50 +80,43 @@ TEST(TestLogisticRegression, TestMainLogisticRegressionManualCopy)
|
|||
uint32_t ITERATIONS = 100;
|
||||
float learningRate = 0.1;
|
||||
|
||||
kp::Constants 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> y{ new kp::Tensor({ 0, 0, 0, 1, 1 }) };
|
||||
|
||||
std::shared_ptr<kp::Tensor> wIn{ new kp::Tensor(
|
||||
wInVec, kp::Tensor::TensorTypes::eHost) };
|
||||
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::eHost) };
|
||||
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::vector<std::shared_ptr<kp::Tensor>> params = { xI, xJ, y,
|
||||
wIn, wOutI, wOutJ,
|
||||
bIn, bOut, lOut };
|
||||
|
||||
{
|
||||
kp::Manager mgr;
|
||||
|
||||
mgr.rebuild(params);
|
||||
std::shared_ptr<kp::Tensor> xI = mgr.tensor({ 0, 1, 1, 1, 1 });
|
||||
std::shared_ptr<kp::Tensor> xJ = mgr.tensor({ 0, 0, 0, 1, 1 });
|
||||
|
||||
std::shared_ptr<kp::Sequence> sq = mgr.sequence();
|
||||
std::shared_ptr<kp::Tensor> y = mgr.tensor({ 0, 0, 0, 1, 1 });
|
||||
|
||||
// Record op algo base
|
||||
sq->begin();
|
||||
std::shared_ptr<kp::Tensor> wIn = mgr.tensor(
|
||||
{ 0.001, 0.001 }, kp::Tensor::TensorTypes::eHost);
|
||||
std::shared_ptr<kp::Tensor> wOutI = mgr.tensor({ 0, 0, 0, 0, 0 });
|
||||
std::shared_ptr<kp::Tensor> wOutJ = mgr.tensor({ 0, 0, 0, 0, 0 });
|
||||
|
||||
sq->record<kp::OpAlgoCreate>(
|
||||
params,
|
||||
std::vector<uint32_t>(
|
||||
std::shared_ptr<kp::Tensor> bIn = mgr.tensor(
|
||||
{ 0 },
|
||||
kp::Tensor::TensorTypes::eHost);
|
||||
std::shared_ptr<kp::Tensor> bOut = mgr.tensor({ 0, 0, 0, 0, 0 });
|
||||
|
||||
std::shared_ptr<kp::Tensor> lOut = mgr.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<uint32_t> spirv = std::vector<uint32_t>(
|
||||
(uint32_t*)kp::shader_data::shaders_glsl_logisticregression_comp_spv,
|
||||
(uint32_t*)(kp::shader_data::shaders_glsl_logisticregression_comp_spv +
|
||||
kp::shader_data::shaders_glsl_logisticregression_comp_spv_len)),
|
||||
kp::Workgroup(), kp::Constants({5.0}));
|
||||
kp::shader_data::shaders_glsl_logisticregression_comp_spv_len));
|
||||
|
||||
sq->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
|
||||
std::shared_ptr<kp::Algorithm> algorithm =
|
||||
mgr.algorithm(params, spirv, kp::Workgroup(), kp::Constants({5.0}));
|
||||
|
||||
sq->end();
|
||||
std::shared_ptr<kp::Sequence> sq =
|
||||
mgr.sequence()
|
||||
->record<kp::OpTensorSyncDevice>({ wIn, bIn })
|
||||
->record<kp::OpAlgoDispatch>(algorithm)
|
||||
->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
|
||||
|
||||
// Iterate across all expected iterations
|
||||
for (size_t i = 0; i < ITERATIONS; i++) {
|
||||
|
|
@ -145,7 +131,6 @@ TEST(TestLogisticRegression, TestMainLogisticRegressionManualCopy)
|
|||
wIn->mapDataIntoHostMemory();
|
||||
bIn->mapDataIntoHostMemory();
|
||||
}
|
||||
}
|
||||
|
||||
// Based on the inputs the outputs should be at least:
|
||||
// * wi < 0.01
|
||||
|
|
@ -160,4 +145,5 @@ TEST(TestLogisticRegression, TestMainLogisticRegressionManualCopy)
|
|||
wIn->data()[0],
|
||||
wIn->data()[1],
|
||||
bIn->data()[0]);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,9 +3,6 @@
|
|||
|
||||
#include "kompute/Kompute.hpp"
|
||||
|
||||
#include "kompute_test/shaders/shadertest_workgroup.hpp"
|
||||
|
||||
|
||||
TEST(TestWorkgroup, TestSimpleWorkgroup)
|
||||
{
|
||||
std::shared_ptr<kp::Tensor> tensorA = nullptr;
|
||||
|
|
@ -31,9 +28,9 @@ TEST(TestWorkgroup, TestSimpleWorkgroup)
|
|||
std::shared_ptr<kp::Algorithm> algorithm = mgr.algorithm(params, spirv, workgroup);
|
||||
|
||||
sq = mgr.sequence();
|
||||
sq->record(std::make_shared<kp::OpTensorSyncDevice>(params));
|
||||
sq->record(std::make_shared<kp::OpAlgoDispatch>(params, algorithm));
|
||||
sq->record(std::make_shared<kp::OpTensorSyncLocal>(params));
|
||||
sq->record<kp::OpTensorSyncDevice>(params);
|
||||
sq->record<kp::OpAlgoDispatch>(params, algorithm);
|
||||
sq->record<kp::OpTensorSyncLocal>(params);
|
||||
sq->eval();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue