File kernel.h

Kernel functions.

Functions

int GpuKernel_init(GpuKernel *k, gpucontext *ctx, unsigned int count, const char **strs, const size_t *lens, const char *name, unsigned int argcount, const int *types, int flags, char **err_str)

Initialize a kernel structure.

lens holds the size of each source string. If is it NULL or an element has a value of 0 the length will be determined using strlen() or equivalent code.

If

*err_str is returned not NULL then it must be free()d by the caller
Parameters

  • k: a kernel structure

  • ctx: context in which to build the kernel

  • count: number of source code strings

  • strs: C array of source code strings

  • lens: C array with the size of each string or NULL

  • name: name of the kernel function

  • argcount: number of kerner arguments

  • types: typecode for each argument

  • flags: kernel use flags (see ga_usefl)

  • err_str: (if not NULL) location to write GPU-backend provided debug info

Return

GA_NO_ERROR if the operation is successful

Return

any other value if an error occured

void GpuKernel_clear(GpuKernel *k)

Clear and release data associated with a kernel.

Parameters

  • k: the kernel to release

gpucontext *GpuKernel_context(GpuKernel *k)

Returns the context in which a kernel was built.

Return

a context pointer

Parameters

  • k: a kernel

int GpuKernel_setarg(GpuKernel *k, unsigned int i, void *val)
int GpuKernel_sched(GpuKernel *k, size_t n, size_t *gs, size_t *ls)

Do a scheduling of local and global size for a kernel.

This function will find an optimal grid and block size for the number of elements specified in n when running kernel k. The parameters may run a bit more instances than n for efficiency reasons, so your kernel must be ready to deal with that.

If either gs or ls is not 0 on entry its value will not be altered and will be taken into account when choosing the other value.

Parameters

  • k: the kernel to schedule for

  • n: number of elements to handle

  • gs: grid size (in/out)

  • ls: local size (in/out)

int GpuKernel_call(GpuKernel *k, unsigned int n, const size_t *gs, const size_t *ls, size_t shared, void **args)

Launch the execution of a kernel.

Parameters

  • k: the kernel to launch

  • n: dimensionality of the grid/blocks

  • gs: sizes of launch grid

  • ls: sizes of launch blocks

  • shared: amount of dynamic shared memory to allocate

  • args: table of pointers to arguments

const char *GpuKernel_error(const GpuKernel *k, int err)
struct GpuKernel
#include <kernel.h>

Kernel information structure.

Public Members

gpukernel *k

Device kernel reference.

void **args

Argument buffer.