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

Updated tests to use new constraints on unique default operations

Browse source
This commit is contained in:
Alejandro Saucedo 2020-10-18 16:04:52 +01:00
parent ba71c7ab46
commit 7679070274
3 changed files with 103 additions and 97 deletions
Download patch file Download diff file Expand all files Collapse all files

31
test/TestAsyncOperations.cpp
View file

@ -142,23 +142,32 @@ TEST(TestAsyncOperations, TestManagerAsyncExecution)
std::vector<float> data(size, 0.0);
std::vector<float> resultAsync(size, 100000000);
kp::Manager mgrAsync(0);
kp::Manager mgr;
std::vector<std::shared_ptr<kp::Tensor>> inputsAsyncB;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor(data) };
std::shared_ptr<kp::Tensor> tensorB{ new kp::Tensor(data) };
inputsAsyncB.push_back(std::make_shared<kp::Tensor>(kp::Tensor(data)));
mgr.createManagedSequence("asyncOne");
mgr.createManagedSequence("asyncTwo");
mgrAsync.evalOpAsyncDefault<kp::OpTensorCreate>(inputsAsyncB);
mgrAsync.evalOpAwaitDefault();
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
mgrAsync.evalOpAsyncDefault<kp::OpAlgoBase<>>(
{ inputsAsyncB[0] },
mgr.evalOpAsync<kp::OpAlgoBase<>>(
{ tensorA },
"asyncOne",
std::vector<char>(shader.begin(), shader.end()));
mgrAsync.evalOpAwaitDefault();
mgr.evalOpAsync<kp::OpAlgoBase<>>(
{ tensorB },
"asyncTwo",
std::vector<char>(shader.begin(), shader.end()));
mgrAsync.evalOpAsyncDefault<kp::OpTensorSyncLocal>({ inputsAsyncB });
mgrAsync.evalOpAwaitDefault();
mgr.evalOpAwait("asyncOne");
mgr.evalOpAwait("asyncTwo");
EXPECT_EQ(inputsAsyncB[0]->data(), resultAsync);
mgr.evalOpAsyncDefault<kp::OpTensorSyncLocal>({ tensorA, tensorB });
mgr.evalOpAwaitDefault();
EXPECT_EQ(tensorA->data(), resultAsync);
EXPECT_EQ(tensorB->data(), resultAsync);
}

108
test/TestLogisticRegression.cpp
View file

@ -31,38 +31,38 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegression)
{
kp::Manager mgr;
if (std::shared_ptr<kp::Sequence> sq =
mgr.getOrCreateManagedSequence("createTensors").lock()) {
std::shared_ptr<kp::Sequence> sqTensor =
mgr.createManagedSequence().lock();
sq->begin();
sqTensor->begin();
sqTensor->record<kp::OpTensorCreate>(params);
sqTensor->end();
sqTensor->eval();
sq->record<kp::OpTensorCreate>(params);
std::shared_ptr<kp::Sequence> sq =
mgr.createManagedSequence().lock();
// Record op algo base
sq->begin();
sq->record<kp::OpTensorSyncDevice>({ wIn, bIn });
sq->record<kp::OpAlgoBase<>>(
params, "test/shaders/glsl/test_logistic_regression.comp");
sq->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
sq->end();
// Iterate across all expected iterations
for (size_t i = 0; i < ITERATIONS; i++) {
sq->end();
sq->eval();
// Record op algo base
sq->begin();
sq->record<kp::OpTensorSyncDevice>({ wIn, bIn });
sq->record<kp::OpAlgoBase<>>(
params, "test/shaders/glsl/test_logistic_regression.comp");
sq->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
sq->end();
// Iterate across all expected iterations
for (size_t i = 0; i < ITERATIONS; i++) {
sq->eval();
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];
}
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];
}
}
}
@ -115,39 +115,39 @@ TEST(TestLogisticRegressionAlgorithm, TestMainLogisticRegressionManualCopy)
{
kp::Manager mgr;
if (std::shared_ptr<kp::Sequence> sq =
mgr.getOrCreateManagedSequence("createTensors").lock()) {
std::shared_ptr<kp::Sequence> sqTensor =
mgr.createManagedSequence().lock();
sq->begin();
sqTensor->begin();
sqTensor->record<kp::OpTensorCreate>(params);
sqTensor->end();
sqTensor->eval();
sq->record<kp::OpTensorCreate>(params);
std::shared_ptr<kp::Sequence> sq =
mgr.createManagedSequence().lock();
// Record op algo base
sq->begin();
sq->record<kp::OpAlgoBase<>>(
params, "test/shaders/glsl/test_logistic_regression.comp");
sq->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
sq->end();
// Iterate across all expected iterations
for (size_t i = 0; i < ITERATIONS; i++) {
sq->end();
sq->eval();
// Record op algo base
sq->begin();
sq->record<kp::OpAlgoBase<>>(
params, "test/shaders/glsl/test_logistic_regression.comp");
sq->record<kp::OpTensorSyncLocal>({ wOutI, wOutJ, bOut, lOut });
sq->end();
// Iterate across all expected iterations
for (size_t i = 0; i < ITERATIONS; i++) {
sq->eval();
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];
}
wIn->mapDataIntoHostMemory();
bIn->mapDataIntoHostMemory();
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];
}
wIn->mapDataIntoHostMemory();
bIn->mapDataIntoHostMemory();
}
}

61
test/TestMultipleAlgoExecutions.cpp
View file

@ -45,7 +45,6 @@ TEST(TestMultipleAlgoExecutions, SingleSequenceRecord)
TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords)
{
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorA{ new kp::Tensor({ 0, 0, 0 }) };
@ -59,43 +58,41 @@ TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords)
pa[index] = pa[index] + 1;
})");
std::weak_ptr<kp::Sequence> sqWeakPtr =
mgr.getOrCreateManagedSequence("newSequence");
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
std::shared_ptr<kp::Sequence> sqTensor =
mgr.createManagedSequence().lock();
sq->record<kp::OpTensorCreate>({ tensorA });
std::shared_ptr<kp::Sequence> sq =
mgr.createManagedSequence().lock();
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
// First create the tensor in a separate sequence
sqTensor->begin();
sqTensor->record<kp::OpTensorCreate>({ tensorA });
sqTensor->end();
sqTensor->eval();
sq->end();
sq->eval();
// Then perform the computations
sq->begin();
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->end();
sq->eval();
sq->begin();
sq->begin();
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->end();
sq->eval();
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->begin();
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->end();
sq->eval();
sq->end();
sq->eval();
sq->begin();
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA }, std::vector<char>(shader.begin(), shader.end()));
sq->end();
sq->eval();
sq->begin();
sq->record<kp::OpTensorSyncLocal>({ tensorA });
sq->end();
sq->eval();
}
sqWeakPtr.reset();
sq->begin();
sq->record<kp::OpTensorSyncLocal>({ tensorA });
sq->end();
sq->eval();
EXPECT_EQ(tensorA->data(), std::vector<float>({ 3, 3, 3 }));
}