void sqlite_statement::prepare(const sql &s)
{
reset();
str(s.prepare());
// destroy statement
clear();
// prepare sqlite statement
int ret = sqlite3_prepare_v2(db_(), str().c_str(), str().size(), &stmt_, 0);
throw_error(ret, db_(), "sqlite3_prepare_v2", str());
}
void sqlite_statement::clear()
{
if (!stmt_) {
return;
}
// std::cout << "finalizing statement 0x" << std::hex << stmt_ << "\n";
int ret = sqlite3_finalize(stmt_);
throw_error(ret, db_(), "sqlite3_finalize");
stmt_ = 0;
return;
}
void Routine::InitProgram(std::initializer_list<const char *> source) {
// Determines the identifier for this particular routine call
auto routine_info = routine_name_;
for (const auto &kernel_name : kernel_names_) {
routine_info += "_" + kernel_name + db_(kernel_name).GetValuesString();
}
log_debug(routine_info);
// Queries the cache to see whether or not the program (context-specific) is already there
bool has_program;
program_ = ProgramCache::Instance().Get(ProgramKeyRef{ context_(), device_(), precision_, routine_info },
&has_program);
if (has_program) { return; }
// Sets the build options from an environmental variable (if set)
auto options = std::vector<std::string>();
const auto environment_variable = std::getenv("CLBLAST_BUILD_OPTIONS");
if (environment_variable != nullptr) {
options.push_back(std::string(environment_variable));
}
// Queries the cache to see whether or not the binary (device-specific) is already there. If it
// is, a program is created and stored in the cache
const auto device_name = GetDeviceName(device_);
const auto platform_id = device_.PlatformID();
bool has_binary;
auto binary = BinaryCache::Instance().Get(BinaryKeyRef{platform_id, precision_, routine_info, device_name },
&has_binary);
if (has_binary) {
program_ = std::make_shared<Program>(device_, context_, binary);
program_->Build(device_, options);
ProgramCache::Instance().Store(ProgramKey{ context_(), device_(), precision_, routine_info },
std::shared_ptr<Program>{program_});
return;
}
// Otherwise, the kernel will be compiled and program will be built. Both the binary and the
// program will be added to the cache.
// Inspects whether or not FP64 is supported in case of double precision
if ((precision_ == Precision::kDouble && !PrecisionSupported<double>(device_)) ||
(precision_ == Precision::kComplexDouble && !PrecisionSupported<double2>(device_))) {
throw RuntimeErrorCode(StatusCode::kNoDoublePrecision);
}
// As above, but for FP16 (half precision)
if (precision_ == Precision::kHalf && !PrecisionSupported<half>(device_)) {
throw RuntimeErrorCode(StatusCode::kNoHalfPrecision);
}
// Collects the parameters for this device in the form of defines
auto source_string = std::string{""};
for (const auto &kernel_name : kernel_names_) {
source_string += db_(kernel_name).GetDefines();
}
// Adds routine-specific code to the constructed source string
for (const char *s: source) {
source_string += s;
}
// Completes the source and compiles the kernel
program_ = CompileFromSource(source_string, precision_, routine_name_,
device_, context_, options, 0);
// Store the compiled binary and program in the cache
BinaryCache::Instance().Store(BinaryKey{platform_id, precision_, routine_info, device_name},
program_->GetIR());
ProgramCache::Instance().Store(ProgramKey{context_(), device_(), precision_, routine_info},
std::shared_ptr<Program>{program_});
}
void sqlite_statement::write(const char *, const object_base_ptr &x)
{
int ret = sqlite3_bind_int(stmt_, ++host_index, x.id());
throw_error(ret, db_(), "sqlite3_bind_int");
}
void sqlite_statement::write(const char*, const varchar_base &x)
{
int ret = sqlite3_bind_text(stmt_, ++host_index, x.c_str(), x.size(), 0);
throw_error(ret, db_(), "sqlite3_bind_text");
}
void sqlite_statement::write(const char*, const char *x, int len)
{
int ret = sqlite3_bind_text(stmt_, ++host_index, x, len, 0);
throw_error(ret, db_(), "sqlite3_bind_text");
}
void sqlite_statement::write(const char*, double x)
{
int ret = sqlite3_bind_double(stmt_, ++host_index, x);
throw_error(ret, db_(), "sqlite3_bind_double");
}
void sqlite_statement::write(const char*, unsigned long x)
{
int ret = sqlite3_bind_int(stmt_, ++host_index, x);
throw_error(ret, db_(), "sqlite3_bind_int");
}
