vector * gpu_matrix_vector_sub_scalar(vector * v_x, double alpha) {
size_t datasize;
cl_int status;
vector * output;
cl_mem buffer_data_x;
vector_buffer buffer_v_x;
cl_command_queue cmd_queue;
cl_kernel kernel;
cl_event write_buffer_events[1],
read_buffer_events[1];
output = malloc(sizeof(vector));
output->length = v_x->length;
output->stride = 1;
output->data = malloc(sizeof(double) * v_x->length);
datasize = gpu_matrix_vector_datasize(v_x);
cmd_queue = clCreateCommandQueue(
context_get(),
device_get(),
CL_QUEUE_PROFILING_ENABLE,
&status
);
buffer_data_x = buffers_create(
CL_MEM_READ_WRITE,
datasize,
NULL,
&status
);
buffer_v_x = gpu_matrix_vector_to_vector_buffer(
v_x, buffer_data_x
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data_x,
CL_TRUE, 0, datasize,
v_x->data, 0, NULL, write_buffer_events
);
clWaitForEvents(1, write_buffer_events);
gpu_matrix_vector_buffer_sub_scalar_BANG(&buffer_v_x, alpha, cmd_queue);
// Print write buffer profilling information
status = clEnqueueReadBuffer(
cmd_queue,
buffer_data_x,
CL_TRUE,
0,
datasize,
output->data,
0,
NULL,
read_buffer_events
);
clReleaseMemObject(buffer_data_x);
clReleaseEvent(read_buffer_events[0]);
clReleaseEvent(write_buffer_events[0]);
return output;
}
/**
* Read from kernel.
*/
int read_kernel(int handle, void *buffer, int length)
{
KERNEL_ASSERT(handle == 0);
KERNEL_ASSERT(length >= strlen(buffer));
device_t *dev;
gcd_t *gcd;
int buf_len;
buf_len = 0;
dev = device_get(TYPECODE_TTY, 0);
KERNEL_ASSERT(dev != NULL);
gcd = (gcd_t *)dev->generic_device;
KERNEL_ASSERT(gcd != NULL);
while(stringcmp(buffer, "n") != 0){
buf_len = buf_len + gcd->read(gcd, buffer, length);
KERNEL_ASSERT(buf_len >= 0);
kwrite(buffer);
}
gcd->write(gcd, buffer, buf_len);
return buf_len;
}
static int devfs_stat(struct mount_entry __unused *mount, uid_t __unused uid,
gid_t __unused gid, ino_t inode, struct stat *stat)
{
if (inode == DEVFS_INODE_ROOT) {
stat->st_dev = -1;
stat->st_ino = DEVFS_INODE_ROOT;
stat->st_mode = VFS_FTYPE_DIR;
} else {
struct device *device;
device = device_get(inode);
if (!device)
return -EINVAL;
stat->st_dev = device->id;
stat->st_ino = device->id;
stat->st_mode = VFS_FTYPE_DEV;
}
/* XXX: Set correct values */
stat->st_nlink = 0;
stat->st_uid = 0;
stat->st_gid = 0;
stat->st_rdev = 0;
stat->st_size = 0;
stat->st_blksize = 0;
stat->st_blocks = 0;
stat->st_atime = 0;
stat->st_mtime = 0;
stat->st_ctime = 0;
return 0;
}
void do_mount() {
for(int i = 0; i < get_num_of_devices(); i++)
vfs_mount("/", device_get(i));
if (!vfs_root_mounted())
panic("unable to mount root directory\n");
}
void vfs_mount_all(void)
{
int i;
device_t *dev;
for(i=0; i<CONFIG_MAX_FILESYSTEMS; i++) {
dev = device_get(YAMS_TYPECODE_DISK, i);
if(dev == NULL) {
/* No more disks. */
return;
} else {
gbd_t *gbd;
gbd = (gbd_t *) dev->generic_device;
if(gbd == NULL) {
kprintf("VFS: Warning, invalid disk driver detected, "
"skipping\n");
continue;
}
vfs_mount_fs(gbd, NULL);
}
}
}
device_t *device_find(device_t *_where, fourcc_t _fcc, device_t *_dev)
{
LinkedList *root;
if(_where == NULL)
root = &device_list;
else
root = &_where->children;
LinkedList *ptr;
if(_dev == NULL)
{
if(_where == NULL)
ptr = device_list.next;
else
ptr = _where->children.next;
}
else
ptr = _dev->list_ptr.next;
while(ptr != root)
{
device_t *dev = device_get(ptr);
if(dev->fourcc == _fcc)
return dev;
ptr = ptr->next;
}
return NULL;
}
index_t gpu_matrix_vector_iamin(vector * v_x) {
size_t datasize = gpu_matrix_vector_datasize(v_x);
cl_int status;
index_t output;
cl_mem buffer_data, buffer_indices;
cl_command_queue cmd_queue;
cl_kernel kernel;
index_t remaining_length = v_x->length;
cl_event write_buffer_events[1],
read_buffer_events[1];
vector_buffer buffer_v_x;
cmd_queue = clCreateCommandQueue(
context_get(),
device_get(),
CL_QUEUE_PROFILING_ENABLE,
&status
);
buffer_data = buffers_create(
CL_MEM_READ_WRITE,
datasize,
NULL,
&status
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data,
CL_TRUE, 0, datasize,
v_x->data, 0, NULL, write_buffer_events
);
buffer_v_x = gpu_matrix_vector_to_vector_buffer(v_x, buffer_data);
gpu_matrix_vector_buffer_abs_BANG(&buffer_v_x, cmd_queue);
buffer_indices = gpu_matrix_vector_buffer_imin(&buffer_v_x, cmd_queue);
// Print write buffer profilling information
status = clEnqueueReadBuffer(
cmd_queue,
buffer_indices,
CL_TRUE,
0,
sizeof(index_t),
&output,
0,
NULL,
read_buffer_events
);
clReleaseMemObject(buffer_data);
clReleaseMemObject(buffer_indices);
clReleaseEvent(read_buffer_events[0]);
clReleaseEvent(write_buffer_events[0]);
return output;
}
static void adjustColour(byte* val)
{
// Adjust to sine level
*val = getSineVal(*val);
// Gamma correction
*val = (byte)(pow(*val / 255.0, GAMMA_CORRECTION) * 255);
// Adjust for brightness
*val = remap(*val, MIN_RGB_LEVEL, MAX_RGB_LEVEL, MIN_RGB_LEVEL, device_get()->brightness);
}
gcd_t* get_tty()
{
device_t *dev;
gcd_t *gcd;
/* Find system console (first tty) */
dev = device_get(YAMS_TYPECODE_TTY, 0);
KERNEL_ASSERT(dev != NULL);
gcd = (gcd_t *)dev->generic_device;
KERNEL_ASSERT(gcd != NULL);
return gcd;
}
gcd_t* get_gcd() {
device_t *dev;
gcd_t *gcd;
dev = device_get(YAMS_TYPECODE_TTY, 0);
KERNEL_ASSERT(dev != NULL);
gcd = (gcd_t *)dev->generic_device;
KERNEL_ASSERT(gcd != NULL);
return gcd;
}
int serial_con_write(struct file *fp, const char *buf, off_t off, size_t n)
{
struct device *devp;
size_t i;
if (!(devp = device_get(fp->dp->rdev)))
return -ENODEV;
for (i = 0; i < n; i++)
serial_con_put(*((u16 *) devp->device), buf[i]);
return n;
}
void gpu_matrix_vector_scal(vector * v_x, double alpha) {
size_t global_work_size[1] = { v_x->length };
vector * output;
size_t datasize = gpu_matrix_vector_datasize(v_x);
cl_int status;
cl_command_queue cmd_queue = clCreateCommandQueue(
context_get(),
device_get(),
CL_QUEUE_PROFILING_ENABLE,
&status
);
cl_event write_buffer_events[2], read_buffer_events[1], enqueue_events[1];
cl_mem buffer_x, buffer_y, buffer_output, buffer_local_cache;
vector_buffer buffer_v_x, buffer_v_y;
buffer_x = buffers_create(
CL_MEM_READ_ONLY,
datasize,
NULL,
&status
);
buffer_v_x = gpu_matrix_vector_to_vector_buffer(v_x, buffer_x);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_x,
CL_FALSE, 0, datasize,
v_x->data, 0, NULL, write_buffer_events
);
clWaitForEvents(1, write_buffer_events);
gpu_matrix_vector_buffer_scal_BANG(
&buffer_v_x,
alpha,
cmd_queue
);
clEnqueueReadBuffer(
cmd_queue,
buffer_x,
CL_TRUE,
0,
datasize,
v_x->data,
0,
NULL,
read_buffer_events
);
clReleaseEvent(write_buffer_events[0]);
clReleaseEvent(read_buffer_events[0]);
}
/* Writes length bytes from buffer to the open file identified by
filehandle, starting at the current position and advancing the
position. Returns the number of bytes actually written, or a
negative value on error. */
int syscall_write(uint32_t fd, char *s, int len)
{
gcd_t *gcd;
device_t *dev;
if (fd == FILEHANDLE_STDOUT || fd == FILEHANDLE_STDERR)
{
dev = device_get(YAMS_TYPECODE_TTY, 0);
gcd = (gcd_t *)dev->generic_device;
return gcd->write(gcd, s, len);
} else {
KERNEL_PANIC("Write syscall not finished yet.");
return 0;
}
}
/* returns the number of bytes written, or a negative value on error */
int syscall_write(int fhandle, const void *buffer, int length) {
fhandle = fhandle;
gcd_t *gcd;
device_t *dev;
dev = device_get(YAMS_TYPECODE_TTY, 0); //from init_startup_fallback
if (dev == NULL) //if error return negative value
return -1;
gcd = (gcd_t *)dev->generic_device; //from init_startup_fallback
if (gcd == NULL) //if error return negative value
return -1;
gcd->write(gcd, buffer, length); //from init_startup_fallback
return length;
}
gcd_t* get_tty(void)
{
device_t *dev;
gcd_t *gcd;
/* Find system console (first tty) */
dev = device_get(YAMS_TYPECODE_TTY, 0);
if (dev == NULL) {
return NULL;
}
gcd = (gcd_t *)dev->generic_device;
if (gcd == NULL) {
return NULL;
}
return gcd;
}
int write(int filehandle, const void *buffer, int length){
buffer = buffer;
if(length < 0){
return ERROR_NEGATIVE_LENGTH;
}
if(filehandle == 0){
return ERROR_CANNOT_WRITE_TO_FILE;
}
device_t *device;
gcd_t *gcd;
device = device_get(TYPECODE_TTY, 0);
KERNEL_ASSERT(device != NULL);
gcd = (gcd_t *) device->generic_device;
KERNEL_ASSERT(gcd != NULL);
int written = gcd->write(gcd, buffer, length);
return written;
}
int syscall_write(int filehandle, const void *buffer, int length) {
device_t *dev;
gcd_t *gcd;
if (filehandle != FILEHANDLE_STDOUT || length < 0)
return -1;
dev = device_get(YAMS_TYPECODE_TTY, 0);
if (dev == NULL)
return -1;
gcd = (gcd_t *)dev->generic_device;
if (gcd == NULL)
return -1;
length = gcd->write(gcd, buffer, length);
return length;
}
int syscall_write(int fhandle, const void *buffer, int length) {
if(fhandle == 1) {
device_t *dev;
gcd_t *gcd;
/* Skaffer device */
dev = device_get(YAMS_TYPECODE_TTY,0);
KERNEL_ASSERT(dev != NULL);
/* skaffer generisk device fra device */
gcd = (gcd_t *)dev->generic_device;
KERNEL_ASSERT(gcd != NULL);
/* iflg. drivers/gcd.h, skriver write, "at most len bytes from the buffer to the device. the function returns the number of bytes read." */
return gcd->write(gcd,buffer,length);
}
return -1;
}
static void cmd_device_list(int _argc, char **_argv)
{
LinkedList *ptr = device_list.next;
if(ptr == &device_list)
{
bufferPrintf("devices: No devices registered.\n");
return;
}
bufferPrintf("devices: Listing devices:\n");
while(ptr != &device_list)
{
device_t *dev = device_get(ptr);
bufferPrintf("devices: %s\n", dev->name);
ptr = ptr->next;
}
}
int syscall_write(int filehandle, void *buffer, int length) {
filehandle = filehandle;
device_t *dev;
gcd_t *gcd;
/* Find system console (first tty) */
dev = device_get(YAMS_TYPECODE_TTY, 0);
KERNEL_ASSERT(dev != NULL);
gcd = (gcd_t *)dev->generic_device;
KERNEL_ASSERT(gcd != NULL);
int lengthWritten = gcd->write(gcd, buffer, length);
lengthWritten += gcd->write(gcd, (void *)"\n", 1);
return lengthWritten + 1;
}
/* returns the number of bytes read before reaching the EOF
* or a negative value on error
*/
int syscall_read(int fhandle, void *buffer, int length) {
fhandle = fhandle;
gcd_t *gcd;
device_t *dev;
int len;
dev = device_get(YAMS_TYPECODE_TTY, 0); //from init_startup_fallback
if (dev == NULL) //if error return negative value
return -1;
gcd = (gcd_t *)dev->generic_device; //from init_startup_fallback
if (gcd == NULL) //if error return negative value
return -1;
len = gcd->read(gcd, buffer, length); //from init_startup_fallback
if (len < 0) //gcd->read function failed
return -1;
return len;
}
int write_file(int file_handle, const void *buffer, int length) {
device_t *dev;
gcd_t *gcd;
int len;
if (file_handle == FILEHANDLE_STDIN) {
return -1;
}
dev = device_get(YAMS_TYPECODE_TTY, 0);
KERNEL_ASSERT(dev != NULL);
gcd = (gcd_t *)dev->generic_device;
KERNEL_ASSERT(gcd != NULL);
len = gcd->write(gcd, buffer, length);
return len;
}
/* Verify parent MPU6000 exists */
static int mpu6000_accel_probe(const char *name) {
const void *blob = fdtparse_get_blob();
int offset, parent_offset, ret;
char *parent;
struct obj *parent_obj;
offset = fdt_path_offset(blob, name);
if (offset < 0) {
return 0;
}
if (fdt_node_check_compatible(blob, offset, MPU6000_ACCEL_COMPAT)) {
return 0;
}
parent_offset = fdt_parent_offset(blob, offset);
if (parent_offset < 0) {
return 0;
}
parent = fdtparse_get_path(blob, parent_offset);
if (!parent) {
return 0;
}
/* Attempt to get parent MPU6000 */
parent_obj = device_get(parent);
if (parent_obj) {
/* Found it! Good to go! */
device_put(parent_obj);
ret = 1;
}
else {
/* No MPU6000, no MPU6000 accelerometer */
ret = 0;
}
free(parent);
return ret;
}
void cmd_lsdev()
{
_printk("NAME TYPE\n");
for (int i = 0; i < get_num_of_devices(); i++) {
struct device *d = device_get(i);
if (!d) {
i --;
continue;
}
_printk("%s %s\n", d->name,
d->type == DEV_TYPE_TTY ? "[tty]"
: d->type == DEV_TYPE_PSEUDO ? "[pseudo]"
: d->type == DEV_TYPE_ISA ? "[isa]"
: d->type == DEV_TYPE_PCI ? "[pci]"
: d->type == DEV_TYPE_BLK ? "[blk]"
: d->type == DEV_TYPE_TTY_INPUT ? "[intty]"
: "[unktype]");
}
}
/**
* Fallback function for system startup. This function is executed
* if the initial startup program (shell or other userland process given
* with initprog boot argument) is not started or specified.
*
* This is a good place for some kernel test code!
*
*/
void init_startup_fallback(void)
{
DEBUG("debuginit", "In init_startup_fallback\n");
/* Run console test if "testconsole" was given as boot argument. */
if (bootargs_get("testconsole") != NULL)
{
device_t *dev;
gcd_t *gcd;
char buffer[64];
char buffer2[64];
int len;
DEBUG("debuginit", "In console test\n");
/* Find system console (first tty) */
dev = device_get(YAMS_TYPECODE_TTY, 0);
KERNEL_ASSERT(dev != NULL);
gcd = (gcd_t *)dev->generic_device;
KERNEL_ASSERT(gcd != NULL);
len = snprintf(buffer, 63, "Hello user! Press any key.\n");
gcd->write(gcd, buffer, len);
len = gcd->read(gcd, buffer2, 63);
KERNEL_ASSERT(len >= 0);
buffer2[len] = '\0';
len = snprintf(buffer, 63, "You said: '%s'\n", buffer2);
gcd->write(gcd, buffer, len);
DEBUG("debuginit", "Console test done, %d bytes written\n", len);
}
/* Nothing else to do, so we shut the system down. */
kprintf("Startup fallback code ends.\n");
halt_kernel();
}
void signal_usr(int sd, struct mosquitto *mosq)
{
struct device *md_dev;
struct module *md;
char md_id[DEVICE_MD_ID_SIZE + 1];
if (user_signal == MODULE_SIGUSR1) {
if (config.remap_usr1)
strcpy(md_id, config.remap_usr1);
else
strcpy(md_id, MODULE_SIGUSR1_ID);
}
else if (user_signal == MODULE_SIGUSR2) {
if (config.remap_usr2)
strcpy(md_id, config.remap_usr2);
else
strcpy(md_id, MODULE_SIGUSR2_ID);
}
md = device_get_module(&bridge, md_id);
if (md) {
md_dev = device_get(&bridge, md->device);
if (!md_dev) {
fprintf(stderr, "Error: Orphan module.\n");
device_remove_module(&bridge, md_id);
user_signal = 0;
return;
}
if (md_dev->md_deps->type == MODULE_SERIAL && bridge.serial_ready) {
snprintf(gbuf, GBUF_SIZE, "%s%s,%d,%s", SERIAL_INIT_MSG, md_dev->id, PROTO_MD_RAW, md->id);
serialport_printlf(sd, gbuf);
}
if (connected)
mqtt_publish(mosq, md->topic, "1");
}
user_signal = 0;
}
int syscall_read(int fhandle, void *buffer, int length) {
if(fhandle == 0) {
device_t *dev;
gcd_t *gcd;
/* Skaffer device */
dev = device_get(YAMS_TYPECODE_TTY,0);
KERNEL_ASSERT(dev != NULL);
/* skaffer generisk device fra device */
gcd = (gcd_t *)dev->generic_device;
KERNEL_ASSERT(gcd != NULL);
/* iflg. drivers/gcd.h, læser read, "at most len bytes from the device to the buffer. the function returns the number of bytes read." */
return gcd->read(gcd,buffer,length);
}
return -1;
/*int tmp = fhandle;
int tmp2 =(int) buffer;
int tmp3 = length; */
}
vector * gpu_matrix_vector_add_arbitary(unsigned count, vector * arr_v[]) {
if (count == 1) {
return gpu_matrix_vector_copy(arr_v[0]);
} else if (count == 0) {
// Have fun mingling with the NULL pointer
return NULL;
}
size_t datasize;
cl_int status;
vector * output;
cl_mem buffer_data;
cl_command_queue cmd_queue;
cl_kernel kernel;
cl_event write_buffer_events_arr[10];
cl_event *write_buffer_events,
read_buffer_events[1];
vector_buffer buffer_v_this;
if (count < 10) {
write_buffer_events = write_buffer_events_arr;
} else {
write_buffer_events = malloc(sizeof(cl_event) * count);
}
// increate write_buffer_events and read_buffer_events if count is not enough
output = malloc(sizeof(vector));
output->length = arr_v[0]->length;
output->stride = 1;
output->data = malloc(sizeof(double) * arr_v[0]->length);
datasize = gpu_matrix_vector_datasize(arr_v[0]);
cmd_queue = clCreateCommandQueue(
context_get(),
device_get(),
CL_QUEUE_PROFILING_ENABLE,
&status
);
buffer_data = buffers_create(
CL_MEM_READ_WRITE,
datasize,
NULL,
&status
);
buffer_v_this = gpu_matrix_vector_to_vector_buffer(
arr_v[0], buffer_data
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data,
CL_TRUE, 0, datasize,
arr_v[0]->data, 0, NULL, write_buffer_events
);
clWaitForEvents(1, write_buffer_events);
clReleaseEvent(write_buffer_events[0]);
// Naive implementation, Improvements later
for (unsigned i = 1 ; i < count ; i++) {
cl_mem buffer_data_next;
vector_buffer buffer_v_next;
buffer_data_next = buffers_create(
CL_MEM_READ_ONLY,
datasize,
NULL,
&status
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data_next,
CL_TRUE, 0 ,datasize,
arr_v[i]->data, 0, NULL, write_buffer_events+i
);
buffer_v_next = gpu_matrix_vector_to_vector_buffer(
arr_v[i], buffer_data_next
);
clWaitForEvents(1, write_buffer_events+i);
gpu_matrix_vector_buffer_add_BANG(&buffer_v_this, &buffer_v_next, cmd_queue);
clReleaseEvent(write_buffer_events[i]);
clReleaseMemObject(buffer_data_next);
}
// Print write buffer profilling information
status = clEnqueueReadBuffer(
cmd_queue,
buffer_data,
CL_TRUE,
0,
datasize,
output->data,
0,
NULL,
read_buffer_events
);
clReleaseMemObject(buffer_data);
clReleaseEvent(read_buffer_events[0]);
if (count >= 10) {
free(write_buffer_events);
}
return output;
}
double gpu_matrix_vector_dot(vector * v_x, vector * v_y) {
size_t datasize = gpu_matrix_vector_datasize(v_x);
size_t global_work_size[1];
cl_int status;
double output;
cl_mem buffer_data_output, buffer_data_x, buffer_data_y;
vector_buffer buffer_v_x, buffer_v_y;
cl_command_queue cmd_queue;
cl_event write_buffer_events[2],
read_buffer_events[1];
datasize = gpu_matrix_vector_datasize(v_x);
global_work_size[0] = v_x->length;
cmd_queue = clCreateCommandQueue(
context_get(),
device_get(),
CL_QUEUE_PROFILING_ENABLE,
&status
);
buffer_data_x = buffers_create(
CL_MEM_READ_WRITE,
datasize,
NULL,
&status
);
buffer_v_x = gpu_matrix_vector_to_vector_buffer(v_x, buffer_data_x);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data_x,
CL_FALSE, 0, datasize,
v_x->data, 0, NULL,
write_buffer_events
);
buffer_data_y = buffers_create(
CL_MEM_READ_ONLY,
datasize,
NULL,
&status
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data_y,
CL_FALSE, 0, datasize,
v_y->data, 0, NULL,
write_buffer_events+1
);
buffer_v_y = gpu_matrix_vector_to_vector_buffer(v_y, buffer_data_y);
clWaitForEvents(2, write_buffer_events);
gpu_matrix_vector_buffer_mul_BANG(&buffer_v_x, &buffer_v_y, cmd_queue);
gpu_matrix_vector_buffer_asum_BANG(&buffer_v_x, cmd_queue);
clEnqueueReadBuffer(
cmd_queue,
buffer_v_x.buffer,
CL_TRUE,
0,
sizeof(double),
&output,
0,
NULL,
read_buffer_events
);
clWaitForEvents(1, read_buffer_events);
// Release buffer objects
clReleaseMemObject(buffer_v_x.buffer);
clReleaseEvent(read_buffer_events[0]);
clReleaseEvent(write_buffer_events[0]);
clReleaseEvent(write_buffer_events[1]);
return output;
}
void gpu_matrix_vector_rot(
vector * v_x,
vector * v_y,
double c,
double s
){
cl_kernel kernel;
cl_command_queue cmd_queue;
cl_int status;
cl_event read_buffer_events[2], write_buffer_events[2];
size_t datasize = gpu_matrix_vector_datasize(v_x);
cl_mem buffer_data_x, buffer_data_y;
vector_buffer buffer_v_x, buffer_v_y;
cmd_queue = clCreateCommandQueue(
context_get(),
device_get(),
CL_QUEUE_PROFILING_ENABLE,
&status
);
buffer_data_x = buffers_create(
CL_MEM_READ_WRITE,
datasize,
NULL,
&status
);
buffer_data_y = buffers_create(
CL_MEM_READ_WRITE,
datasize,
NULL,
&status
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data_x,
CL_FALSE, 0, datasize,
v_x->data, 0, NULL,
write_buffer_events
);
status = clEnqueueWriteBuffer(
cmd_queue, buffer_data_y,
CL_FALSE, 0, datasize,
v_y->data, 0, NULL,
write_buffer_events+1
);
clWaitForEvents(2, write_buffer_events);
buffer_v_x = gpu_matrix_vector_to_vector_buffer(v_x, buffer_data_x);
buffer_v_y = gpu_matrix_vector_to_vector_buffer(v_x, buffer_data_y);
gpu_matrix_vector_buffer_rot_BANG(&buffer_v_x, &buffer_v_y, c, s, cmd_queue);
status = clEnqueueReadBuffer(
cmd_queue,
buffer_v_x.buffer,
CL_TRUE,
0,
datasize,
v_x->data,
0,
NULL,
read_buffer_events
);
status = clEnqueueReadBuffer(
cmd_queue,
buffer_v_y.buffer,
CL_TRUE,
0,
datasize,
v_y->data,
0,
NULL,
read_buffer_events+1
);
clWaitForEvents(2, read_buffer_events);
}
