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

Simplified specialization constants by limiting to floats2

Browse source
This commit is contained in:
Alejandro Saucedo 2021-02-14 06:55:09 +00:00
parent 7126cc47ff
commit a7801cedd0
5 changed files with 358 additions and 470 deletions
Download patch file Download diff file Expand all files Collapse all files

112
src/include/kompute/Algorithm.hpp
View file

@ -12,114 +12,6 @@ namespace kp {
*/
class Algorithm
{
public:
// TODO: Move as internal struct of speccontainer
class SpecializationConstant {
public:
SpecializationConstant(const SpecializationConstant& specializationConstant) {
SPDLOG_DEBUG("Kompute SpecializationConstant copy constructor: {}", *((uint32_t*)specializationConstant.mInstanceData));
this->mInstanceData = (char*)malloc(sizeof(uint32_t));
memcpy(this->mInstanceData, specializationConstant.mInstanceData, sizeof(uint32_t));
}
// This class is required in absence of std::variant to ensure C++11 support
SpecializationConstant(uint32_t val) {
SPDLOG_DEBUG("Kompute SpecializationConstant uint32_t constructor: {}", val);
this->mInstanceData = (char*)malloc(sizeof(uint32_t));
memcpy(this->mInstanceData, &val, sizeof(uint32_t));
}
SpecializationConstant(float val) {
SPDLOG_DEBUG("Kompute SpecializationConstant float constructor: {}", val);
this->mInstanceData = (char*)malloc(sizeof(uint32_t));
memcpy(this->mInstanceData, &val, sizeof(uint32_t));
}
~SpecializationConstant() {
free(this->mInstanceData);
}
void *data() {
return this->mInstanceData;
}
private:
// We use char pointer to enable for pointer arithmetic
char *mInstanceData = nullptr;
};
class SpecializationContainer {
public:
SpecializationContainer() {
SPDLOG_DEBUG("Kompute SpecializationContainer default initialiser");
this->mFreeData = false;
}
SpecializationContainer(const SpecializationContainer& specializationContainer)
{
SPDLOG_DEBUG("Kompute SpecializationContainer copy constructor, size: {}", specializationContainer.mSpecializationConstants.size());
SpecializationContainer(specializationContainer.mSpecializationConstants);
}
SpecializationContainer(std::vector<SpecializationConstant> instances) {
SPDLOG_DEBUG("Kompute SpecializationContainer initialiser with instances size {}", instances.size());
static_assert(sizeof(uint32_t) == sizeof(float) && sizeof(uint32_t) == sizeof(char) * 4,
"Kompute requires uint32_t and float to be of same size. Please report this to github.");
// totalMemorySize depends on instances being set so this needs to be set before
this->mSpecializationConstants = instances;
// Data has then to be allocated in order to copy memory into it
this->mData = (char*)malloc(this->totalMemorySize());
this->mFreeData = true;
for (size_t i = 0; i < this->size(); i++) {
memcpy(this->mData + (i * sizeof(uint32_t)), instances[i].data(), sizeof(uint32_t));
}
}
~SpecializationContainer() {
SPDLOG_DEBUG("Kompute SpecializationContainer destructor started");
this->mSpecializationConstants.clear();
if (this->mFreeData) {
SPDLOG_DEBUG("Kompute SpecializationContainer freeing data");
this->mFreeData = false;
free(this->mData);
} else {
SPDLOG_DEBUG("Kompute SpecializationContainer no data was freed");
}
SPDLOG_DEBUG("kompute SpecializationContainer freed data");
}
void *transferDataOwnership() {
SPDLOG_DEBUG("Kompute SpecializationContainer data transfer ownership requested");
this->mFreeData = false;
return (void*)this->mData;
}
uint32_t size() {
return this->mSpecializationConstants.size();
}
uint32_t totalMemorySize() {
return this->instanceMemorySize() * this->size();
}
uint32_t instanceMemorySize() {
// At this point only variables accepted are uint32_t and float which are same size
return sizeof(uint32_t);
}
private:
std::vector<SpecializationConstant> mSpecializationConstants;
bool mFreeData = false;
// We use char pointer to enable for pointer arithmetic
char *mData = nullptr;
};
private:
// Private struct template which is then
public:
/**
Base constructor for Algorithm. Should not be used unless explicit
@ -136,7 +28,7 @@ public:
*/
Algorithm(std::shared_ptr<vk::Device> device,
std::shared_ptr<vk::CommandBuffer> commandBuffer,
const SpecializationContainer& specializationConstants = {});
const std::vector<float>& specializationConstants = {});
/**
* Initialiser for the shader data provided to the algorithm as well as
@ -188,7 +80,7 @@ private:
bool mFreePipeline = false;
// -------------- ALWAYS OWNED RESOURCES
SpecializationContainer mSpecializationConstants;
std::vector<float> mSpecializationConstants;
// Create util functions
void createShaderModule(const std::vector<char>& shaderFileData);