MirrorHub/construct
0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-11-18 07:50:57 +01:00
Code Issues Releases Wiki Activity
construct/ircd/cl.cc

3039 lines
60 KiB
C++
Raw Blame History

// The Construct
//
// Copyright (C) Matrix Construct Developers, Authors & Contributors
// Copyright (C) 2016-2021 Jason Volk <jason@zemos.net>
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice is present in all copies. The
// full license for this software is available in the LICENSE file.
#include <dlfcn.h>
#include <CL/cl.h>
#include <CL/cl_ext.h>
// Util
namespace ircd::cl
{
static bool is_error(const int &code) noexcept;
static int throw_on_error(const int &code);
template<int maybe = CL_SUCCESS, class func, class... args> static int call(func&&, args&&...);
template<class T = string_view, int maybe = CL_SUCCESS, class F, class id, class param> static T info(F&&, const id &, const param &, const mutable_buffer &, T default_ = {});
template<class T = string_view, int maybe = CL_SUCCESS, class F, class id0, class id1, class param> static T info(F&&, const id0 &, const id1 &, const param &, const mutable_buffer &, T default_ = {});
static string_view version_str(const mutable_buffer &, const cl_version);
static uint query_warp_size_amd(cl_device_id);
static uint query_warp_size(cl_context, cl_device_id);
}
// Runtime state
namespace ircd::cl
{
static const size_t
OPTION_MAX {8},
PLATFORM_MAX {8},
DEVICE_MAX {8};
static uint
options,
platforms,
devices[PLATFORM_MAX];
static char
option[OPTION_MAX][256];
static void
*linkage;
static cl_platform_id
platform[PLATFORM_MAX];
static cl_device_id
device[PLATFORM_MAX][DEVICE_MAX];
static struct version
{
int major, minor;
}
api[PLATFORM_MAX][DEVICE_MAX];
static uint
warp_size[PLATFORM_MAX][DEVICE_MAX];
static cl_context
primary;
extern struct stats
primary_stats;
static cl_command_queue
queue[PLATFORM_MAX][DEVICE_MAX];
static void handle_notify(const char *, const void *, size_t, void *) noexcept;
}
struct ircd::cl::stats
{
template<class T>
using item = ircd::stats::item<T>;
item<uint64_t>
sync_count,
flush_count,
alloc_count,
alloc_bytes,
dealloc_count,
dealloc_bytes,
work_waits,
work_waits_async,
work_errors,
work_completes,
exec_tasks,
exec_kern_tasks,
exec_kern_threads,
exec_kern_groups,
exec_write_tasks,
exec_write_bytes,
exec_read_tasks,
exec_read_bytes,
exec_copy_tasks,
exec_copy_bytes,
exec_barrier_tasks;
};
decltype(ircd::cl::log)
ircd::cl::log
{
"cl"
};
decltype(ircd::cl::version_api)
ircd::cl::version_api
{
"OpenCL", info::versions::API, CL_TARGET_OPENCL_VERSION,
{
#if defined(CL_VERSION_MAJOR) && defined(CL_VERSION_MINOR) && defined(CL_VERSION_PATCH)
CL_VERSION_MAJOR(CL_TARGET_OPENCL_VERSION),
CL_VERSION_MINOR(CL_TARGET_OPENCL_VERSION),
CL_VERSION_PATCH(CL_TARGET_OPENCL_VERSION),
#endif
}
};
decltype(ircd::cl::version_abi)
ircd::cl::version_abi
{
"OpenCL", info::versions::ABI
};
decltype(ircd::cl::enable)
ircd::cl::enable
{
{ "name", "ircd.cl.enable" },
{ "default", true },
{ "persist", false },
};
decltype(ircd::cl::profile_queue)
ircd::cl::profile_queue
{
{ "name", "ircd.cl.queue.profile" },
{ "default", false },
{ "persist", false },
};
decltype(ircd::cl::device_queue)
ircd::cl::device_queue
{
{ "name", "ircd.cl.queue.device" },
{ "default", true },
{ "persist", false },
};
decltype(ircd::cl::queue_size)
ircd::cl::queue_size
{
{ "name", "ircd.cl.queue.size" },
{ "default", long(1_MiB) },
{ "persist", false },
};
decltype(ircd::cl::intensity)
ircd::cl::intensity
{
{ "name", "ircd.cl.intensity" },
{ "default", 0L },
};
decltype(ircd::cl::watchdog_tsc)
ircd::cl::watchdog_tsc
{
{ "name", "ircd.cl.watchdog.tsc" },
{ "default", 268'435'456L },
};
decltype(ircd::cl::path)
ircd::cl::path
{
{ "name", "ircd.cl.path" },
{ "default", "libOpenCL.so" },
{ "persist", false },
};
decltype(ircd::cl::envs)
ircd::cl::envs
{
{
{ "name", "LP_NUM_THREADS" },
{ "default", "0" },
},
{
{ "name", "MESA_NO_MINMAX_CACHE" },
{ "default", "true" },
},
{
{ "name", "MESA_GLSL_CACHE_DISABLE" },
{ "default", "true" },
},
{
{ "name", "AMD_DEBUG" },
{ "default", "nogfx,reserve_vmid" },
},
{
{ "name", "R600_DEBUG" },
{ "default", "forcedma" },
},
{
{ "name", "RADEON_THREAD" },
{ "default", "false" },
},
};
decltype(ircd::cl::primary_stats)
ircd::cl::primary_stats
{
{ { "name", "ircd.cl.sync.count" } },
{ { "name", "ircd.cl.flush.count" } },
{ { "name", "ircd.cl.alloc.count" } },
{ { "name", "ircd.cl.alloc.bytes" } },
{ { "name", "ircd.cl.dealloc.count" } },
{ { "name", "ircd.cl.dealloc.bytes" } },
{ { "name", "ircd.cl.work.waits" } },
{ { "name", "ircd.cl.work.waits.async" } },
{ { "name", "ircd.cl.work.errors" } },
{ { "name", "ircd.cl.work.completes" } },
{ { "name", "ircd.cl.exec.tasks" } },
{ { "name", "ircd.cl.exec.kern.tasks" } },
{ { "name", "ircd.cl.exec.kern.threads" } },
{ { "name", "ircd.cl.exec.kern.groups" } },
{ { "name", "ircd.cl.exec.write.tasks" } },
{ { "name", "ircd.cl.exec.write.bytes" } },
{ { "name", "ircd.cl.exec.read.tasks" } },
{ { "name", "ircd.cl.exec.read.bytes" } },
{ { "name", "ircd.cl.exec.copy.tasks" } },
{ { "name", "ircd.cl.exec.copy.bytes" } },
{ { "name", "ircd.cl.exec.barrier.tasks" } },
};
//
// init
//
ircd::cl::init::init()
{
if(!enable)
{
log::dwarning
{
log, "OpenCL hardware acceleration is not available or enabled."
};
return;
}
const ctx::posix::enable_pthread enable_pthread;
// Link the libraries.
if(!init_libs())
{
log::warning
{
log, "OpenCL hardware acceleration runtime failed to link."
};
return;
}
// Get the platforms.
if(!init_platforms())
{
log::warning
{
log, "OpenCL hardware acceleration platform not found."
};
return;
}
// Report the platforms.
log_platform_info();
// Get the devices.
if(!init_devices())
{
log::warning
{
log, "OpenCL hardware acceleration device not found."
};
return;
}
// Various other inits.
init_ctxs();
// Report the devices.
log_dev_info();
}
[[gnu::cold]]
ircd::cl::init::~init()
noexcept
{
if(!linkage)
return;
log::debug
{
log, "Shutting down OpenCL...",
};
const ctx::posix::enable_pthread enable_pthread;
fini_ctxs();
fini_libs();
}
bool
ircd::cl::init::init_libs()
{
const string_view path
{
cl::path
};
if(path.empty())
return false;
// Setup options
for(const auto &item : envs)
{
assert(options < OPTION_MAX);
fmt::sprintf
{
option[options], "%s=%s",
item.name,
string_view{item},
};
sys::call(putenv, option[options++]);
}
// Load the pipe.
assert(!linkage);
if(!(linkage = dlopen(path.c_str(), RTLD_NOW | RTLD_GLOBAL)))
return false;
return true;
}
void
ircd::cl::init::fini_libs()
{
if(likely(linkage))
dlclose(linkage);
}
size_t
ircd::cl::init::init_platforms()
{
// OpenCL sez platform=null is implementation defined.
constexpr auto ignore(CL_INVALID_PLATFORM);
info<string_view, ignore>(clGetPlatformInfo, nullptr, CL_PLATFORM_VERSION, version_abi.string);
// Get the platforms.
call(clGetPlatformIDs, PLATFORM_MAX, platform, &platforms);
return platforms;
}
size_t
ircd::cl::init::init_devices()
{
// Get the devices.
size_t devices_total(0);
for(size_t i(0); i < platforms; ++i)
{
static const auto type
{
CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR
};
// OpenCL sez 0 devices throws an error but we log a warning for now.
constexpr auto ignore(CL_DEVICE_NOT_FOUND);
call<ignore>(clGetDeviceIDs, platform[i], type, DEVICE_MAX, device[i], devices + i);
devices_total += devices[i];
}
// Gather the API versions for the devices.
for(size_t i(0); i < platforms; ++i)
for(size_t j(0); j < devices[i]; ++j) try
{
// OpenCL sez:
// OpenCL<space><major_version.minor_version><space><vendor-specific information>
string_view ver; char buf[256];
ver = info(clGetDeviceInfo, device[i][j], CL_DEVICE_VERSION, buf);
ver = lstrip(ver, "OpenCL ");
ver = split(ver, ' ').first;
const auto &[major, minor]
{
split(ver, '.')
};
api[i][j].major = lex_cast<uint>(major);
api[i][j].minor = lex_cast<uint>(minor);
}
catch(const error &e)
{
log::error
{
log, "OpenCL [%u][%u] CL_DEVICE_VERSION :%s",
i, j,
e.what(),
};
}
return devices_total;
}
size_t
ircd::cl::init::init_ctxs()
{
// Gather all devices we'll use.
size_t _devs {0};
cl_device_id _dev[DEVICE_MAX];
for(size_t i(0); i < platforms; ++i)
for(size_t j(0); j < devices[i]; ++j)
_dev[_devs++] = device[i][j];
// Create a context from gathered devices.
cl_int err {CL_SUCCESS};
cl_context_properties ctxprop {0};
primary = clCreateContext(&ctxprop, _devs, _dev, handle_notify, nullptr, &err);
throw_on_error(err);
// Device queue enabler
bool dev_queue
{
true
&& cl::device_queue // If enabled by conf
&& !cl::profile_queue // And not profiling (for now)
};
// Device queue support
char tmp[4];
for(size_t i(0); i < _devs; ++i)
dev_queue &= info<uint>(clGetDeviceInfo, _dev[i], CL_DEVICE_MAX_ON_DEVICE_QUEUES, tmp);
// Queue out-of-order execution
bool dev_ooe
{
dev_queue // tied to dev_queue
};
// Queue size in bytes
uint dev_queue_size
{
uint(cl::queue_size)
};
// Queue size limited by devices
for(size_t i(0); i < _devs; ++i)
{
const auto max_queue_size
{
info<uint>(clGetDeviceInfo, _dev[i], CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE, tmp)
};
dev_queue_size = std::min(dev_queue_size, max_queue_size);
}
const uint prop[][2]
{
{ CL_QUEUE_SIZE, dev_queue_size },
{ CL_QUEUE_PROPERTIES, CL_QUEUE_ON_DEVICE & boolmask<uint>(dev_queue) },
{ CL_QUEUE_PROPERTIES, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE & boolmask<uint>(dev_ooe) },
{ CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE & boolmask<uint>(profile_queue) },
{ 0, 0 },
};
cl_queue_properties qprop[8] {0};
const auto qprops(sizeof(qprop) / sizeof(cl_queue_properties));
for(size_t i(0), j(0); j < qprops && (prop[i][0] || prop[i][1]); ++i)
if(prop[i][1])
{
qprop[j++] = prop[i][0];
qprop[j++] = prop[i][1];
}
// Create a queue for each device.
for(size_t i(0); i < platforms; ++i)
for(size_t j(0); j < devices[i]; ++j)
{
queue[i][j] = clCreateCommandQueueWithProperties(primary, device[i][j], qprop, &err);
throw_on_error(err);
}
// For any inits in the work subsystem.
work::init();
// Save the warp/wavefront size.
for(size_t i(0); i < platforms; ++i)
for(size_t j(0); j < devices[i]; ++j)
warp_size[i][j] = query_warp_size(primary, device[i][j]);
return _devs;
}
void
ircd::cl::init::fini_ctxs()
{
if(primary)
work::fini();
for(size_t i(0); i < PLATFORM_MAX; ++i)
for(size_t j(0); j < DEVICE_MAX; ++j)
if(queue[i][j])
{
call(clReleaseCommandQueue, queue[i][j]);
queue[i][j] = nullptr;
}
if(primary)
{
call(clReleaseContext, primary);
primary = nullptr;
}
}
void
ircd::cl::log_platform_info()
{
for(size_t i(0); i < platforms; ++i)
log_platform_info(i);
}
void
ircd::cl::log_platform_info(const uint i)
{
char buf[3][64];
char extbuf[320];
log::logf
{
log, log::level::DEBUG,
"OpenCL [%u][*] %-3d :%s :%s :%s :%s",
i,
CL_TARGET_OPENCL_VERSION,
info(clGetPlatformInfo, platform[i], CL_PLATFORM_VERSION, buf[0]),
info(clGetPlatformInfo, platform[i], CL_PLATFORM_VENDOR, buf[1]),
info(clGetPlatformInfo, platform[i], CL_PLATFORM_NAME, buf[2]),
info(clGetPlatformInfo, platform[i], CL_PLATFORM_EXTENSIONS, extbuf),
};
}
void
ircd::cl::log_dev_info()
{
for(size_t i(0); i < platforms; ++i)
log_dev_info(i);
}
void
ircd::cl::log_dev_info(const uint i)
{
if(unlikely(i >= PLATFORM_MAX))
throw std::out_of_range
{
"Invalid platform identifier."
};
for(size_t j(0); j < devices[i]; ++j)
log_dev_info(i, j);
}
void
ircd::cl::log_dev_info(const uint i,
const uint j)
{
if(unlikely(i >= PLATFORM_MAX || j >= DEVICE_MAX))
throw std::out_of_range
{
"Invalid platform or device identifier."
};
const auto &dev
{
device[i][j]
};
char buf[12][192];
char pbuf[8][64];
const auto type
{
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_TYPE, buf[0])
};
const auto type_str
{
type & CL_DEVICE_TYPE_CPU?
"CPU"_sv:
type & CL_DEVICE_TYPE_GPU?
"GPU"_sv:
type & CL_DEVICE_TYPE_ACCELERATOR?
"APU"_sv:
"DEV"_sv
};
const fmt::bsprintf<32> head
{
"%s id:%u:%u",
type_str,
i,
j,
};
constexpr auto ignore(CL_INVALID_VALUE);
const uint numeric_ver[]
{
info<uint, ignore>(clGetDeviceInfo, dev, CL_DEVICE_NUMERIC_VERSION, buf[0]),
info<uint, ignore>(clGetDeviceInfo, dev, CL_DEVICE_OPENCL_C_NUMERIC_VERSION_KHR, buf[1]),
};
log::info
{
log, "%s cl:%03u clc:%s dev:%s :%s :%s :%s :%s",
string_view{head},
CL_TARGET_OPENCL_VERSION,
version_str(buf[0], numeric_ver[0]),
version_str(buf[1], numeric_ver[1]),
info(clGetDeviceInfo, dev, CL_DEVICE_VERSION, buf[2]),
info(clGetDeviceInfo, dev, CL_DRIVER_VERSION, buf[3]),
info(clGetDeviceInfo, dev, CL_DEVICE_VENDOR, buf[4]),
info(clGetDeviceInfo, dev, CL_DEVICE_NAME, buf[5]),
};
const auto wid
{
info<std::array<size_t, 3>>(clGetDeviceInfo, dev, CL_DEVICE_MAX_WORK_ITEM_SIZES, buf[0])
};
log::info
{
log, "%s %u$mHz %u$x[simd%u] %u$x[%lu:%lu]%d %u$d[%u$x%u$x%u]",
string_view{head},
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_MAX_CLOCK_FREQUENCY, buf[0]),
info<uint, CL_INVALID_VALUE>(clGetDeviceInfo, dev, CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD, buf[1], 0U),
info<uint, CL_INVALID_VALUE>(clGetDeviceInfo, dev, CL_DEVICE_SIMD_WIDTH_AMD, buf[2], 0U),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_MAX_COMPUTE_UNITS, buf[3]),
warp_size[i][j],
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_MAX_WORK_GROUP_SIZE, buf[4]),
info<int>(clGetDeviceInfo, dev, CL_DEVICE_PARTITION_PROPERTIES, buf[5]),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, buf[6]),
wid[0], wid[1], wid[2],
};
log::info
{
log, "%s %u$bit-%s %s line %s align %s page %s param %s alloc %s",
string_view{head},
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_ADDRESS_BITS, buf[0]),
info<bool>(clGetDeviceInfo, dev, CL_DEVICE_ENDIAN_LITTLE, buf[1])?
"LE"_sv: "BE"_sv,
info<bool>(clGetDeviceInfo, dev, CL_DEVICE_ERROR_CORRECTION_SUPPORT, buf[2])?
"ECC"_sv: "non-ECC"_sv,
pretty(pbuf[0], iec(info<uint>(clGetDeviceInfo, dev, CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, buf[3]))),
pretty(pbuf[1], iec(info<uint>(clGetDeviceInfo, dev, CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, buf[4]))),
pretty(pbuf[2], iec(info<uint>(clGetDeviceInfo, dev, CL_DEVICE_MEM_BASE_ADDR_ALIGN, buf[5]))),
pretty(pbuf[3], iec(info<uint>(clGetDeviceInfo, dev, CL_DEVICE_MAX_PARAMETER_SIZE, buf[6]))),
pretty(pbuf[4], iec(info<ulong>(clGetDeviceInfo, dev, CL_DEVICE_MAX_MEM_ALLOC_SIZE, buf[7]))),
};
log::info
{
log, "%s global %s type:%02x cache %s chans %u banks %u width %u",
string_view{head},
pretty(pbuf[0], iec(info<ulong>(clGetDeviceInfo, dev, CL_DEVICE_GLOBAL_MEM_SIZE, buf[0]))),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, buf[1]),
pretty(pbuf[1], iec(info<ulong>(clGetDeviceInfo, dev, CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, buf[2]))),
info<uint, CL_INVALID_VALUE>(clGetDeviceInfo, dev, CL_DEVICE_GLOBAL_MEM_CHANNELS_AMD, buf[3], 0U),
info<uint, CL_INVALID_VALUE>(clGetDeviceInfo, dev, CL_DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD, buf[4], 0U),
info<uint, CL_INVALID_VALUE>(clGetDeviceInfo, dev, CL_DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD, buf[5], 0U),
};
log::info
{
log, "%s local %s type:%02x banks %u const %s consts %u",
string_view{head},
pretty(pbuf[0], iec(info<ulong>(clGetDeviceInfo, dev, CL_DEVICE_LOCAL_MEM_SIZE, buf[0]))),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_LOCAL_MEM_TYPE, buf[1]),
info<uint, CL_INVALID_VALUE>(clGetDeviceInfo, dev, CL_DEVICE_LOCAL_MEM_BANKS_AMD, buf[2], 0U),
pretty(pbuf[1], iec(info<ulong>(clGetDeviceInfo, dev, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, buf[3]))),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_MAX_CONSTANT_ARGS, buf[4]),
};
log::logf
{
log, log::level::DEBUG,
"%s char%u short%u half%u int%u float%u long%u double%u",
string_view{head},
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, buf[0]),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, buf[1]),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, buf[2]),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, buf[3]),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, buf[4]),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, buf[5]),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, buf[6]),
};
const bool native_kernel
(
CL_EXEC_NATIVE_KERNEL
& info<ulong>(clGetDeviceInfo, dev, CL_DEVICE_EXECUTION_CAPABILITIES, buf[0])
);
const auto il_version
(
native_kernel?
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_IL_VERSION, buf[1]): 0
);
log::logf
{
log, log::level::DEBUG,
"%s SPIR-V:%b:%u queues:%u events:%u pref:%u max:%u printf:%lu :%s",
string_view{head},
native_kernel,
il_version,
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_MAX_ON_DEVICE_QUEUES, buf[0]),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_MAX_ON_DEVICE_EVENTS, buf[1]),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_QUEUE_ON_DEVICE_PREFERRED_SIZE, buf[2]),
info<uint>(clGetDeviceInfo, dev, CL_DEVICE_QUEUE_ON_DEVICE_MAX_SIZE, buf[3]),
info<size_t>(clGetDeviceInfo, dev, CL_DEVICE_PRINTF_BUFFER_SIZE, buf[4]),
info(clGetDeviceInfo, dev, CL_DEVICE_OPENCL_C_VERSION, buf[5])
};
char extensions_buf[2048];
const string_view extensions
{
info(clGetDeviceInfo, dev, CL_DEVICE_EXTENSIONS, extensions_buf)
};
log::logf
{
log, log::level::DEBUG,
"%s :%s",
string_view{head},
extensions,
};
}
/// Silly quirks of OpenCL force us to setup a context, compile a program, and
/// instantiate a kernel to find out the warp/wavefront size characteristic.
/// Note that other thread-grouping characteristics are available from device
/// properties directly.
uint
ircd::cl::query_warp_size(cl_context context,
cl_device_id dev)
try
{
// Attempt to get this value the easy way from a device API.
uint ret(0);
if((ret = query_warp_size_amd(dev)))
return ret;
assert(primary);
assert(context == primary); //TODO: XXX
// Get this value the hard way from the cl_kernel API which requires
// building a program first and querying its properties.
cl::code code
{
"__kernel void ircd_test() {}"_sv
};
code.compile();
code.link();
cl::kern kern
{
code, "ircd_test"
};
ret = kern.preferred_group_size_multiple(device);
return ret;
}
catch(const ctx::interrupted &)
{
throw;
}
catch(const ctx::terminated &)
{
throw;
}
catch(const std::exception &e)
{
log::logf
{
log, log::level::WARNING,
"context(%p) device(%p) query warp size :%s",
static_cast<const void *>(context),
static_cast<const void *>(dev),
e.what(),
};
return 0;
}
uint
ircd::cl::query_warp_size_amd(cl_device_id dev)
try
{
char buf[4];
constexpr auto ign(CL_INVALID_VALUE);
return info<uint, ign>(clGetDeviceInfo, dev, CL_DEVICE_WAVEFRONT_WIDTH_AMD, buf, 0);
}
catch(const std::exception &e)
{
log::error
{
log, "device(%p) query warp size (AMD) :%s",
static_cast<const void *>(dev),
e.what(),
};
return 0;
}
ircd::string_view
ircd::cl::version_str(const mutable_buffer &buf,
const cl_version val)
{
return fmt::sprintf
{
buf, "%u.%u.%u",
CL_VERSION_MAJOR(val),
CL_VERSION_MINOR(val),
CL_VERSION_PATCH(val),
};
}
//
// interface
//
void
ircd::cl::sync()
{
if(unlikely(!primary))
return;
auto &q
{
queue[0][0]
};
call
(
clFinish, q
);
++primary_stats.sync_count;
}
void
ircd::cl::flush()
{
auto &q
{
queue[0][0]
};
call
(
clFlush, q
);
++primary_stats.flush_count;
}
//
// exec
//
namespace ircd::cl
{
static const size_t _deps_list_max {32};
static thread_local cl_event _deps_list[_deps_list_max];
static cl_event *addressof_handle(cl::work *const &);
static void check_submit_blocking(cl::exec *const &, const exec::opts &);
static void handle_submitted(cl::exec *const &, const exec::opts &);
static vector_view<cl_event> make_deps_default(cl::work *const &, const exec::opts &);
static vector_view<cl_event> make_deps(cl::work *const &, const exec::opts &);
}
template<>
decltype(ircd::util::instance_list<ircd::cl::work>::allocator)
ircd::util::instance_list<ircd::cl::work>::allocator
{};
template<>
decltype(ircd::util::instance_list<ircd::cl::work>::list)
ircd::util::instance_list<ircd::cl::work>::list
{
allocator
};
decltype(ircd::cl::exec::opts_default)
ircd::cl::exec::opts_default;
ircd::cl::exec::exec(const opts &opts)
try
{
auto &q
{
queue[0][0]
};
const auto deps
{
make_deps(this, opts)
};
assert(!this->handle);
call
(
clEnqueueBarrierWithWaitList,
q,
deps.size(),
deps.size()? deps.data(): nullptr,
addressof_handle(this)
);
primary_stats.exec_barrier_tasks += 1;
handle_submitted(this, opts);
}
catch(const std::exception &e)
{
log::error
{
log, "Exec Barrier :%s",
e.what(),
};
throw;
}
ircd::cl::exec::exec(kern &kern,
const kern::range &range,
const opts &opts)
try
{
size_t dim(0);
for(size_t i(0); i < range.global.size(); ++i)
dim += range.global[i] > 0 && dim == i;
if(!dim)
return;
if(unlikely(run::level != run::level::RUN))
throw unavailable
{
"Unable to submit work items in runlevel %s",
reflect(run::level),
};
assert(run::level == run::level::RUN);
auto &q
{
queue[0][0]
};
auto &dev
{
device[0][0]
};
const auto deps
{
make_deps(this, opts)
};
assert(!this->object);
this->object = &kern;
const auto max_local_size
{
kern.group_size(dev)
};
const auto reqd_local_size
{
kern.compile_group_size(dev)
};
const auto hint_local_size
{
kern.preferred_group_size_multiple(dev)
};
size_t local[dim];
for(size_t d(0); d < dim; ++d)
{
local[d] = reqd_local_size[d]?: range.local[d]?: hint_local_size;
local[d] = std::min(local[d], max_local_size);
}
size_t global_size{range.global[0]};
size_t local_size{local[0]};
for(size_t d(1); d < dim; ++d)
{
global_size *= range.global[d];
local_size *= local[d];
}
assert(global_size % local_size == 0);
const size_t groups
{
global_size / local_size
};
assert(groups > 0);
size_t intensity
{
cl::intensity?
std::max(opts.intensity, uint(cl::intensity)):
opts.intensity
};
if(intensity < groups)
while(intensity > 1 && groups % intensity != 0)
intensity--;
const size_t tasks
{
intensity && intensity < groups?
groups / intensity:
1
};
assert(!this->handle);
for(size_t i(0); i < tasks; ++i)
{
kern::range sub_range(range);
for(size_t d(0); d < dim; ++d)
{
sub_range.global[d] /= tasks;
sub_range.offset[d] += sub_range.global[d] * i;
}
call
(
clEnqueueNDRangeKernel,
q,
cl_kernel(kern.handle),
dim,
sub_range.offset.data(),
sub_range.global.data(),
local + 0,
deps.size(),
deps.size()? deps.data(): nullptr,
i == tasks - 1? addressof_handle(this): nullptr
);
}
primary_stats.exec_kern_tasks += tasks;
primary_stats.exec_kern_threads += global_size;
primary_stats.exec_kern_groups += groups;
handle_submitted(this, opts);
}
catch(const std::exception &e)
{
log::error
{
log, "Exec Kern :%s",
e.what(),
};
throw;
}
ircd::cl::exec::exec(data &dst,
const data &src,
const opts &opts)
try
{
auto &q
{
queue[0][0]
};
assert(src.handle);
assert(dst.handle);
const size_t size
{
opts.size == -1UL?
std::min(dst.size(), src.size()):
opts.size
};
if(!size)
return;
assert(!this->object);
this->object = &dst;
const auto deps
{
make_deps(this, opts)
};
assert(!this->handle);
call
(
clEnqueueCopyBuffer,
q,
cl_mem(src.handle),
cl_mem(dst.handle),
opts.offset[1],
opts.offset[0],
size,
deps.size(),
deps.size()? deps.data(): nullptr,
addressof_handle(this)
);
primary_stats.exec_copy_bytes += size;
primary_stats.exec_copy_tasks += 1;
handle_submitted(this, opts);
}
catch(const std::exception &e)
{
log::error
{
log, "Exec Copy :%s",
e.what(),
};
throw;
}
ircd::cl::exec::exec(data &data,
const std::memory_order order,
const opts &opts)
try
{
if(unlikely(run::level < run::level::RUN))
throw unavailable
{
"Unable to write to device in runlevel %s",
reflect(run::level),
};
assert(run::level >= run::level::RUN);
const auto max_size
{
opts.size == -1UL?
data.size():
opts.size
};
const auto size
{
size_t(opts.offset[0]) < max_size?
max_size - opts.offset[0]:
0UL
};
assert(size_t(size) <= data.size());
assert(size_t(opts.offset[0]) <= data.size());
if(!size)
return;
bool read {false}, write {false}, invalidate {false};
bool blocking {opts.blocking};
switch(order)
{
case std::memory_order_relaxed:
return;
case std::memory_order_consume:
read = true;
break;
case std::memory_order_acquire:
read = true;
write = true;
break;
case std::memory_order_seq_cst:
read = true;
write = true;
blocking = true;
break;
case std::memory_order_acq_rel:
invalidate = true;
break;
case std::memory_order_release:
break;
}
const cl_map_flags flags
{
(boolmask<cl_map_flags>(read) & CL_MAP_READ) |
(boolmask<cl_map_flags>(write) & CL_MAP_WRITE) |
(boolmask<cl_map_flags>(invalidate) & CL_MAP_WRITE_INVALIDATE_REGION)
};
if(!flags && !data.mapped)
return;
assert(flags || data.mapped);
assert(!this->object);
this->object = &data;
auto &q
{
queue[0][0]
};
const auto deps
{
make_deps(this, opts)
};
int err {CL_SUCCESS};
assert(!this->handle);
if(flags)
data.mapped = clEnqueueMapBuffer
(
q,
cl_mem(data.handle),
blocking,
flags,
opts.offset[0],
size,
deps.size(),
deps.size()? deps.data(): nullptr,
addressof_handle(this),
&err
);
else
call
(
clEnqueueUnmapMemObject,
q,
cl_mem(data.handle),
std::exchange(data.mapped, nullptr),
0, // deps
nullptr, // depslist
addressof_handle(this)
);
throw_on_error(err);
primary_stats.exec_read_bytes += read? size: 0;
primary_stats.exec_read_tasks += read;
primary_stats.exec_write_bytes += write || invalidate? size: 0;
primary_stats.exec_write_tasks += write || invalidate;
handle_submitted(this, opts);
assert(data.mapped || !flags);
assert(this->handle);
}
catch(const std::exception &e)
{
log::error
{
log, "Exec Map order:%d :%s",
int(order),
e.what(),
};
throw;
}
void
ircd::cl::handle_submitted(cl::exec *const &exec,
const exec::opts &opts)
{
assert(run::level == run::level::RUN || run::level == run::level::QUIT);
primary_stats.exec_tasks += 1;
if(opts.flush)
cl::flush();
if(opts.sync)
cl::sync();
if(likely(!opts.blocking))
check_submit_blocking(exec, opts);
}
/// Checks if the OpenCL runtime blocked this thread to sound the alarms.
void
ircd::cl::check_submit_blocking(cl::exec *const &exec,
const exec::opts &opts)
{
const uint64_t &threshold
{
watchdog_tsc
};
if(!threshold)
return;
const auto submit_cycles
{
prof::cycles() - exec->ts
};
if(likely(submit_cycles < threshold))
return;
char nbuf[64];
const auto name
{
exec->name(nbuf)
};
char pbuf[32];
log::dwarning
{
log, "clEnqueue() kernel '%s' blocking the host for %s cycles on submit.",
name?: "<unnamed kernel or unknown command type>"_sv,
pretty(pbuf, si(submit_cycles), 1),
};
}
ircd::vector_view<cl_event>
ircd::cl::make_deps(cl::work *const &work,
const exec::opts &opts)
{
if(empty(opts.deps) && !opts.indep)
return make_deps_default(work, opts);
if(empty(opts.deps))
return {};
size_t ret(0);
vector_view<cl_event> out(_deps_list);
for(auto &exec : opts.deps)
out.at(ret++) = cl_event(exec.handle);
return vector_view<cl_event>
{
out, ret
};
}
ircd::vector_view<cl_event>
ircd::cl::make_deps_default(cl::work *const &work,
const exec::opts &opts)
{
size_t ret(0);
vector_view<cl_event> out(_deps_list);
for(auto it(rbegin(cl::work::list)); it != rend(cl::work::list); ++it)
{
cl::work *const &other{*it};
if(other == work)
continue;
if(!other->handle)
continue;
if(other->context != ctx::current)
continue;
out.at(ret++) = cl_event(other->handle);
break;
}
return vector_view<cl_event>
{
out, ret
};
}
cl_event *
ircd::cl::addressof_handle(cl::work *const &work)
{
const auto handle
{
std::addressof(work->handle)
};
cl_event *const ret
(
reinterpret_cast<cl_event *>(handle)
);
return ret;
}
//
// kern
//
ircd::cl::kern::kern(code &code,
const string_view &name)
try
{
int err {CL_SUCCESS};
handle = clCreateKernel(cl_program(code.handle), name.c_str(), &err);
throw_on_error(err);
const std::array<size_t, 3> cgs
{
#ifdef RB_DEBUG
compile_group_size(device[0][0]) //TODO: XXX
#else
0, 0, 0
#endif
};
char buf[1][16];
char pbuf[2][48];
if constexpr((false))
log::debug
{
log, "kernel stack %s local %s group:%zu pref:%zu comp:%zu:%zu:%zu :%s",
pretty(pbuf[0], iec(stack_mem_size())),
pretty(pbuf[1], iec(local_mem_size())),
group_size(),
preferred_group_size_multiple(),
cgs[0], cgs[1], cgs[2],
name,
};
}
catch(const std::exception &e)
{
log::error
{
log, "Kernel Create '%s' :%s",
name,
e.what(),
};
throw;
}
ircd::cl::kern::~kern()
noexcept try
{
if(likely(handle))
call(clReleaseKernel, cl_kernel(handle));
}
catch(const std::exception &e)
{
log::critical
{
log, "Kernel Release :%s",
e.what(),
};
return;
}
void
ircd::cl::kern::arg(const int i,
data &data)
{
const auto &data_handle
{
cl_mem(data.handle)
};
call(clSetKernelArg, cl_kernel(handle), i, sizeof(cl_mem), &data_handle);
}
void
ircd::cl::kern::arg(const int i,
const const_buffer &buf)
{
call(clSetKernelArg, cl_kernel(handle), i, ircd::size(buf), ircd::data(buf));
}
std::array<size_t, 3>
ircd::cl::kern::compile_group_size(void *const dev)
const
{
char buf[24];
const auto handle(cl_kernel(this->handle));
constexpr auto flag(CL_KERNEL_COMPILE_WORK_GROUP_SIZE);
return info<std::array<size_t, 3>>(clGetKernelWorkGroupInfo, handle, cl_device_id(dev), flag, buf);
}
size_t
ircd::cl::kern::preferred_group_size_multiple(void *const dev)
const
{
char buf[16];
const auto handle(cl_kernel(this->handle));
constexpr auto flag(CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE);
return info<size_t>(clGetKernelWorkGroupInfo, handle, cl_device_id(dev), flag, buf);
}
size_t
ircd::cl::kern::group_size(void *const dev)
const
{
char buf[16];
const auto handle(cl_kernel(this->handle));
constexpr auto flag(CL_KERNEL_WORK_GROUP_SIZE);
return info<size_t>(clGetKernelWorkGroupInfo, handle, cl_device_id(dev), flag, buf);
}
size_t
ircd::cl::kern::local_mem_size(void *const dev)
const
{
char buf[16];
const auto handle(cl_kernel(this->handle));
constexpr auto flag(CL_KERNEL_LOCAL_MEM_SIZE);
return info<ulong>(clGetKernelWorkGroupInfo, handle, cl_device_id(dev), flag, buf);
}
size_t
ircd::cl::kern::stack_mem_size(void *const dev)
const
{
char buf[16];
const auto handle(cl_kernel(this->handle));
constexpr auto flag(CL_KERNEL_PRIVATE_MEM_SIZE);
return info<ulong>(clGetKernelWorkGroupInfo, handle, cl_device_id(dev), flag, buf);
}
uint
ircd::cl::kern::argc()
const
{
const auto handle
{
cl_kernel(this->handle)
};
char buf[sizeof(uint)];
return info<uint>(clGetKernelInfo, handle, CL_KERNEL_NUM_ARGS, buf);
}
ircd::string_view
ircd::cl::kern::name(const mutable_buffer &buf)
const
{
const auto handle
{
cl_kernel(this->handle)
};
return handle?
info(clGetKernelInfo, handle, CL_KERNEL_FUNCTION_NAME, buf):
string_view{};
}
//
// code
//
namespace ircd::cl
{
static void build_handle_error_log_line(const string_view &line);
static void build_handle_error(code &, const opencl_error &);
static void build_handle(cl_program program, void *priv);
}
decltype(ircd::cl::code::iov_max)
ircd::cl::code::iov_max
{
64
};
//
// code::code
//
ircd::cl::code::code(path_t,
const string_view &paths)
:code
{
path,
vector_view<const string_view>(&paths, 1),
}
{
}
ircd::cl::code::code(path_t,
const vector_view<const string_view> &paths_)
{
static const auto is_cl
{
[](const auto &path)
{
return fs::is_reg(path) && fs::is_extension(path, ".cl");
}
};
std::vector<std::string> buf;
for(const auto &path : paths_)
if(fs::is_dir(path))
{
for(const auto &file : fs::ls(path))
if(is_cl(file))
buf.emplace_back(fs::read(fs::fd(file)));
}
else if(is_cl(path))
buf.emplace_back(fs::read(fs::fd(path)));
const auto count(buf.size());
if(unlikely(count > iov_max))
throw error
{
"Maximum number of sources exceeded: lim:%zu got:%zu",
iov_max,
count,
};
string_view src[count];
for(uint i(0); i < count; ++i)
src[i] = buf[i];
create(vector_view<const string_view>(src, count));
}
ircd::cl::code::code(const string_view &src)
:code
{
vector_view<const string_view>(&src, 1),
}
{
}
ircd::cl::code::code(const vector_view<const string_view> &srcs)
{
create(srcs);
}
ircd::cl::code::code(const vector_view<const const_buffer> &bins)
{
create(bins);
}
ircd::cl::code::code(const const_buffer &bc)
{
char pbuf[1][48];
log::logf
{
log, log::level::DEBUG,
"code(%p) loading %s bitcode:%p",
this,
pretty(pbuf[0], si(ircd::size(bc))),
ircd::data(bc),
};
assert(!handle);
int err {CL_SUCCESS};
handle = clCreateProgramWithIL
(
primary,
ircd::data(bc),
ircd::size(bc),
&err
);
throw_on_error(err);
}
ircd::cl::code::~code()
noexcept try
{
if(likely(handle))
call(clReleaseProgram, cl_program(handle));
}
catch(const std::exception &e)
{
log::critical
{
log, "Program Release :%s",
e.what(),
};
return;
}
void
ircd::cl::code::create(const vector_view<const string_view> &srcs)
{
const auto count(srcs.size());
if(unlikely(count > iov_max))
throw error
{
"Maximum number of sources exceeded: lim:%zu got:%zu",
iov_max,
srcs.size(),
};
size_t len[count];
const char *src[count];
for(size_t i(0); i < count; ++i)
src[i] = ircd::data(srcs[i]),
len[i] = ircd::size(srcs[i]);
char pbuf[1][48];
log::logf
{
log, log::level::DEBUG,
"code(%p) creating %s srcs:%zu",
this,
pretty(pbuf[0], si(std::accumulate(len, len + count, 0))),
count,
};
assert(!handle);
int err {CL_SUCCESS};
handle = clCreateProgramWithSource(primary, count, src, len, &err);
throw_on_error(err);
}
void
ircd::cl::code::create(const vector_view<const const_buffer> &bins)
{
const auto count(bins.size());
if(unlikely(count > iov_max))
throw error
{
"Maximum number of binaries exceeded: lim:%zu got:%zu",
iov_max,
count,
};
size_t len[iov_max + 1] {0};
const uint8_t *bin[iov_max + 1] {nullptr};
for(size_t i(0); i < count; ++i)
bin[i] = reinterpret_cast<const uint8_t *>(ircd::data(bins[i])),
len[i] = ircd::size(bins[i]);
size_t devs {0};
cl_device_id dev[DEVICE_MAX] {0};
for(size_t i(0); i < platforms; ++i)
for(size_t j(0); j < devices[i]; ++j)
dev[devs++] = device[i][j];
char pbuf[1][48];
log::logf
{
log, log::level::DEBUG,
"code(%p) loading %s bins:%zu devs:%zu",
this,
pretty(pbuf[0], si(std::accumulate(len, len + count, 0))),
count,
devs,
};
assert(len);
assert(devs);
assert(!handle);
int err {CL_SUCCESS};
int binerr[iov_max + 1] {CL_SUCCESS};
handle = clCreateProgramWithBinary(primary, devs, dev, len, bin, binerr, &err);
throw_on_error(err);
for(size_t i(0); i < count; ++i)
throw_on_error(binerr[i]);
}
void
ircd::cl::code::build(const string_view &opts)
try
{
const uint num_devices {1};
const cl_device_id *device_list
{
device[0] //TODO: XXX
};
log::logf
{
log, log::level::DEBUG,
"code(%p) building devs:%zu %c%s",
this,
num_devices,
opts? ':': ' ',
opts,
};
call
(
clBuildProgram,
cl_program(handle),
num_devices,
device_list,
opts.c_str(),
cl::build_handle,
this
);
}
catch(const opencl_error &e)
{
build_handle_error(*this, e);
throw;
}
catch(const std::exception &e)
{
log::error
{
log, "code(%p) :Failed to build :%s",
this,
e.what(),
};
throw;
}
void
ircd::cl::code::link(const string_view &opts)
try
{
const uint num_devices {1};
const cl_device_id *device_list
{
device[0] //TODO: XXX
};
assert(this->handle);
const uint num_progs {1};
const cl_program progs[]
{
cl_program(this->handle)
};
log::logf
{
log, log::level::DEBUG,
"code(%p) linking devs:%zu progs:%zu opts:%zu$B %c%s",
this,
num_devices,
num_progs,
ircd::size(opts),
opts? ':': ' ',
opts,
};
int err
{
CL_COMPILER_NOT_AVAILABLE
};
#ifdef CL_VERSION_1_2
void *handle
{
clLinkProgram
(
primary,
num_devices,
device_list,
opts.c_str(),
num_progs,
progs,
cl::build_handle,
this,
&err
)
};
#endif
throw_on_error(err);
std::swap(handle, this->handle);
call(clReleaseProgram, cl_program(handle));
}
catch(const opencl_error &e)
{
build_handle_error(*this, e);
throw;
}
catch(const std::exception &e)
{
log::error
{
log, "code(%p) :Failed to link :%s",
this,
e.what(),
};
throw;
}
void
ircd::cl::code::compile(const string_view &opts)
try
{
const uint num_devices {1};
const cl_device_id *device_list
{
device[0] //TODO: XXX
};
const uint num_headers {0};
const cl_program *header_progs
{
nullptr
};
const char *header_names[]
{
nullptr
};
log::logf
{
log, log::level::DEBUG,
"code(%p) compiling devs:%zu headers:%zu %c%s",
this,
num_devices,
num_headers,
opts? ':': ' ',
opts,
};
#ifdef CL_VERSION_1_2
call
(
clCompileProgram,
cl_program(handle),
num_devices,
device_list,
opts.c_str(),
num_headers,
header_progs,
nullptr, //header_names, // clover api bug?
cl::build_handle,
this
);
#else
throw_on_error(CL_COMPILER_NOT_AVAILABLE);
#endif
}
catch(const opencl_error &e)
{
build_handle_error(*this, e);
throw;
}
catch(const std::exception &e)
{
log::error
{
log, "code(%p) :Failed to compile :%s",
this,
e.what(),
};
throw;
}
ircd::string_view
ircd::cl::code::src(const mutable_buffer &buf)
const
{
const auto &handle
{
cl_program(this->handle)
};
return info(clGetProgramInfo, handle, CL_PROGRAM_SOURCE, buf);
}
ircd::vector_view<const ircd::mutable_buffer>
ircd::cl::code::bin(vector_view<mutable_buffer> buf)
const
{
const auto &handle
{
cl_program(this->handle)
};
const auto devs
{
this->devs()
};
assert(devs <= ircd::size(buf));
const auto count
{
std::min(devs, ircd::size(buf))
};
size_t bin_sz[count];
const auto bins
{
this->bins({bin_sz, count})
};
assert(bins <= count);
const auto num
{
std::min(bins, count)
};
for(size_t i(0); i < num; ++i)
buf[i] = mutable_buffer
{
buf[i], bin_sz[i]
};
uintptr_t ptr[num];
for(size_t i(0); i < num; ++i)
ptr[i] = uintptr_t(ircd::data(buf[i]));
info(clGetProgramInfo, handle, CL_PROGRAM_BINARIES, mutable_buffer
{
reinterpret_cast<char *>(ptr), sizeof(uintptr_t) * num
});
return buf;
}
size_t
ircd::cl::code::bins_size()
const
{
const auto devs
{
this->devs()
};
size_t bin_sz[devs];
const auto bins
{
this->bins({bin_sz, devs})
};
assert(bins <= devs);
const auto ret
{
std::accumulate(bin_sz, bin_sz + bins, 0UL)
};
return ret;
}
size_t
ircd::cl::code::bins(const vector_view<size_t> &buf)
const
{
const auto &handle
{
cl_program(this->handle)
};
const auto count
{
devs()
};
assert(count <= size(buf));
info(clGetProgramInfo, handle, CL_PROGRAM_BINARY_SIZES, mutable_buffer
{
reinterpret_cast<char *>(ircd::data(buf)), ircd::size(buf) * sizeof(size_t)
});
return count;
}
size_t
ircd::cl::code::devs()
const
{
char buf[sizeof(uint)];
const auto &handle
{
cl_program(this->handle)
};
return info<uint>(clGetProgramInfo, handle, CL_PROGRAM_NUM_DEVICES, buf);
}
long
ircd::cl::code::status()
const
{
const auto &handle
{
cl_program(this->handle)
};
cl_build_status buf;
const mutable_buffer mb
{
reinterpret_cast<char *>(&buf), sizeof(buf)
};
const auto &dev
{
device[0][0], //TODO: XXX
};
const auto ret
{
info<cl_build_status>(clGetProgramBuildInfo, handle, dev, CL_PROGRAM_BUILD_STATUS, mb)
};
return ret;
}
void
ircd::cl::build_handle(cl_program program,
void *const priv)
{
cl::code *const &code
{
reinterpret_cast<cl::code *>(priv)
};
assert(code);
char pbuf[1][48];
log::logf
{
log, log::level::DEBUG,
"program(%p) devs:%zu binsz:%s :Build complete.",
(const void *)program,
code->devs(),
pretty(pbuf[0], si(code->bins_size())),
};
}
void
ircd::cl::build_handle_error(code &code,
const opencl_error &e)
{
const auto string_closure
{
[&code](const mutable_buffer &buf)
{
size_t len {0}; call
(
clGetProgramBuildInfo,
cl_program(code.handle),
device[0][0], //TODO: XXX
CL_PROGRAM_BUILD_LOG,
ircd::size(buf),
ircd::data(buf),
&len
);
return len;
}
};
const auto error_message
{
ircd::string(8_KiB | SHRINK_TO_FIT, string_closure)
};
const auto lines
{
ircd::tokens(error_message, '\n', build_handle_error_log_line)
};
}
void
ircd::cl::build_handle_error_log_line(const string_view &line)
{
// note last line is just a CR
if(line.size() <= 1)
return;
const auto &[loc, line_] { split(line, ' ') };
const auto &[fac, msg] { split(line_, ' ') };
const auto &[fname, pos] { split(loc, ':') };
const auto &[row, col] { split(pos, ':') };
const auto level
{
startswith(fac, "warning")?
log::level::WARNING:
startswith(fac, "error")?
log::level::ERROR:
log::level::ERROR
};
log::logf
{
log, level, "%s", line
};
}
//
// data
//
decltype(ircd::cl::data::gart_page_size)
ircd::cl::data::gart_page_size
{
{ "name", "ircd.cl.data.gart.page_size" },
{ "default", 4096 },
{ "help", "Override (un)detected gart page size." },
};
ircd::cl::data::data(const size_t size,
const bool host_read,
const bool host_write)
{
if(!size)
return;
cl_mem_flags flags {0};
flags |= CL_MEM_READ_WRITE;
flags |= host_read && !host_write? CL_MEM_HOST_READ_ONLY: 0;
flags |= !host_read && host_write? CL_MEM_HOST_WRITE_ONLY: 0;
flags |= !host_read && !host_write? CL_MEM_HOST_NO_ACCESS: 0;
char pbuf[48];
log::debug
{
log, "data(%p) device %s %lu@ host[read:%b write:%b] flags:%08x",
this,
pretty(pbuf, iec(size)),
alignment(size),
host_read,
host_write,
flags,
};
int err {CL_SUCCESS};
handle = clCreateBuffer
(
primary,
flags,
size,
nullptr,
&err
);
throw_on_error(err);
primary_stats.alloc_count += 1;
primary_stats.alloc_bytes += size;
}
ircd::cl::data::data(const mutable_buffer &buf,
const bool wonly)
{
const auto &ptr
{
ircd::data(buf)
};
const auto &size
{
ircd::size(buf)
};
if(!size)
return;
cl_mem_flags flags {0};
flags |= CL_MEM_USE_HOST_PTR;
flags |= wonly? CL_MEM_WRITE_ONLY: CL_MEM_READ_WRITE;
char pbuf[48];
log::debug
{
log, "data(%p) mutable %p %lu@ %s %lu@ wonly:%b flags:%08x",
this,
ptr,
alignment(ptr),
pretty(pbuf, iec(size)),
alignment(size),
wonly,
flags,
};
assert(!ptr || aligned(buf, size_t(gart_page_size)));
assert(padded(size, size_t(gart_page_size)));
int err {CL_SUCCESS};
handle = clCreateBuffer
(
primary,
flags,
size,
ptr,
&err
);
throw_on_error(err);
primary_stats.alloc_count += 1;
primary_stats.alloc_bytes += size;
}
ircd::cl::data::data(const const_buffer &buf)
{
const auto &ptr
{
ircd::data(buf)
};
const auto &size
{
ircd::size(buf)
};
if(!size)
return;
cl_mem_flags flags {0};
flags |= CL_MEM_USE_HOST_PTR;
flags |= CL_MEM_READ_ONLY;
char pbuf[48];
log::debug
{
log, "data(%p) immutable %p %lu@ %s %lu@ flags:%08x",
this,
ptr,
alignment(ptr),
pretty(pbuf, iec(size)),
alignment(size),
flags,
};
assert(!ptr || aligned(buf, size_t(gart_page_size)));
assert(padded(size, size_t(gart_page_size)));
int err {CL_SUCCESS};
handle = clCreateBuffer
(
primary,
flags,
size,
mutable_cast(ptr),
&err
);
throw_on_error(err);
primary_stats.alloc_count += 1;
primary_stats.alloc_bytes += size;
}
ircd::cl::data::data(data &master,
const pair<size_t, off_t> &slice)
{
constexpr auto type
{
CL_BUFFER_CREATE_TYPE_REGION
};
if(!master.handle)
return;
cl_buffer_region region {0};
region.size = slice.first;
region.origin = master.offset() + slice.second;
if(!region.size)
return;
const auto root
{
master.master()?: master.handle
};
char pbuf[48];
if constexpr((false))
log::debug
{
log, "data(%p) master(%p) region offset:%zu %lu@ %s %lu@",
this,
root,
region.origin,
alignment(region.origin),
pretty(pbuf, iec(region.size)),
alignment(region.size),
};
assert(aligned(region.origin, size_t(gart_page_size)));
assert(padded(region.size, size_t(gart_page_size)));
assert(root);
int err {CL_SUCCESS};
handle = clCreateSubBuffer
(
cl_mem(root),
cl_mem_flags{0},
type,
&region,
&err
);
throw_on_error(err);
}
ircd::cl::data::~data()
noexcept try
{
assert(handle || !mapped);
if(likely(handle))
{
const auto size
{
this->size()
};
call(clReleaseMemObject, cl_mem(handle));
primary_stats.dealloc_count += 1;
primary_stats.dealloc_bytes += size;
}
}
catch(const std::exception &e)
{
log::critical
{
log, "Memory Release :%s",
e.what(),
};
return;
}
char *
ircd::cl::data::ptr()
const
{
assert(handle);
char buf[sizeof(void *)] {0};
const auto ret
{
this->mapped?
static_cast<char *>(this->mapped):
info<char *>(clGetMemObjectInfo, cl_mem(mutable_cast(handle)), CL_MEM_HOST_PTR, buf)
};
return ret;
}
size_t
ircd::cl::data::refs()
const
{
assert(handle);
char buf[sizeof(size_t)] {0};
return info<uint>(clGetMemObjectInfo, cl_mem(mutable_cast(handle)), CL_MEM_REFERENCE_COUNT, buf);
}
off_t
ircd::cl::data::offset()
const
{
assert(handle);
char buf[sizeof(off_t)] {0};
return info<off_t>(clGetMemObjectInfo, cl_mem(mutable_cast(handle)), CL_MEM_OFFSET, buf);
}
size_t
ircd::cl::data::size()
const
{
assert(handle);
char buf[sizeof(size_t)] {0};
return info<size_t>(clGetMemObjectInfo, cl_mem(mutable_cast(handle)), CL_MEM_SIZE, buf);
}
uint
ircd::cl::data::flags()
const
{
assert(handle);
char buf[sizeof(uint)] {0};
return info<uint>(clGetMemObjectInfo, cl_mem(mutable_cast(handle)), CL_MEM_FLAGS, buf);
}
void *
ircd::cl::data::master()
const
{
assert(handle);
char buf[sizeof(void *)] {0};
constexpr auto qtype(CL_MEM_ASSOCIATED_MEMOBJECT);
return info<cl_mem>(clGetMemObjectInfo, cl_mem(mutable_cast(handle)), qtype, buf);
}
//
// cl::work (event)
//
namespace ircd::cl
{
struct completion;
extern conf::item<bool> offload_enable;
extern const ctx::ole::opts offload_opts;
static void handle_event_callback(cl_event, cl_int, void *) noexcept;
static int wait_event_callback(work &, const int, const int);
static int wait_event_offload(work &, const int, const int);
static int wait_event(work &, const int, const int);
}
struct alignas(64) ircd::cl::completion
{
cl_event event {nullptr};
cl_int status {CL_COMPLETE};
ctx::dock dock;
};
decltype(ircd::cl::offload_enable)
ircd::cl::offload_enable
{
{ "name", "ircd.cl.offload.enable" },
{ "default", true },
};
decltype(ircd::cl::offload_opts)
ircd::cl::offload_opts
{
"cl"
};
[[gnu::visibility("hidden")]]
void
ircd::cl::work::init()
{
}
[[using gnu: cold, visibility("hidden")]]
void
ircd::cl::work::fini()
noexcept
{
cl::sync();
}
//
// work::work
//
ircd::cl::work::work()
{
if(unlikely(!cl::linkage))
throw unavailable
{
"OpenCL runtime is not available."
};
assert(cl::linkage);
}
ircd::cl::work::work(void *const &handle)
{
call(clRetainEvent, cl_event(handle));
this->handle = handle;
}
ircd::cl::work::~work()
noexcept try
{
if(!handle)
return;
const unwind free{[this]
{
assert(handle);
call(clReleaseEvent, cl_event(handle));
}};
wait();
}
catch(const std::exception &e)
{
log::critical
{
log, "Work Release :%s",
e.what(),
};
return;
}
void
ircd::cl::work::wait(const uint desired)
try
{
static_assert(CL_COMPLETE == 0);
constexpr auto execution_status
{
CL_EVENT_COMMAND_EXECUTION_STATUS
};
char buf[4];
int status {0};
if(likely(handle))
status = info<int>(clGetEventInfo, cl_event(handle), execution_status, buf);
if(status > int(desired))
status = wait_event(*this, status, desired);
if(unlikely(status < 0))
throw_on_error(status);
assert(int(status) == int(desired));
}
catch(const std::exception &e)
{
log::error
{
log, "work(%p)::wait(%u) :%s",
this,
desired,
e.what(),
};
throw;
}
ircd::string_view
ircd::cl::work::name(const mutable_buffer &buf)
const
{
switch(const auto type(this->type()); type)
{
default:
return nullptr;
case CL_COMMAND_READ_BUFFER: return "READ_BUFFER";
case CL_COMMAND_WRITE_BUFFER: return "WRITE_BUFFER";
case CL_COMMAND_COPY_BUFFER: return "COPY_BUFFER";
case CL_COMMAND_MAP_BUFFER: return "MAP_BUFFER";
case CL_COMMAND_UNMAP_MEM_OBJECT: return "UNMAP_MEM_OBJECT";
case CL_COMMAND_NDRANGE_KERNEL:
{
const auto kern
{
reinterpret_cast<const cl::kern *>(object)
};
return kern? kern->name(buf): "NDRANGE_KERNEL";
}
};
}
int
ircd::cl::work::type()
const
{
const auto handle
{
cl_event(this->handle)
};
if(!handle)
return 0;
char buf[4];
return info<int>(clGetEventInfo, handle, CL_EVENT_COMMAND_TYPE, buf);
}
//
// cl::work::prof
//
ircd::cl::work::prof::prof(const cl::work &w)
{
const auto h
{
cl_event(w.handle)
};
if(!profile_queue || !h)
{
for(uint i(0); i < this->size(); ++i)
(*this)[i] = 0ns;
return;
}
char b[5][8];
(*this)[0] = info<nanoseconds>(clGetEventProfilingInfo, h, CL_PROFILING_COMMAND_QUEUED, b[0]);
(*this)[1] = info<nanoseconds>(clGetEventProfilingInfo, h, CL_PROFILING_COMMAND_SUBMIT, b[1]);
(*this)[2] = info<nanoseconds>(clGetEventProfilingInfo, h, CL_PROFILING_COMMAND_START, b[2]);
(*this)[3] = info<nanoseconds>(clGetEventProfilingInfo, h, CL_PROFILING_COMMAND_END, b[3]);
(*this)[4] = info<nanoseconds>(clGetEventProfilingInfo, h, CL_PROFILING_COMMAND_COMPLETE, b[4]);
}
//
// cl::work (internal)
//
int
ircd::cl::wait_event(work &work,
const int status,
const int desired)
{
assert(work.handle);
assert(status > desired);
const ctx::uninterruptible::nothrow ui;
const bool use_offload
{
// conf item
bool(offload_enable)
};
const auto ret
{
use_offload?
wait_event_offload(work, status, desired):
wait_event_callback(work, status, desired)
};
const bool is_err
{
ret < 0
};
const bool is_complete
{
ret == CL_COMPLETE
};
primary_stats.work_completes += is_complete;
primary_stats.work_errors += is_err;
primary_stats.work_waits += 1;
return ret;
}
int
ircd::cl::wait_event_offload(work &work,
const int status,
const int desired)
{
completion c
{
cl_event(work.handle),
status,
};
ctx::ole::offload
{
offload_opts, [&c]
{
assert(c.status != CL_COMPLETE);
call(clWaitForEvents, 1UL, &c.event);
c.status = CL_COMPLETE;
}
};
assert(c.status == CL_COMPLETE);
return c.status;
}
int
ircd::cl::wait_event_callback(work &work,
const int status,
const int desired)
{
// Completion state structure on this ircd::ctx's stack.
completion c
{
cl_event(work.handle),
status,
};
// Completion condition closure to be satisfied.
const auto condition{[&c, &desired]
() noexcept -> bool
{
return !c.event || c.status <= desired;
}};
// Register callback with OpenCL; note that the callback might be
// dispatched immediately from this call itself (see below).
call
(
clSetEventCallback,
c.event,
desired,
&handle_event_callback,
&c
);
// This stats item counts clSetEventCallback()'s which return before OpenCL
// calls the callback, verifying asynchronicity. If this stats item remains
// zero, the OpenCL runtime has hijacked our thread for a blocking wait.
primary_stats.work_waits_async += !condition();
// Yield ircd::ctx while condition unsatisfied
c.dock.wait(condition);
return c.status;
}
void
ircd::cl::handle_event_callback(cl_event event,
cl_int status,
void *const priv)
noexcept
{
auto *const c
{
reinterpret_cast<completion *>(priv)
};
assert(priv != nullptr);
assert(event != nullptr);
assert(c->event == event);
c->status = status;
c->dock.notify_one();
}
//
// callback surface
//
void
ircd::cl::handle_notify(const char *errstr,
const void *token,
size_t cb,
void *priv)
noexcept
{
if(errstr)
log::error
{
log, "OpenCL t:%p cb:%zu :%s",
token,
cb,
errstr,
};
}
//
// util
//
template<class T,
int maybe,
class F,
class id0,
class param>
T
ircd::cl::info(F&& func,
const id0 &i0,
const param &p,
const mutable_buffer &out,
T default_)
{
using ircd::data;
using ircd::size;
size_t len {0};
const auto code
{
call<maybe>(std::forward<F>(func), i0, p, size(out), data(out), &len)
};
assert(code == CL_SUCCESS || code == maybe);
if constexpr(maybe != CL_SUCCESS)
if(code == maybe)
return default_;
return byte_view<T>
{
string_view
{
data(out), len
}
};
}
template<class T,
int maybe,
class F,
class id0,
class id1,
class param>
T
ircd::cl::info(F&& func,
const id0 &i0,
const id1 &i1,
const param &p,
const mutable_buffer &out,
T default_)
{
using ircd::data;
using ircd::size;
size_t len {0};
const auto code
{
call<maybe>(std::forward<F>(func), i0, i1, p, size(out), data(out), &len)
};
assert(code == CL_SUCCESS || code == maybe);
if constexpr(maybe != CL_SUCCESS)
if(code == maybe)
return default_;
return byte_view<T>
{
string_view
{
data(out), len
}
};
}
template<int maybe,
class func,
class... args>
int
ircd::cl::call(func&& f,
args&&... a)
{
const int ret
{
f(std::forward<args>(a)...)
};
if constexpr(maybe != CL_SUCCESS)
if(ret == maybe)
return ret;
return throw_on_error(ret);
}
int
ircd::cl::throw_on_error(const int &code)
{
if(unlikely(is_error(code)))
throw opencl_error
{
"(%d) :%s",
code,
reflect_error(code),
};
return code;
}
bool
ircd::cl::is_error(const int &code)
noexcept
{
return code < 0;
}
ircd::string_view
ircd::cl::reflect_error(const int code)
noexcept
{
switch(code)
{
case CL_SUCCESS: return "SUCCESS";
case CL_DEVICE_NOT_FOUND: return "DEVICE_NOT_FOUND";
case CL_DEVICE_NOT_AVAILABLE: return "DEVICE_NOT_AVAILABLE";
case CL_COMPILER_NOT_AVAILABLE: return "COMPILER_NOT_AVAILABLE";
case CL_MEM_OBJECT_ALLOCATION_FAILURE: return "MEM_OBJECT_ALLOCATION_FAILURE";
case CL_OUT_OF_RESOURCES: return "OUT_OF_RESOURCES";
case CL_OUT_OF_HOST_MEMORY: return "OUT_OF_HOST_MEMORY";
case CL_PROFILING_INFO_NOT_AVAILABLE: return "PROFILING_INFO_NOT_AVAILABLE";
case CL_MEM_COPY_OVERLAP: return "MEM_COPY_OVERLAP";
case CL_IMAGE_FORMAT_MISMATCH: return "IMAGE_FORMAT_MISMATCH";
case CL_IMAGE_FORMAT_NOT_SUPPORTED: return "IMAGE_FORMAT_NOT_SUPPORTED";
case CL_BUILD_PROGRAM_FAILURE: return "BUILD_PROGRAM_FAILURE";
case CL_MAP_FAILURE: return "MAP_FAILURE";
case CL_INVALID_VALUE: return "INVALID_VALUE";
case CL_INVALID_DEVICE_TYPE: return "INVALID_DEVICE_TYPE";
case CL_INVALID_PLATFORM: return "INVALID_PLATFORM";
case CL_INVALID_DEVICE: return "INVALID_DEVICE";
case CL_INVALID_CONTEXT: return "INVALID_CONTEXT";
case CL_INVALID_QUEUE_PROPERTIES: return "INVALID_QUEUE_PROPERTIES";
case CL_INVALID_COMMAND_QUEUE: return "INVALID_COMMAND_QUEUE";
case CL_INVALID_HOST_PTR: return "INVALID_HOST_PTR";
case CL_INVALID_MEM_OBJECT: return "INVALID_MEM_OBJECT";
case CL_INVALID_IMAGE_FORMAT_DESCRIPTOR: return "INVALID_IMAGE_FORMAT_DESCRIPTOR";
case CL_INVALID_IMAGE_SIZE: return "INVALID_IMAGE_SIZE";
case CL_INVALID_SAMPLER: return "INVALID_SAMPLER";
case CL_INVALID_BINARY: return "INVALID_BINARY";
case CL_INVALID_BUILD_OPTIONS: return "INVALID_BUILD_OPTIONS";
case CL_INVALID_PROGRAM: return "INVALID_PROGRAM";
case CL_INVALID_PROGRAM_EXECUTABLE: return "INVALID_PROGRAM_EXECUTABLE";
case CL_INVALID_KERNEL_NAME: return "INVALID_KERNEL_NAME";
case CL_INVALID_KERNEL_DEFINITION: return "INVALID_KERNEL_DEFINITION";
case CL_INVALID_KERNEL: return "INVALID_KERNEL";
case CL_INVALID_ARG_INDEX: return "INVALID_ARG_INDEX";
case CL_INVALID_ARG_VALUE: return "INVALID_ARG_VALUE";
case CL_INVALID_ARG_SIZE: return "INVALID_ARG_SIZE";
case CL_INVALID_KERNEL_ARGS: return "INVALID_KERNEL_ARGS";
case CL_INVALID_WORK_DIMENSION: return "INVALID_WORK_DIMENSION";
case CL_INVALID_WORK_GROUP_SIZE: return "INVALID_WORK_GROUP_SIZE";
case CL_INVALID_WORK_ITEM_SIZE: return "INVALID_WORK_ITEM_SIZE";
case CL_INVALID_GLOBAL_OFFSET: return "INVALID_GLOBAL_OFFSET";
case CL_INVALID_EVENT_WAIT_LIST: return "INVALID_EVENT_WAIT_LIST";
case CL_INVALID_EVENT: return "INVALID_EVENT";
case CL_INVALID_OPERATION: return "INVALID_OPERATION";
case CL_INVALID_GL_OBJECT: return "INVALID_GL_OBJECT";
case CL_INVALID_BUFFER_SIZE: return "INVALID_BUFFER_SIZE";
case CL_INVALID_MIP_LEVEL: return "INVALID_MIP_LEVEL";
case CL_INVALID_GLOBAL_WORK_SIZE: return "INVALID_GLOBAL_WORK_SIZE";
#ifdef CL_VERSION_1_1
case CL_INVALID_PROPERTY: return "INVALID_PROPERTY";
case CL_MISALIGNED_SUB_BUFFER_OFFSET: return "MISALIGNED_SUB_BUFFER_OFFSET";
case CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST: return "EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST";
#endif
#ifdef CL_VERSION_1_2
case CL_COMPILE_PROGRAM_FAILURE: return "COMPILE_PROGRAM_FAILURE";
case CL_LINKER_NOT_AVAILABLE: return "LINKER_NOT_AVAILABLE";
case CL_LINK_PROGRAM_FAILURE: return "LINK_PROGRAM_FAILURE";
case CL_DEVICE_PARTITION_FAILED: return "DEVICE_PARTITION_FAILED";
case CL_KERNEL_ARG_INFO_NOT_AVAILABLE: return "KERNEL_ARG_INFO_NOT_AVAILABLE";
case CL_INVALID_IMAGE_DESCRIPTOR: return "INVALID_IMAGE_DESCRIPTOR";
case CL_INVALID_COMPILER_OPTIONS: return "INVALID_COMPILER_OPTIONS";
case CL_INVALID_LINKER_OPTIONS: return "INVALID_LINKER_OPTIONS";
case CL_INVALID_DEVICE_PARTITION_COUNT: return "INVALID_DEVICE_PARTITION_COUNT";
#endif
#ifdef CL_VERSION_2_0
case CL_INVALID_PIPE_SIZE: return "INVALID_PIPE_SIZE";
case CL_INVALID_DEVICE_QUEUE: return "INVALID_DEVICE_QUEUE";
#endif
#ifdef CL_VERSION_2_2
case CL_INVALID_SPEC_ID: return "INVALID_SPEC_ID";
case CL_MAX_SIZE_RESTRICTION_EXCEEDED: return "MAX_SIZE_RESTRICTION_EXCEEDED";
#endif
}
return "???????";
}
Reference in a new issue View git blame Copy permalink