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

Renamed tensorcreate and started adding optensorsyncdevice

Browse source
This commit is contained in:
Alejandro Saucedo 2020-09-06 11:38:08 +01:00
parent 236c349aa0
commit ec89fc6d56
17 changed files with 318 additions and 71 deletions
Download patch file Download diff file Expand all files Collapse all files

2
test/TestLogisticRegression.cpp
View file

@ -35,7 +35,7 @@ TEST(LogisticRegressionAlgorithm, TestMainLogisticRegression) {
sq->begin();
sq->record<kp::OpCreateTensor>(params);
sq->record<kp::OpTensorCreate>(params);
sq->end();
sq->eval();

14
test/TestManager.cpp
View file

@ -8,15 +8,15 @@ TEST(TestManager, EndToEndOpMultFlow)
kp::Manager mgr;
std::shared_ptr<kp::Tensor> tensorLHS{ new kp::Tensor({ 0, 1, 2 }) };
mgr.evalOp<kp::OpCreateTensor>({ tensorLHS });
mgr.evalOp<kp::OpTensorCreate>({ tensorLHS });
std::shared_ptr<kp::Tensor> tensorRHS{ new kp::Tensor(
{ 2, 4, 6 }) };
mgr.evalOp<kp::OpCreateTensor>({ tensorRHS });
mgr.evalOp<kp::OpTensorCreate>({ tensorRHS });
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor(
{ 0, 0, 0 }) };
mgr.evalOp<kp::OpCreateTensor>({ tensorOutput });
mgr.evalOp<kp::OpTensorCreate>({ tensorOutput });
mgr.evalOp<kp::OpMult<>>({ tensorLHS, tensorRHS, tensorOutput });
@ -40,9 +40,9 @@ TEST(TestManager, OpMultSequenceFlow) {
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
sq->record<kp::OpCreateTensor>({ tensorLHS });
sq->record<kp::OpCreateTensor>({ tensorRHS });
sq->record<kp::OpCreateTensor>({ tensorOutput });
sq->record<kp::OpTensorCreate>({ tensorLHS });
sq->record<kp::OpTensorCreate>({ tensorRHS });
sq->record<kp::OpTensorCreate>({ tensorOutput });
sq->record<kp::OpMult<>>({ tensorLHS, tensorRHS, tensorOutput });
@ -92,7 +92,7 @@ TEST(TestManager, TestMultipleTensorsAtOnce) {
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
sq->record<kp::OpCreateTensor>({ tensorLHS, tensorRHS, tensorOutput });
sq->record<kp::OpTensorCreate>({ tensorLHS, tensorRHS, tensorOutput });
EXPECT_TRUE(tensorLHS->isInit());
EXPECT_TRUE(tensorRHS->isInit());

8
test/TestMultipleAlgoExecutions.cpp
View file

@ -23,7 +23,7 @@ TEST(TestMultipleAlgoExecutions, SingleSequenceRecord) {
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
sq->record<kp::OpCreateTensor>({ tensorA });
sq->record<kp::OpTensorCreate>({ tensorA });
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA },
@ -66,7 +66,7 @@ TEST(TestMultipleAlgoExecutions, MultipleCmdBufRecords) {
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
sq->record<kp::OpCreateTensor>({ tensorA });
sq->record<kp::OpTensorCreate>({ tensorA });
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA },
@ -122,7 +122,7 @@ TEST(TestMultipleAlgoExecutions, MultipleSequences) {
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
sq->record<kp::OpCreateTensor>({ tensorA });
sq->record<kp::OpTensorCreate>({ tensorA });
sq->record<kp::OpAlgoBase<3, 1, 1>>(
{ tensorA },
@ -183,7 +183,7 @@ TEST(TestMultipleAlgoExecutions, SingleRecordMultipleEval) {
if (std::shared_ptr<kp::Sequence> sq = sqWeakPtr.lock()) {
sq->begin();
sq->record<kp::OpCreateTensor>({ tensorA });
sq->record<kp::OpTensorCreate>({ tensorA });
sq->end();
sq->eval();

8
test/TestOpShadersFromStringAndFile.cpp
View file

@ -10,7 +10,7 @@ TEST(TestOpAlgoBase, ShaderRawDataFromConstructor) {
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::OpCreateTensor>({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
std::string shader(R"(
#version 450
@ -41,7 +41,7 @@ TEST(TestOpAlgoBase, ShaderCompiledDataFromConstructor) {
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::OpCreateTensor>({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpAlgoBase<>>(
{ tensorA, tensorB },
@ -60,7 +60,7 @@ TEST(TestOpAlgoBase, ShaderRawDataFromFile) {
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::OpCreateTensor>({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpAlgoBase<>>(
{ tensorA, tensorB },
@ -76,7 +76,7 @@ TEST(TestOpAlgoBase, ShaderCompiledDataFromFile) {
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::OpCreateTensor>({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpTensorCreate>({ tensorA, tensorB });
mgr.evalOpDefault<kp::OpAlgoBase<>>(
{ tensorA, tensorB },

111
test/TestOpTensorCopy.cpp Normal file
View file

@ -0,0 +1,111 @@
#include "gtest/gtest.h"
#include "kompute/Kompute.hpp"
TEST(TestOpTensorCopy, CopyDeviceToDeviceTensor) {
kp::Manager mgr;
std::vector<float> testVecA{ 9, 8, 7 };
std::shared_ptr<kp::Tensor> tensorA{new kp::Tensor(testVecA)};
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA});
EXPECT_TRUE(tensorA->isInit());
EXPECT_EQ(tensorA->data(), testVecA);
tensorA->freeMemoryDestroyGPUResources();
EXPECT_FALSE(tensorA->isInit());
}
TEST(TestOpTensorCopy, 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.evalOpDefault<kp::OpTensorCreate>({tensorA, tensorB});
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
EXPECT_EQ(tensorA->data(), testVecA);
EXPECT_EQ(tensorB->data(), testVecB);
}
TEST(TestOpTensorCopy, 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.evalOpDefault<kp::OpTensorCreate>({tensorA});
mgr.evalOpDefault<kp::OpTensorCreate>({tensorB});
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
EXPECT_EQ(tensorA->data(), testVecA);
EXPECT_EQ(tensorB->data(), testVecB);
}
TEST(TestOpTensorCopy, 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)};
{
kp::Manager mgr;
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA});
mgr.evalOpDefault<kp::OpTensorCreate>({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(TestOpTensorCopy, 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.evalOpDefault<kp::OpTensorCreate>({tensorA});
mgr.evalOpDefault<kp::OpTensorCreate>({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());
}

26
test/TestOpCreateTensor.cpp → test/TestOpTensorCreate.cpp
View file

@ -3,7 +3,7 @@
#include "kompute/Kompute.hpp"
TEST(TestOpCreateTensor, CreateSingleTensorSingleOp) {
TEST(TestOpTensorCreate, CreateSingleTensorSingleOp) {
kp::Manager mgr;
@ -11,7 +11,7 @@ TEST(TestOpCreateTensor, CreateSingleTensorSingleOp) {
std::shared_ptr<kp::Tensor> tensorA{new kp::Tensor(testVecA)};
mgr.evalOpDefault<kp::OpCreateTensor>({tensorA});
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA});
EXPECT_TRUE(tensorA->isInit());
@ -21,7 +21,7 @@ TEST(TestOpCreateTensor, CreateSingleTensorSingleOp) {
EXPECT_FALSE(tensorA->isInit());
}
TEST(TestOpCreateTensor, CreateMultipleTensorSingleOp) {
TEST(TestOpTensorCreate, CreateMultipleTensorSingleOp) {
kp::Manager mgr;
@ -31,7 +31,7 @@ TEST(TestOpCreateTensor, CreateMultipleTensorSingleOp) {
std::shared_ptr<kp::Tensor> tensorA{new kp::Tensor(testVecA)};
std::shared_ptr<kp::Tensor> tensorB{new kp::Tensor(testVecB)};
mgr.evalOpDefault<kp::OpCreateTensor>({tensorA, tensorB});
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA, tensorB});
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
@ -40,7 +40,7 @@ TEST(TestOpCreateTensor, CreateMultipleTensorSingleOp) {
EXPECT_EQ(tensorB->data(), testVecB);
}
TEST(TestOpCreateTensor, CreateMultipleTensorMultipleOp) {
TEST(TestOpTensorCreate, CreateMultipleTensorMultipleOp) {
kp::Manager mgr;
@ -50,8 +50,8 @@ TEST(TestOpCreateTensor, CreateMultipleTensorMultipleOp) {
std::shared_ptr<kp::Tensor> tensorA{new kp::Tensor(testVecA)};
std::shared_ptr<kp::Tensor> tensorB{new kp::Tensor(testVecB)};
mgr.evalOpDefault<kp::OpCreateTensor>({tensorA});
mgr.evalOpDefault<kp::OpCreateTensor>({tensorB});
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA});
mgr.evalOpDefault<kp::OpTensorCreate>({tensorB});
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
@ -60,7 +60,7 @@ TEST(TestOpCreateTensor, CreateMultipleTensorMultipleOp) {
EXPECT_EQ(tensorB->data(), testVecB);
}
TEST(TestOpCreateTensor, ManageTensorMemoryWhenOpCreateTensorDestroyed) {
TEST(TestOpTensorCreate, ManageTensorMemoryWhenOpTensorCreateDestroyed) {
std::vector<float> testVecA{ 9, 8, 7 };
std::vector<float> testVecB{ 6, 5, 4 };
@ -70,8 +70,8 @@ TEST(TestOpCreateTensor, ManageTensorMemoryWhenOpCreateTensorDestroyed) {
{
kp::Manager mgr;
mgr.evalOpDefault<kp::OpCreateTensor>({tensorA});
mgr.evalOpDefault<kp::OpCreateTensor>({tensorB});
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA});
mgr.evalOpDefault<kp::OpTensorCreate>({tensorB});
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());
@ -84,7 +84,7 @@ TEST(TestOpCreateTensor, ManageTensorMemoryWhenOpCreateTensorDestroyed) {
EXPECT_FALSE(tensorB->isInit());
}
TEST(TestOpCreateTensor, NoErrorIfTensorFreedBefore) {
TEST(TestOpTensorCreate, NoErrorIfTensorFreedBefore) {
std::vector<float> testVecA{ 9, 8, 7 };
std::vector<float> testVecB{ 6, 5, 4 };
@ -94,8 +94,8 @@ TEST(TestOpCreateTensor, NoErrorIfTensorFreedBefore) {
kp::Manager mgr;
mgr.evalOpDefault<kp::OpCreateTensor>({tensorA});
mgr.evalOpDefault<kp::OpCreateTensor>({tensorB});
mgr.evalOpDefault<kp::OpTensorCreate>({tensorA});
mgr.evalOpDefault<kp::OpTensorCreate>({tensorB});
EXPECT_TRUE(tensorA->isInit());
EXPECT_TRUE(tensorB->isInit());

2
test/TestTensor.cpp
View file

@ -28,7 +28,7 @@ TEST(TestTensor, CopyFromHostData) {
{
sq->begin();
sq->record<kp::OpCreateTensor>({tensorA, tensorB});
sq->record<kp::OpTensorCreate>({tensorA, tensorB});
sq->record<kp::OpTensorCopy>({tensorA, tensorB});