xacc_util_cl.c File Reference

#include "xmp_internal.h"
#include "xacc_internal.h"
#include <sys/stat.h>
#include "../../libacc/include/openacc.h"
#include "xacc_util_cl_kernel.hex"

Include dependency graph for xacc_util_cl.c:

Macros
#define	KERNEL_FUNCTIONS
#define	DEF_ENUM(...)   enum {__VA_ARGS__, _XACC_num_kernels};
#define	DEF_STRARRAY(...)   const static char *_kernel_names[] = {__VA_ARGS__};
#define	NAME(s)   s
#define	NAME(s)   #s
#define	CHECK_MULTIPLE(size, base)   if(size % base != 0){_XACC_fatal(#size " is not a multiple of " #base);}

Functions
void	_XACC_queue_create (_XACC_queue_t *queue)
void	_XACC_queue_destroy (_XACC_queue_t *queue)
void	_XACC_queue_wait (_XACC_queue_t queue)
void	_XACC_memory_alloc (_XACC_memory_t *memory, size_t size)
void	_XACC_memory_free (_XACC_memory_t *memory)
void	_XACC_memory_read (void *addr, _XACC_memory_t memory, size_t memory_offset, size_t size, _XACC_queue_t queue, bool is_blocking)
void	_XACC_memory_write (_XACC_memory_t memory, size_t memory_offset, void *addr, size_t size, _XACC_queue_t queue, bool is_blocking)
void	_XACC_memory_copy (_XACC_memory_t dst_memory, size_t dst_memory_offset, _XACC_memory_t src_memory, size_t src_memory_offset, size_t size, _XACC_queue_t queue, bool is_blocking)
void *	_XACC_memory_get_address (_XACC_memory_t memory)
void	_XACC_host_malloc (void **ptr, size_t size)
void	_XACC_host_free (void **ptr)
void	create_kernels (cl_kernel kernels[], cl_program program, int num_kernels, const char *kernel_names[])
void	_XACC_util_init ()
void	_XACC_memory_pack_vector (_XACC_memory_t dst_mem, size_t dst_offset, _XACC_memory_t src_mem, size_t src_offset, size_t blocklength, size_t stride, size_t count, size_t typesize, _XACC_queue_t queue, bool is_blocking)
void	_XACC_memory_unpack_vector (_XACC_memory_t dst_mem, size_t dst_offset, _XACC_memory_t src_mem, size_t src_offset, size_t blocklength, size_t stride, size_t count, size_t typesize, _XACC_queue_t queue, bool is_blocking)
void	_XACC_memory_pack_vector2 (_XACC_memory_t dst0_mem, size_t dst0_offset, _XACC_memory_t src0_mem, size_t src0_offset, size_t blocklength0, size_t stride0, size_t count0, _XACC_memory_t dst1_mem, size_t dst1_offset, _XACC_memory_t src1_mem, size_t src1_offset, size_t blocklength1, size_t stride1, size_t count1, size_t typesize, _XACC_queue_t queue, bool is_blocking)
void	_XACC_memory_unpack_vector2 (_XACC_memory_t dst0_mem, size_t dst0_offset, _XACC_memory_t src0_mem, size_t src0_offset, size_t blocklength0, size_t stride0, size_t count0, _XACC_memory_t dst1_mem, size_t dst1_offset, _XACC_memory_t src1_mem, size_t src1_offset, size_t blocklength1, size_t stride1, size_t count1, size_t typesize, _XACC_queue_t queue, bool is_blocking)

Macro Definition Documentation

CHECK_MULTIPLE

#define CHECK_MULTIPLE	(		size,
			base
	)		if(size % base != 0){_XACC_fatal(#size " is not a multiple of " #base);}

DEF_ENUM

#define DEF_ENUM

(

...

)

enum {__VA_ARGS__, _XACC_num_kernels};

DEF_STRARRAY

#define DEF_STRARRAY

(

...

)

const static char *_kernel_names[] = {__VA_ARGS__};

KERNEL_FUNCTIONS

#define KERNEL_FUNCTIONS

Value:

    NAME(_XACC_pack_vector_8),\
    NAME(_XACC_pack_vector_16),\
    NAME(_XACC_pack_vector_32),\
    NAME(_XACC_pack_vector_64),\
    NAME(_XACC_unpack_vector_8),\
    NAME(_XACC_unpack_vector_16),\
    NAME(_XACC_unpack_vector_32),\
    NAME(_XACC_unpack_vector_64)

NAME [1/2]

#define NAME

(

s

)

s

NAME [2/2]

#define NAME

(

s

)

#s

Function Documentation

_XACC_host_free()

void _XACC_host_free

(

void **

ptr

)

{
    _XMP_free(*ptr);
    *ptr = NULL;
}

Here is the call graph for this function:

_XACC_host_malloc()

void _XACC_host_malloc	(	void **	ptr,
		size_t	size
	)

{
    *ptr = _XMP_alloc(size);
}

Here is the call graph for this function:

_XACC_memory_alloc()

void _XACC_memory_alloc	(	_XACC_memory_t *	memory,
		size_t	size
	)

{
    cl_int ret;
    cl_context context = (cl_context)acc_get_current_opencl_context();
 
    cl_mem mem = clCreateBuffer(context, CL_MEM_READ_WRITE, size, NULL, &ret);
    CL_CHECK(ret);
 
    XACC_DEBUG("alloc %p, %zd", mem, size);
    *memory = mem;
}

_XACC_memory_copy()

void _XACC_memory_copy	(	_XACC_memory_t	dst_memory,
		size_t	dst_memory_offset,
		_XACC_memory_t	src_memory,
		size_t	src_memory_offset,
		size_t	size,
		_XACC_queue_t	queue,
		bool	is_blocking
	)

{
    CL_CHECK(clEnqueueCopyBuffer(queue, src_memory, dst_memory, src_memory_offset, dst_memory_offset, size, 0 /*num_wait_ev*/, NULL /*wait_ev_list*/, NULL /*ev*/));
 
    if(is_blocking){
        _XACC_queue_wait(queue);
    }
}

Here is the call graph for this function:

_XACC_memory_free()

void _XACC_memory_free

(

_XACC_memory_t *

memory

)

{
    if(*memory == NULL) return;
 
    XACC_DEBUG("free %p\n", *memory);
    CL_CHECK(clReleaseMemObject(*memory));
    *memory = NULL;
}

_XACC_memory_get_address()

void* _XACC_memory_get_address

(

_XACC_memory_t

memory

)

{
    _XACC_fatal("cannot get raw address in OpenCL");
    return NULL; //dummy
}

_XACC_memory_pack_vector()

void _XACC_memory_pack_vector	(	_XACC_memory_t	dst_mem,
		size_t	dst_offset,
		_XACC_memory_t	src_mem,
		size_t	src_offset,
		size_t	blocklength,
		size_t	stride,
		size_t	count,
		size_t	typesize,
		_XACC_queue_t	queue,
		bool	is_blocking
	)

{
    XACC_DEBUG("pack_vector, dst=%p, dst_off=%zd, src=%p, src_off=%zd, blklen=%zd, stride=%zd, count=%zd, typesize=%zd, queue=%p, is_blocking=%d\n",
               dst_mem, dst_offset, src_mem, src_offset, blocklength, stride, count, typesize, queue, is_blocking);
 
    const int numThreads = 128; //must be 2^n
 
    CHECK_MULTIPLE(blocklength, typesize);
    CHECK_MULTIPLE(stride, typesize);
    CHECK_MULTIPLE(dst_offset, typesize);
    CHECK_MULTIPLE(src_offset, typesize);
    size_t blocklength_e = blocklength / typesize;
    size_t stride_e = stride / typesize;
    size_t dst_offset_e = dst_offset / typesize;
    size_t src_offset_e = src_offset / typesize;
 
#ifdef _XMP_XACC_PZCL
    const int max_num_threads = 8192;
    int num_threads = ADJUST_GLOBAL_WORK_SIZE(blocklength_e * count); //MIN(blocklength_e * count, max_num_threads);
 
    cl_uint work_dim = 1;
    size_t global_work_size[] = {num_threads};
    size_t local_work_size[] = {8};
 
    if(global_work_size[0] > 8192 || global_work_size[0] % 128 != 0){
      _XMP_fatal("invalid global_work_size at pack vector");
    }
#else
    int bx = 1, by;
    int tx = 1, ty;
    if(blocklength_e >= numThreads){
        tx = numThreads;
    }else{
        while(tx < blocklength_e){
            tx <<= 1;
        }
    }
    ty = numThreads / tx;
    by = (count-1)/ty + 1;
 
    cl_uint work_dim = 2;
    size_t global_work_size[] = {bx*tx, by*ty};
    size_t local_work_size[] = {tx, ty};
#endif
 
    void *args[] = {&dst_mem, &dst_offset_e, &src_mem, &src_offset_e, &blocklength_e, &stride_e, &count};
    size_t arg_sizes[] = {sizeof(dst_mem), sizeof(dst_offset_e), sizeof(src_mem), sizeof(src_offset_e), sizeof(blocklength_e), sizeof(stride_e), sizeof(count)};
 
    switch(typesize){
    case 1:
        XACC_DEBUG("pack_vector_8\n");
        enqueue_kernel(queue, _kernels[_XACC_pack_vector_8], 7, args, arg_sizes, work_dim, global_work_size, local_work_size);
        break;
    case 2:
        XACC_DEBUG("pack_vector_16\n");
        enqueue_kernel(queue, _kernels[_XACC_pack_vector_16], 7, args, arg_sizes, work_dim, global_work_size, local_work_size);
        break;
    case 4:
        XACC_DEBUG("pack_vector_32\n");
        enqueue_kernel(queue, _kernels[_XACC_pack_vector_32], 7, args, arg_sizes, work_dim, global_work_size, local_work_size);
        break;
    case 8:
        XACC_DEBUG("pack_vector_64\n");
        enqueue_kernel(queue, _kernels[_XACC_pack_vector_64], 7, args, arg_sizes, work_dim, global_work_size, local_work_size);
        break;
    default:
        {
            void *args_default[] = {&dst_mem, &dst_offset, &src_mem, &src_offset, &blocklength, &stride, &count};
            size_t arg_sizes_default[] = {sizeof(dst_mem), sizeof(dst_offset), sizeof(src_mem), sizeof(src_offset), sizeof(blocklength), sizeof(stride), sizeof(count)};
 
            XACC_DEBUG("pack_vector_default\n");
            enqueue_kernel(queue, _kernels[_XACC_pack_vector_8], 7, args_default, arg_sizes_default, work_dim, global_work_size, local_work_size);
        }
    }
}

Here is the call graph for this function:

_XACC_memory_pack_vector2()

void _XACC_memory_pack_vector2	(	_XACC_memory_t	dst0_mem,
		size_t	dst0_offset,
		_XACC_memory_t	src0_mem,
		size_t	src0_offset,
		size_t	blocklength0,
		size_t	stride0,
		size_t	count0,
		_XACC_memory_t	dst1_mem,
		size_t	dst1_offset,
		_XACC_memory_t	src1_mem,
		size_t	src1_offset,
		size_t	blocklength1,
		size_t	stride1,
		size_t	count1,
		size_t	typesize,
		_XACC_queue_t	queue,
		bool	is_blocking
	)

{
}

_XACC_memory_read()

void _XACC_memory_read	(	void *	addr,
		_XACC_memory_t	memory,
		size_t	memory_offset,
		size_t	size,
		_XACC_queue_t	queue,
		bool	is_blocking
	)

{
    cl_bool is_blocking_cl = is_blocking? CL_TRUE : CL_FALSE;
 
    XACC_DEBUG("clEnqueueReadBuffer(cq=%p, mem=%p, blocking=%d, offset=%zd, size=%zd, addr=%p)", queue, memory, is_blocking_cl, memory_offset, size, addr);
    CL_CHECK(clEnqueueReadBuffer(queue, memory, is_blocking_cl, memory_offset, size, addr,
                                 0 /*num_wait_ev*/, NULL /*wait_ev_list*/, NULL /*ev*/));
}

_XACC_memory_unpack_vector()

void _XACC_memory_unpack_vector	(	_XACC_memory_t	dst_mem,
		size_t	dst_offset,
		_XACC_memory_t	src_mem,
		size_t	src_offset,
		size_t	blocklength,
		size_t	stride,
		size_t	count,
		size_t	typesize,
		_XACC_queue_t	queue,
		bool	is_blocking
	)

{
    XACC_DEBUG("unpack_vector, dst=%p, dst_off=%zd, src=%p, src_off=%zd, blklen=%zd, stride=%zd, count=%zd, typesize=%zd, queue=%p, is_blocking=%d\n",
               dst_mem, dst_offset, src_mem, src_offset, blocklength, stride, count, typesize, queue, is_blocking);
 
    const int numThreads = 128; //must be 2^n
 
    CHECK_MULTIPLE(blocklength, typesize);
    CHECK_MULTIPLE(stride, typesize);
    CHECK_MULTIPLE(dst_offset, typesize);
    CHECK_MULTIPLE(src_offset, typesize);
    size_t blocklength_e = blocklength / typesize;
    size_t stride_e = stride / typesize;
    size_t dst_offset_e = dst_offset / typesize;
    size_t src_offset_e = src_offset / typesize;
 
#ifdef _XMP_XACC_PZCL
    const int max_num_threads = 8192;
    int num_threads = ADJUST_GLOBAL_WORK_SIZE(blocklength_e * count); //MIN(blocklength_e * count, max_num_threads);
 
    cl_uint work_dim = 1;
    size_t global_work_size[] = {num_threads};
    size_t local_work_size[] = {8};
 
    if(global_work_size[0] > 8192 || global_work_size[0] % 128 != 0){
      _XMP_fatal("invalid global_work_size at unpack vector");
    }
#else
    int bx = 1, by;
    int tx = 1, ty;
 
    if(blocklength_e >= numThreads){
        tx = numThreads;
    }else{
        while(tx < blocklength_e){
            tx <<= 1;
        }
    }
    ty = numThreads / tx;
    by = (count-1)/ty + 1;
 
    cl_uint work_dim = 2;
    size_t global_work_size[] = {bx*tx, by*ty};
    size_t local_work_size[] = {tx, ty};
#endif
 
    void *args[] = {&dst_mem, &dst_offset_e, &src_mem, &src_offset_e, &blocklength_e, &stride_e, &count};
    size_t arg_sizes[] = {sizeof(dst_mem), sizeof(dst_offset_e), sizeof(src_mem), sizeof(src_offset_e), sizeof(blocklength_e), sizeof(stride_e), sizeof(count)};
 
    switch(typesize){
    case 1:
        XACC_DEBUG("unpack_vector_8\n");
        enqueue_kernel(queue, _kernels[_XACC_unpack_vector_8], 7, args, arg_sizes, work_dim, global_work_size, local_work_size);
        break;
    case 2:
        XACC_DEBUG("unpack_vector_16\n");
        enqueue_kernel(queue, _kernels[_XACC_unpack_vector_16], 7, args, arg_sizes, work_dim, global_work_size, local_work_size);
        break;
    case 4:
        XACC_DEBUG("unpack_vector_32\n");
        enqueue_kernel(queue, _kernels[_XACC_unpack_vector_32], 7, args, arg_sizes, work_dim, global_work_size, local_work_size);
        break;
    case 8:
        XACC_DEBUG("unpack_vector_64\n");
        enqueue_kernel(queue, _kernels[_XACC_unpack_vector_64], 7, args, arg_sizes, work_dim, global_work_size, local_work_size);
        break;
    default:
        {
            void *args_default[] = {&dst_mem, &dst_offset, &src_mem, &src_offset, &blocklength, &stride, &count};
            size_t arg_sizes_default[] = {sizeof(dst_mem), sizeof(dst_offset), sizeof(src_mem), sizeof(src_offset), sizeof(blocklength), sizeof(stride), sizeof(count)};
 
            XACC_DEBUG("unpack_vector_default\n");
            enqueue_kernel(queue, _kernels[_XACC_unpack_vector_8], 7, args_default, arg_sizes_default, work_dim, global_work_size, local_work_size);
        }
    }
}

Here is the call graph for this function:

_XACC_memory_unpack_vector2()

void _XACC_memory_unpack_vector2	(	_XACC_memory_t	dst0_mem,
		size_t	dst0_offset,
		_XACC_memory_t	src0_mem,
		size_t	src0_offset,
		size_t	blocklength0,
		size_t	stride0,
		size_t	count0,
		_XACC_memory_t	dst1_mem,
		size_t	dst1_offset,
		_XACC_memory_t	src1_mem,
		size_t	src1_offset,
		size_t	blocklength1,
		size_t	stride1,
		size_t	count1,
		size_t	typesize,
		_XACC_queue_t	queue,
		bool	is_blocking
	)

{
}

_XACC_memory_write()

void _XACC_memory_write	(	_XACC_memory_t	memory,
		size_t	memory_offset,
		void *	addr,
		size_t	size,
		_XACC_queue_t	queue,
		bool	is_blocking
	)

{
    cl_bool is_blocking_cl = is_blocking? CL_TRUE : CL_FALSE;
 
    XACC_DEBUG("clEnqueueWriteBuffer(cq=%p, mem=%p, blocking=%d, offset=%zd, size=%zd, addr=%p)", queue, memory, is_blocking_cl, memory_offset, size, addr);
    CL_CHECK(clEnqueueWriteBuffer(queue, memory, is_blocking_cl, memory_offset, size, addr,
                                  0 /*num_wait_ev*/, NULL /*wait_ev_list*/, NULL /*ev*/));
}

_XACC_queue_create()

void _XACC_queue_create

(

_XACC_queue_t *

queue

)

{
    cl_int ret;
#ifdef _XMP_XACC_PZCL
    *queue = (cl_command_queue)acc_get_opencl_queue(ACC_ASYNC_SYNC);
#else
    cl_context context = (cl_context)acc_get_current_opencl_context();
    cl_device_id device_id = (cl_device_id)acc_get_current_opencl_device();
 
    cl_command_queue command_queue = clCreateCommandQueue(context, device_id, 0 /*prop*/, &ret);
    CL_CHECK(ret);
 
    XACC_DEBUG("queue create %p", command_queue);
    *queue = command_queue;
#endif
}

_XACC_queue_destroy()

void _XACC_queue_destroy

(

_XACC_queue_t *

queue

)

{
#ifndef _XMP_XACC_PZCL
    XACC_DEBUG("queue destroy %p", *queue);
    CL_CHECK(clFinish(*queue));
    CL_CHECK(clReleaseCommandQueue(*queue));
#endif
    *queue = NULL;
}

_XACC_queue_wait()

void _XACC_queue_wait

(

_XACC_queue_t

queue

)

{
    CL_CHECK(clFinish(queue));
}

Here is the caller graph for this function:

_XACC_util_init()

void _XACC_util_init

(

)

{
    // _program = create_and_build_program_from_file("util.cl");
    _program = create_and_build_program((char*)_kernel_src, strlen((char*)_kernel_src));
 
    create_kernels(_kernels, _program, _XACC_num_kernels, _kernel_names);
}

create_kernels()

void create_kernels	(	cl_kernel	kernels[],
		cl_program	program,
		int	num_kernels,
		const char *	kernel_names[]
	)

{
    cl_int ret;
    //create kernels
    for(int i = 0; i < num_kernels; i++){
        XACC_DEBUG("create kernel \"%s\"\n", kernel_names[i]);
        kernels[i] = clCreateKernel(program, kernel_names[i], &ret);
        CL_CHECK(ret);
    }
}