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

Added base tests for end to end manager functionality

Browse source
This commit is contained in:
Alejandro Saucedo 2020-08-26 18:53:50 +01:00
parent 1748694b3a
commit 39b051160a
7 changed files with 199 additions and 181 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Makefile
View file

@ -1,7 +1,7 @@
####### SRC Build Params #######
CC="/c/Program Files (x86)/Microsoft Visual Studio/2019/Community/MSBuild/Current/Bin/MSBuildTaskHost.exe"
CC="/c/Program Files (x86)/Microsoft Visual Studio/2019/Community/MSBuild/Current/Bin/MSBuild.exe"
####### Shader Build Params #######
@ -25,6 +25,12 @@ run_cmake:
-DCMAKE_EXPORT_COMPILE_COMMANDS=1 \
-G "Visual Studio 16 2019"
build_vs:
$(CC) build/kompute.sln
run_tests:
./build/test/Debug/test_kompute.exe
clean_cmake:
rm -rf build/

95
single_include/kompute/Kompute.hpp
View file

@ -299,10 +299,12 @@ class Sequence
std::unique_ptr<OpBase> baseOpPtr{ baseOp };
SPDLOG_DEBUG("Kompute Sequence running init on OpBase derived class instance");
SPDLOG_DEBUG(
"Kompute Sequence running init on OpBase derived class instance");
baseOpPtr->init(tensors);
SPDLOG_DEBUG("Kompute Sequence running record on OpBase derived class instance");
SPDLOG_DEBUG(
"Kompute Sequence running record on OpBase derived class instance");
baseOpPtr->record();
mOperations.push_back(std::move(baseOpPtr));
@ -345,7 +347,7 @@ class Manager
~Manager();
Sequence constructSequence();
std::weak_ptr<Sequence> managedSequence();
template<typename T, typename... TArgs>
void evalOp(std::vector<std::shared_ptr<Tensor>> tensors)
@ -376,6 +378,9 @@ class Manager
uint32_t mComputeQueueFamilyIndex = -1;
std::shared_ptr<vk::Queue> mComputeQueue = nullptr;
// Always owned resources
std::vector<std::shared_ptr<Sequence>> mManagedSequences;
#if DEBUG
vk::DebugReportCallbackEXT mDebugReportCallback;
vk::DispatchLoaderDynamic mDebugDispatcher;
@ -438,7 +443,6 @@ class Algorithm
// Parameters
void createParameters(std::vector<std::shared_ptr<Tensor>>& tensorParams);
void createDescriptorPool();
};
} // End namespace kp
@ -498,8 +502,8 @@ OpMult<tX, tY, tZ>::OpMult()
// TODO: Remove physicalDevice from main initialiser
template<uint32_t tX, uint32_t tY, uint32_t tZ>
OpMult<tX, tY, tZ>::OpMult(std::shared_ptr<vk::PhysicalDevice> physicalDevice,
std::shared_ptr<vk::Device> device,
std::shared_ptr<vk::CommandBuffer> commandBuffer)
std::shared_ptr<vk::Device> device,
std::shared_ptr<vk::CommandBuffer> commandBuffer)
: OpBase(physicalDevice, device, commandBuffer)
{
SPDLOG_DEBUG("Kompute OpMult constructor with params");
@ -511,7 +515,6 @@ template<uint32_t tX, uint32_t tY, uint32_t tZ>
OpMult<tX, tY, tZ>::~OpMult()
{
SPDLOG_DEBUG("Kompute OpMult destructor started");
}
template<uint32_t tX, uint32_t tY, uint32_t tZ>
@ -531,20 +534,24 @@ OpMult<tX, tY, tZ>::init(std::vector<std::shared_ptr<Tensor>> tensors)
this->mTensorRHS = tensors[1];
this->mTensorOutput = tensors[2];
// The dispatch size is set up based on either explicitly provided template parameters or by default it would take the shape and size of the tensors
// The dispatch size is set up based on either explicitly provided template
// parameters or by default it would take the shape and size of the tensors
if (tX > 0) {
// If at least the x value is provided we use mainly the parameters provided
// If at least the x value is provided we use mainly the parameters
// provided
this->mX = tX;
this->mY = tY > 0 ? tY : 1;
this->mZ = tZ > 0 ? tZ : 1;
}
else {
} else {
// TODO: Fully support the full size dispatch using size for the shape
this->mX = this->mTensorLHS->size();
this->mY = 1;
this->mZ = 1;
}
spdlog::info("Kompute OpMult dispatch size X: {}, Y: {}, Z: {}", this->mX, this->mY, this->mZ);
spdlog::info("Kompute OpMult dispatch size X: {}, Y: {}, Z: {}",
this->mX,
this->mY,
this->mZ);
// TODO: Explore adding a validate function
if (!(this->mTensorLHS->isInit() && this->mTensorRHS->isInit() &&
@ -570,16 +577,17 @@ OpMult<tX, tY, tZ>::init(std::vector<std::shared_ptr<Tensor>> tensors)
this->mTensorOutputStaging = std::make_shared<Tensor>(
this->mTensorOutput->data(), Tensor::TensorTypes::eStaging);
this->mTensorOutputStaging->init(this->mPhysicalDevice,
this->mDevice,
this->mCommandBuffer);
this->mTensorOutputStaging->init(
this->mPhysicalDevice, this->mDevice, this->mCommandBuffer);
#if RELEASE
std::vector<char> shaderFileData(
shader_data::shaders_glsl_opmult_comp_spv,
shader_data::shaders_glsl_opmult_comp_spv + kp::shader_data::shaders_glsl_opmult_comp_spv_len);
shader_data::shaders_glsl_opmult_comp_spv,
shader_data::shaders_glsl_opmult_comp_spv +
kp::shader_data::shaders_glsl_opmult_comp_spv_len);
#else
SPDLOG_DEBUG("Kompute OpMult Running debug loading shaders directly from spirv file");
SPDLOG_DEBUG(
"Kompute OpMult Running debug loading shaders directly from spirv file");
// TODO: Move to utility function
std::string shaderFilePath = "shaders/glsl/opmult.comp.spv";
@ -592,7 +600,8 @@ OpMult<tX, tY, tZ>::init(std::vector<std::shared_ptr<Tensor>> tensors)
fileStream.read(shaderDataRaw, shaderFileSize);
fileStream.close();
std::vector<char> shaderFileData(shaderDataRaw, shaderDataRaw + shaderFileSize);
std::vector<char> shaderFileData(shaderDataRaw,
shaderDataRaw + shaderFileSize);
#endif
SPDLOG_DEBUG("Kompute OpMult Initialising algorithm component");
@ -608,43 +617,43 @@ OpMult<tX, tY, tZ>::record()
// Barrier to ensure the data is finished writing to buffer memory
this->mTensorLHS->recordBufferMemoryBarrier(
vk::AccessFlagBits::eHostWrite,
vk::AccessFlagBits::eShaderRead,
vk::PipelineStageFlagBits::eHost,
vk::PipelineStageFlagBits::eComputeShader);
vk::AccessFlagBits::eHostWrite,
vk::AccessFlagBits::eShaderRead,
vk::PipelineStageFlagBits::eHost,
vk::PipelineStageFlagBits::eComputeShader);
this->mTensorRHS->recordBufferMemoryBarrier(
vk::AccessFlagBits::eHostWrite,
vk::AccessFlagBits::eShaderRead,
vk::PipelineStageFlagBits::eHost,
vk::PipelineStageFlagBits::eComputeShader);
vk::AccessFlagBits::eHostWrite,
vk::AccessFlagBits::eShaderRead,
vk::PipelineStageFlagBits::eHost,
vk::PipelineStageFlagBits::eComputeShader);
this->mAlgorithm->recordDispatch(this->mX, this->mY, this->mZ);
// Barrier to ensure the shader code is executed before buffer read
this->mTensorLHS->recordBufferMemoryBarrier(
vk::AccessFlagBits::eShaderWrite,
vk::AccessFlagBits::eTransferRead,
vk::PipelineStageFlagBits::eComputeShader,
vk::PipelineStageFlagBits::eTransfer);
vk::AccessFlagBits::eShaderWrite,
vk::AccessFlagBits::eTransferRead,
vk::PipelineStageFlagBits::eComputeShader,
vk::PipelineStageFlagBits::eTransfer);
this->mTensorOutput->recordBufferMemoryBarrier(
vk::AccessFlagBits::eShaderWrite,
vk::AccessFlagBits::eTransferRead,
vk::PipelineStageFlagBits::eComputeShader,
vk::PipelineStageFlagBits::eTransfer);
vk::AccessFlagBits::eShaderWrite,
vk::AccessFlagBits::eTransferRead,
vk::PipelineStageFlagBits::eComputeShader,
vk::PipelineStageFlagBits::eTransfer);
this->mTensorOutputStaging->recordCopyFrom(this->mTensorOutput);
// Buffer to ensure wait until data is copied to staging buffer
this->mTensorLHS->recordBufferMemoryBarrier(
vk::AccessFlagBits::eTransferWrite,
vk::AccessFlagBits::eHostRead,
vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eHost);
vk::AccessFlagBits::eTransferWrite,
vk::AccessFlagBits::eHostRead,
vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eHost);
this->mTensorOutput->recordBufferMemoryBarrier(
vk::AccessFlagBits::eTransferWrite,
vk::AccessFlagBits::eHostRead,
vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eHost);
vk::AccessFlagBits::eTransferWrite,
vk::AccessFlagBits::eHostRead,
vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eHost);
}
template<uint32_t tX, uint32_t tY, uint32_t tZ>

6
test/CMakeLists.txt
View file

@ -1,7 +1,11 @@
find_package(Catch2 REQUIRED)
add_executable(test_kompute Main.cpp)
file(GLOB test_kompute_CPP
"${CMAKE_CURRENT_SOURCE_DIR}/*.cpp"
)
add_executable(test_kompute ${test_kompute_CPP})
target_include_directories(
test_kompute PUBLIC

114
test/Main.cpp
View file

@ -1,114 +0,0 @@
#if defined(_WIN32)
#pragma comment(linker, "/subsystem:console")
#endif
// SPDLOG_ACTIVE_LEVEL must be defined before spdlog.h import
#if DEBUG
#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
#endif
#include <vector>
#include <spdlog/spdlog.h>
// ranges.h must come after spdlog.h
#include <fmt/ranges.h>
#include <vulkan/vulkan.h>
#include <vulkan/vulkan.hpp>
#include "kompute/Kompute.hpp"
int
main()
{
#if DEBUG
spdlog::set_level(spdlog::level::debug);
#else
spdlog::set_level(spdlog::level::info);
#endif
try {
// Run Kompute
{
spdlog::info("Creating manager");
kp::Manager mgr;
spdlog::info("Creating first tensor");
std::shared_ptr<kp::Tensor> tensorLHS{ new kp::Tensor( { 0, 1, 2 }) };
mgr.evalOp<kp::OpCreateTensor>({ tensorLHS });
spdlog::info("Creating second tensor");
std::shared_ptr<kp::Tensor> tensorRHS{ new kp::Tensor(
{ 2, 4, 6 }) };
mgr.evalOp<kp::OpCreateTensor>({ tensorRHS });
// TODO: Add capabilities for just output tensor types
spdlog::info("Creating output tensor");
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor(
{ 0, 0, 0 }) };
mgr.evalOp<kp::OpCreateTensor>({ tensorOutput });
spdlog::info("OpCreateTensor success for tensors");
spdlog::info("Tensor one: {}", tensorLHS->data());
spdlog::info("Tensor two: {}", tensorRHS->data());
spdlog::info("Tensor output: {}", tensorOutput->data());
spdlog::info("Calling op mult");
mgr.evalOp<kp::OpMult<>>({ tensorLHS, tensorRHS, tensorOutput });
spdlog::info("OpMult call success");
spdlog::info("Tensor output: {}", tensorOutput->data());
spdlog::info("Called manager eval success END PROGRAM");
}
{
spdlog::info("Creating manager");
kp::Manager mgr;
kp::Sequence sq = mgr.constructSequence();
sq.begin();
spdlog::info("Creating first tensor");
std::shared_ptr<kp::Tensor> tensorLHS{ new kp::Tensor(
{ 0, 1, 2 }) };
spdlog::info("Creating second tensor");
std::shared_ptr<kp::Tensor> tensorRHS{ new kp::Tensor(
{ 2, 4, 6 }) };
// TODO: Add capabilities for just output tensor types
spdlog::info("Creating output tensor");
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor(
{ 0, 0, 0 }) };
sq.record<kp::OpCreateTensor>({ tensorLHS });
sq.record<kp::OpCreateTensor>({ tensorRHS });
sq.record<kp::OpCreateTensor>({ tensorOutput });
spdlog::info("OpCreateTensor success for tensors");
spdlog::info("Tensor one: {}", tensorLHS->data());
spdlog::info("Tensor two: {}", tensorRHS->data());
spdlog::info("Tensor output: {}", tensorOutput->data());
spdlog::info("Calling op mult");
sq.record<kp::OpMult<>>({ tensorLHS, tensorRHS, tensorOutput });
sq.end();
sq.eval();
spdlog::info("OpMult call success");
spdlog::info("Tensor output: {}", tensorOutput->data());
spdlog::info("Called manager eval success END PROGRAM");
}
return 0;
} catch (const std::exception& exc) {
spdlog::error("Exception caught: {}", exc.what());
return 1;
} catch (...) {
spdlog::error("Uncaught exception");
return 1;
}
}

26
test/TestMain.cpp
View file

@ -1,4 +1,28 @@
#define CATCH_CONFIG_MAIN
#define CATCH_CONFIG_RUNNER
// clang-format: SPDLOG_ACTIVE_LEVEL must be defined before spdlog.h import
#if DEBUG
#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
#endif
#include <spdlog/spdlog.h>
// clang-format: ranges.h must come after spdlog.h
#include <fmt/ranges.h>
#include "catch2/catch.hpp"
int main( int argc, char* argv[] ) {
#if DEBUG
spdlog::set_level(spdlog::level::debug);
#else
spdlog::set_level(spdlog::level::info);
#endif
int result = Catch::Session().run( argc, argv );
// global clean-up...
return result;
}

104
test/TestManager.cpp Executable file
View file

@ -0,0 +1,104 @@
#if defined(_WIN32)
#pragma comment(linker, "/subsystem:console")
#endif
// clang-format: SPDLOG_ACTIVE_LEVEL must be defined before spdlog.h import
#if DEBUG
#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
#endif
#include <vector>
#include <spdlog/spdlog.h>
// clang-format: ranges.h must come after spdlog.h
#include <fmt/ranges.h>
#include "catch2/catch.hpp"
#include "kompute/Kompute.hpp"
TEST_CASE("End to end OpMult Flow should execute correctly from manager") {
spdlog::info("TEST CASE STARTING");
spdlog::info("Creating manager");
kp::Manager mgr;
spdlog::info("Creating first tensor");
std::shared_ptr<kp::Tensor> tensorLHS{ new kp::Tensor( { 0, 1, 2 }) };
mgr.evalOp<kp::OpCreateTensor>({ tensorLHS });
spdlog::info("Creating second tensor");
std::shared_ptr<kp::Tensor> tensorRHS{ new kp::Tensor(
{ 2, 4, 6 }) };
mgr.evalOp<kp::OpCreateTensor>({ tensorRHS });
// TODO: Add capabilities for just output tensor types
spdlog::info("Creating output tensor");
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor(
{ 0, 0, 0 }) };
mgr.evalOp<kp::OpCreateTensor>({ tensorOutput });
spdlog::info("OpCreateTensor success for tensors");
spdlog::info("Tensor one: {}", tensorLHS->data());
spdlog::info("Tensor two: {}", tensorRHS->data());
spdlog::info("Tensor output: {}", tensorOutput->data());
spdlog::info("Calling op mult");
mgr.evalOp<kp::OpMult<>>({ tensorLHS, tensorRHS, tensorOutput });
spdlog::info("OpMult call success");
spdlog::info("Tensor output: {}", tensorOutput->data());
REQUIRE(tensorOutput->data() == std::vector<uint32_t>{0, 4, 12});
spdlog::info("Called manager eval success END PROGRAM");
}
TEST_CASE("End to end OpMult Flow should execute correctly from sequence") {
spdlog::info("TEST CASE STARTING");
spdlog::info("Creating manager");
spdlog::info("Creating first tensor");
std::shared_ptr<kp::Tensor> tensorLHS{ new kp::Tensor(
{ 0, 1, 2 }) };
spdlog::info("Creating second tensor");
std::shared_ptr<kp::Tensor> tensorRHS{ new kp::Tensor(
{ 2, 4, 6 }) };
// TODO: Add capabilities for just output tensor types
spdlog::info("Creating output tensor");
std::shared_ptr<kp::Tensor> tensorOutput{ new kp::Tensor(
{ 0, 0, 0 }) };
kp::Manager mgr;
std::weak_ptr<kp::Sequence> sq_ref = mgr.managedSequence();
if (std::shared_ptr<kp::Sequence> sq = sq_ref.lock()) {
sq->begin();
sq->record<kp::OpCreateTensor>({ tensorLHS });
sq->record<kp::OpCreateTensor>({ tensorRHS });
sq->record<kp::OpCreateTensor>({ tensorOutput });
spdlog::info("OpCreateTensor success for tensors");
spdlog::info("Tensor one: {}", tensorLHS->data());
spdlog::info("Tensor two: {}", tensorRHS->data());
spdlog::info("Tensor output: {}", tensorOutput->data());
spdlog::info("Calling op mult");
sq->record<kp::OpMult<>>({ tensorLHS, tensorRHS, tensorOutput });
sq->end();
sq->eval();
}
sq_ref.reset();
spdlog::info("OpMult call success");
spdlog::info("Tensor output: {}", tensorOutput->data());
REQUIRE(tensorOutput->data() == std::vector<uint32_t>{0, 4, 12});
spdlog::info("Called manager eval success END PROGRAM");
}

27
test/TestTensor.cpp
View file

@ -1,25 +1,10 @@
#include <catch2/catch.hpp>
#include "Tensor.hpp"
#include "kompute/Tensor.hpp"
int Factorial( int number ) {
return number <= 1 ? number : Factorial( number - 1 ) * number; // fail
// return number <= 1 ? 1 : Factorial( number - 1 ) * number; // pass
}
TEST_CASE( "Factorial of 0 is 1 (fail)", "[single-file]" ) {
REQUIRE( Factorial(0) == 1 );
}
TEST_CASE( "Factorials of 1 and higher are computed (pass)", "[single-file]" ) {
REQUIRE( Factorial(1) == 1 );
REQUIRE( Factorial(2) == 2 );
REQUIRE( Factorial(3) == 6 );
REQUIRE( Factorial(10) == 3628800 );
}
TEST_CASE("Exploring if manager test compiles") {
kp::Tensor tensor({0,1,2});
REQUIRE( tensor.size() == 3 );
TEST_CASE("Tensor should have same vector as initialised") {
std::vector<uint32_t> vec{0,1,2};
kp::Tensor tensor(vec);
REQUIRE( tensor.data() == vec );
}