ibuffer::ibuffer(const device &device, const vk::BufferUsageFlags flags, const void *data, const size_t size)
: device_(device), size_(size)
{
handle_ = device.create_buffer(
vk::BufferCreateInfo()
.size(static_cast<vk::DeviceSize>(size))
.usage(flags));
gpumem_ = gpu_memory(
device,
device.get_buffer_memory_requirements(handle_),
vk::MemoryPropertyFlagBits::eHostVisible,
data);
device.bind_buffer_memory(handle_, gpumem_.handle(), 0);
}
static void hpxcl_single_initialize( hpx::naming::id_type node_id,
size_t vector_size)
{
// Query all devices on local node
std::vector<device> devices = get_devices( node_id,
CL_DEVICE_TYPE_GPU,
"OpenCL 1.1" ).get();
/*
// print devices
hpx::cout << "Devices:" << hpx::endl;
for(cl_uint i = 0; i < devices.size(); i++)
{
device cldevice = devices[i];
// Query name
std::string device_name = device::device_info_to_string(
cldevice.get_device_info(CL_DEVICE_NAME));
std::string device_vendor = device::device_info_to_string(
cldevice.get_device_info(CL_DEVICE_VENDOR));
hpx::cout << i << ": " << device_name << " (" << device_vendor << ")"
<< hpx::endl;
}
// Lets you choose a device
size_t device_num;
hpx::cout << "Choose device: " << hpx::endl;
std::cin >> device_num;
if(device_num < 0 || device_num >= devices.size())
exit(0);
// Select a device
hpxcl_single_device = devices[device_num];
*/
size_t device_id = 0;
// print device
hpx::cout << "Device:" << hpx::endl;
{
device cldevice = devices[device_id];
// Query name
std::string device_name = device::device_info_to_string(
cldevice.get_device_info(CL_DEVICE_NAME));
std::string device_vendor = device::device_info_to_string(
cldevice.get_device_info(CL_DEVICE_VENDOR));
hpx::cout << " " << device_name << " (" << device_vendor << ")"
<< hpx::endl;
}
// Select a device
hpxcl_single_device = devices[device_id];
// Create program
hpxcl_single_program = hpxcl_single_device.create_program_with_source(
gpu_code);
// Build program
hpxcl_single_program.build();
// Create kernels
hpxcl_single_log_kernel = hpxcl_single_program.create_kernel("logn");
hpxcl_single_exp_kernel = hpxcl_single_program.create_kernel("expn");
hpxcl_single_mul_kernel = hpxcl_single_program.create_kernel("mul");
hpxcl_single_add_kernel = hpxcl_single_program.create_kernel("add");
hpxcl_single_dbl_kernel = hpxcl_single_program.create_kernel("dbl");
// Generate buffers
hpxcl_single_buffer_a = hpxcl_single_device.create_buffer(
CL_MEM_READ_ONLY,
vector_size * sizeof(float));
hpxcl_single_buffer_b = hpxcl_single_device.create_buffer(
CL_MEM_READ_ONLY,
vector_size * sizeof(float));
hpxcl_single_buffer_c = hpxcl_single_device.create_buffer(
CL_MEM_READ_ONLY,
vector_size * sizeof(float));
hpxcl_single_buffer_m = hpxcl_single_device.create_buffer(
CL_MEM_READ_WRITE,
vector_size * sizeof(float));
hpxcl_single_buffer_n = hpxcl_single_device.create_buffer(
CL_MEM_READ_WRITE,
vector_size * sizeof(float));
hpxcl_single_buffer_o = hpxcl_single_device.create_buffer(
CL_MEM_READ_WRITE,
vector_size * sizeof(float));
hpxcl_single_buffer_p = hpxcl_single_device.create_buffer(
CL_MEM_READ_WRITE,
vector_size * sizeof(float));
hpxcl_single_buffer_z = hpxcl_single_device.create_buffer(
CL_MEM_WRITE_ONLY,
vector_size * sizeof(float));
// Initialize a list of future events for asynchronous set_arg calls
std::vector<shared_future<void>> set_arg_futures;
// set kernel args for exp
set_arg_futures.push_back(
hpxcl_single_exp_kernel.set_arg_async(0, hpxcl_single_buffer_m));
set_arg_futures.push_back(
hpxcl_single_exp_kernel.set_arg_async(1, hpxcl_single_buffer_b));
// set kernel args for add
set_arg_futures.push_back(
hpxcl_single_add_kernel.set_arg_async(0, hpxcl_single_buffer_n));
set_arg_futures.push_back(
hpxcl_single_add_kernel.set_arg_async(1, hpxcl_single_buffer_a));
set_arg_futures.push_back(
hpxcl_single_add_kernel.set_arg_async(2, hpxcl_single_buffer_m));
// set kernel args for dbl
set_arg_futures.push_back(
hpxcl_single_dbl_kernel.set_arg_async(0, hpxcl_single_buffer_o));
set_arg_futures.push_back(
hpxcl_single_dbl_kernel.set_arg_async(1, hpxcl_single_buffer_c));
// set kernel args for mul
set_arg_futures.push_back(
hpxcl_single_mul_kernel.set_arg_async(0, hpxcl_single_buffer_p));
set_arg_futures.push_back(
hpxcl_single_mul_kernel.set_arg_async(1, hpxcl_single_buffer_n));
set_arg_futures.push_back(
hpxcl_single_mul_kernel.set_arg_async(2, hpxcl_single_buffer_o));
// set kernel args for log
set_arg_futures.push_back(
hpxcl_single_log_kernel.set_arg_async(0, hpxcl_single_buffer_z));
set_arg_futures.push_back(
hpxcl_single_log_kernel.set_arg_async(1, hpxcl_single_buffer_p));
// wait for function calls to trigger
BOOST_FOREACH(shared_future<void> & future, set_arg_futures)
{
future.wait();
}
}
