nomic-ai/kompute
1
0
Fork 0
mirror of https://github.com/nomic-ai/kompute.git synced 2026-05-11 08:59:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

Updated to current multiple queue implementation

Browse Source
This commit is contained in:
Alejandro Saucedo
2020-10-15 21:40:31 +01:00
parent 3e5364fc44
commit 4e697bb787
4 changed files with 151 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

101
test/TestAsyncOperations.cpp
View File

@@ -9,21 +9,6 @@ TEST(TestAsyncOperations, TestManagerAsync)
{
uint32_t size = 100000;
std::vector<float> data(size, 0.0);
std::vector<float> resultSync(size, 100000);
std::vector<float> resultAsync(size, 200000);
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> tensorC{ new kp::Tensor(data) };
std::shared_ptr<kp::Tensor> tensorD{ new kp::Tensor(data) };
std::shared_ptr<kp::Tensor> tensorE{ new kp::Tensor(data) };
std::shared_ptr<kp::Tensor> tensorF{ new kp::Tensor(data) };
kp::Manager mgr;
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB, tensorC, tensorD, tensorE, tensorF });
std::string shader(R"(
#version 450
@@ -44,52 +29,82 @@ TEST(TestAsyncOperations, TestManagerAsync)
}
)");
std::vector<float> data(size, 0.0);
std::vector<float> resultSync(size, 100000);
std::vector<float> resultAsync(size, 100000);
std::shared_ptr<kp::Tensor> tensorSyncA{ new kp::Tensor(data) };
std::shared_ptr<kp::Tensor> tensorSyncB{ new kp::Tensor(data) };
std::shared_ptr<kp::Tensor> tensorSyncC{ new kp::Tensor(data) };
std::shared_ptr<kp::Tensor> tensorSyncD{ new kp::Tensor(data) };
std::shared_ptr<kp::Tensor> tensorSyncE{ new kp::Tensor(data) };
std::shared_ptr<kp::Tensor> tensorSyncF{ new kp::Tensor(data) };
kp::Manager mgr;
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorSyncA, tensorSyncB, tensorSyncC, tensorSyncD, tensorSyncE, tensorSyncF });
auto startSync = std::chrono::high_resolution_clock::now();
mgr.evalOpDefault<kp::OpAlgoBase<>>(
{ tensorA, tensorB }, std::vector<char>(shader.begin(), shader.end()));
{ tensorSyncA, tensorSyncB }, std::vector<char>(shader.begin(), shader.end()));
mgr.evalOpDefault<kp::OpAlgoBase<>>(
{ tensorC, tensorD }, std::vector<char>(shader.begin(), shader.end()));
{ tensorSyncC, tensorSyncD }, std::vector<char>(shader.begin(), shader.end()));
mgr.evalOpDefault<kp::OpAlgoBase<>>(
{ tensorE, tensorF }, std::vector<char>(shader.begin(), shader.end()));
{ tensorSyncE, tensorSyncF }, std::vector<char>(shader.begin(), shader.end()));
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorSyncB, tensorSyncD, tensorSyncF });
auto endSync = std::chrono::high_resolution_clock::now();
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB, tensorD, tensorF });
EXPECT_EQ(tensorB->data(), resultSync);
EXPECT_EQ(tensorD->data(), resultSync);
EXPECT_EQ(tensorF->data(), resultSync);
auto durationSync = std::chrono::duration_cast<std::chrono::microseconds>(endSync - startSync).count();
auto startAsync = std::chrono::high_resolution_clock::now();
EXPECT_EQ(tensorSyncB->data(), resultSync);
EXPECT_EQ(tensorSyncD->data(), resultSync);
EXPECT_EQ(tensorSyncF->data(), resultSync);
mgr.evalOpAsync<kp::OpAlgoBase<>>(
{ tensorA, tensorB }, "asyncOne", std::vector<char>(shader.begin(), shader.end()));
//std::shared_ptr<kp::Tensor> tensorAsyncA{ new kp::Tensor(data) };
//std::shared_ptr<kp::Tensor> tensorAsyncB{ new kp::Tensor(data) };
//std::shared_ptr<kp::Tensor> tensorAsyncC{ new kp::Tensor(data) };
//std::shared_ptr<kp::Tensor> tensorAsyncD{ new kp::Tensor(data) };
//std::shared_ptr<kp::Tensor> tensorAsyncE{ new kp::Tensor(data) };
//std::shared_ptr<kp::Tensor> tensorAsyncF{ new kp::Tensor(data) };
mgr.evalOpAsync<kp::OpAlgoBase<>>(
{ tensorC, tensorD }, "asyncTwo", std::vector<char>(shader.begin(), shader.end()));
//kp::Manager mgrAsync(0, 1);
mgr.evalOpAsync<kp::OpAlgoBase<>>(
{ tensorE, tensorF }, "asyncThree", std::vector<char>(shader.begin(), shader.end()));
//mgrAsync.evalOpDefault<kp::OpTensorCreate>({ tensorAsyncA, tensorAsyncB, tensorAsyncC, tensorAsyncD, tensorAsyncE, tensorAsyncF });
mgr.evalOpAwait("asyncOne");
mgr.evalOpAwait("asyncTwo");
mgr.evalOpAwait("asyncThree");
//mgrAsync.createManagedSequence("async0", 0);
////mgrAsync.createManagedSequence("async1", 1);
////mgrAsync.createManagedSequence("async2", 2);
auto endAsync = std::chrono::high_resolution_clock::now();
//auto startAsync = std::chrono::high_resolution_clock::now();
auto durationAsync = std::chrono::duration_cast<std::chrono::microseconds>(endAsync - startAsync).count();
//mgrAsync.evalOpAsync<kp::OpAlgoBase<>>(
// { tensorAsyncA, tensorAsyncB }, "async0", std::vector<char>(shader.begin(), shader.end()));
mgr.evalOpDefault<kp::OpTensorSyncLocal>({ tensorB, tensorD, tensorF });
////mgrAsync.evalOpAsync<kp::OpAlgoBase<>>(
//// { tensorAsyncC, tensorAsyncD }, "async1", std::vector<char>(shader.begin(), shader.end()));
EXPECT_EQ(tensorB->data(), resultAsync);
EXPECT_EQ(tensorD->data(), resultAsync);
EXPECT_EQ(tensorF->data(), resultAsync);
////mgrAsync.evalOpAsync<kp::OpAlgoBase<>>(
//// { tensorAsyncE, tensorAsyncF }, "async2", std::vector<char>(shader.begin(), shader.end()));
SPDLOG_DEBUG("Total Sync: {}", durationSync);
SPDLOG_DEBUG("Total Async: {}", durationAsync);
//mgrAsync.evalOpAwait("async0");
////mgrAsync.evalOpAwait("async1");
////mgrAsync.evalOpAwait("async2");
//mgrAsync.evalOpDefault<kp::OpTensorSyncLocal>({ tensorAsyncB });
////mgrAsync.evalOpDefault<kp::OpTensorSyncLocal>({ tensorAsyncD });
////mgrAsync.evalOpDefault<kp::OpTensorSyncLocal>({ tensorAsyncF });
//auto endAsync = std::chrono::high_resolution_clock::now();
//auto durationAsync = std::chrono::duration_cast<std::chrono::microseconds>(endAsync - startAsync).count();
//EXPECT_EQ(tensorAsyncB->data(), resultAsync);
////EXPECT_EQ(tensorAsyncD->data(), resultAsync);
////EXPECT_EQ(tensorAsyncF->data(), resultAsync);
////SPDLOG_DEBUG("Total Sync: {}", durationSync);
//SPDLOG_DEBUG("Total Async: {}", durationAsync);
}