StarPU Handbook
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
Data Interfaces

Data Structures

struct  starpu_data_interface_ops
struct  starpu_data_copy_methods
struct  starpu_variable_interface
struct  starpu_vector_interface
struct  starpu_matrix_interface
struct  starpu_block_interface
struct  starpu_bcsr_interface
struct  starpu_csr_interface
struct  starpu_coo_interface

Enumerations

enum  starpu_data_interface_id {
  STARPU_UNKNOWN_INTERFACE_ID, STARPU_MATRIX_INTERFACE_ID, STARPU_BLOCK_INTERFACE_ID, STARPU_VECTOR_INTERFACE_ID,
  STARPU_CSR_INTERFACE_ID, STARPU_BCSR_INTERFACE_ID, STARPU_VARIABLE_INTERFACE_ID, STARPU_VOID_INTERFACE_ID,
  STARPU_MULTIFORMAT_INTERFACE_ID, STARPU_COO_INTERFACE_ID, STARPU_MAX_INTERFACE_ID
}

Registering Data

There are several ways to register a memory region so that it can be managed by StarPU. The functions below allow the registration of vectors, 2D matrices, 3D matrices as well as BCSR and CSR sparse matrices.

void starpu_void_data_register (starpu_data_handle_t *handle)
void starpu_variable_data_register (starpu_data_handle_t *handle, int home_node, uintptr_t ptr, size_t size)
void starpu_variable_ptr_register (starpu_data_handle_t handle, unsigned node, uintptr_t ptr, uintptr_t dev_handle, size_t offset)
void starpu_vector_data_register (starpu_data_handle_t *handle, int home_node, uintptr_t ptr, uint32_t nx, size_t elemsize)
void starpu_vector_ptr_register (starpu_data_handle_t handle, unsigned node, uintptr_t ptr, uintptr_t dev_handle, size_t offset)
void starpu_matrix_data_register (starpu_data_handle_t *handle, int home_node, uintptr_t ptr, uint32_t ld, uint32_t nx, uint32_t ny, size_t elemsize)
void starpu_matrix_ptr_register (starpu_data_handle_t handle, unsigned node, uintptr_t ptr, uintptr_t dev_handle, size_t offset, uint32_t ld)
void starpu_block_data_register (starpu_data_handle_t *handle, int home_node, uintptr_t ptr, uint32_t ldy, uint32_t ldz, uint32_t nx, uint32_t ny, uint32_t nz, size_t elemsize)
void starpu_block_ptr_register (starpu_data_handle_t handle, unsigned node, uintptr_t ptr, uintptr_t dev_handle, size_t offset, uint32_t ldy, uint32_t ldz)
void starpu_bcsr_data_register (starpu_data_handle_t *handle, int home_node, uint32_t nnz, uint32_t nrow, uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, uint32_t r, uint32_t c, size_t elemsize)
void starpu_csr_data_register (starpu_data_handle_t *handle, int home_node, uint32_t nnz, uint32_t nrow, uintptr_t nzval, uint32_t *colind, uint32_t *rowptr, uint32_t firstentry, size_t elemsize)
void starpu_coo_data_register (starpu_data_handle_t *handleptr, int home_node, uint32_t nx, uint32_t ny, uint32_t n_values, uint32_t *columns, uint32_t *rows, uintptr_t values, size_t elemsize)
void * starpu_data_get_interface_on_node (starpu_data_handle_t handle, unsigned memory_node)

Accessing Data Interfaces

Each data interface is provided with a set of field access functions. The ones using a void * parameter aimed to be used in codelet implementations (see for example the code in Vector Scaling Using StarPU's API).

void * starpu_data_handle_to_pointer (starpu_data_handle_t handle, unsigned node)
void * starpu_data_get_local_ptr (starpu_data_handle_t handle)
enum starpu_data_interface_id starpu_data_get_interface_id (starpu_data_handle_t handle)
size_t starpu_data_get_size (starpu_data_handle_t handle)
int starpu_data_pack (starpu_data_handle_t handle, void **ptr, starpu_ssize_t *count)
int starpu_data_unpack (starpu_data_handle_t handle, void *ptr, size_t count)

Accessing Variable Data Interfaces

#define STARPU_VARIABLE_GET_PTR(interface)
#define STARPU_VARIABLE_GET_ELEMSIZE(interface)
#define STARPU_VARIABLE_GET_DEV_HANDLE(interface)
#define STARPU_VARIABLE_GET_OFFSET(interface)
size_t starpu_variable_get_elemsize (starpu_data_handle_t handle)
uintptr_t starpu_variable_get_local_ptr (starpu_data_handle_t handle)

Accessing Vector Data Interfaces

#define STARPU_VECTOR_GET_PTR(interface)
#define STARPU_VECTOR_GET_DEV_HANDLE(interface)
#define STARPU_VECTOR_GET_OFFSET(interface)
#define STARPU_VECTOR_GET_NX(interface)
#define STARPU_VECTOR_GET_ELEMSIZE(interface)
#define STARPU_VECTOR_GET_SLICE_BASE(interface)
uint32_t starpu_vector_get_nx (starpu_data_handle_t handle)
size_t starpu_vector_get_elemsize (starpu_data_handle_t handle)
uintptr_t starpu_vector_get_local_ptr (starpu_data_handle_t handle)

Accessing Matrix Data Interfaces

#define STARPU_MATRIX_GET_PTR(interface)
#define STARPU_MATRIX_GET_DEV_HANDLE(interface)
#define STARPU_MATRIX_GET_OFFSET(interface)
#define STARPU_MATRIX_GET_NX(interface)
#define STARPU_MATRIX_GET_NY(interface)
#define STARPU_MATRIX_GET_LD(interface)
#define STARPU_MATRIX_GET_ELEMSIZE(interface)
uint32_t starpu_matrix_get_nx (starpu_data_handle_t handle)
uint32_t starpu_matrix_get_ny (starpu_data_handle_t handle)
uint32_t starpu_matrix_get_local_ld (starpu_data_handle_t handle)
uintptr_t starpu_matrix_get_local_ptr (starpu_data_handle_t handle)
size_t starpu_matrix_get_elemsize (starpu_data_handle_t handle)

Accessing Block Data Interfaces

#define STARPU_BLOCK_GET_PTR(interface)
#define STARPU_BLOCK_GET_DEV_HANDLE(interface)
#define STARPU_BLOCK_GET_OFFSET(interface)
#define STARPU_BLOCK_GET_NX(interface)
#define STARPU_BLOCK_GET_NY(interface)
#define STARPU_BLOCK_GET_NZ(interface)
#define STARPU_BLOCK_GET_LDY(interface)
#define STARPU_BLOCK_GET_LDZ(interface)
#define STARPU_BLOCK_GET_ELEMSIZE(interface)
uint32_t starpu_block_get_nx (starpu_data_handle_t handle)
uint32_t starpu_block_get_ny (starpu_data_handle_t handle)
uint32_t starpu_block_get_nz (starpu_data_handle_t handle)
uint32_t starpu_block_get_local_ldy (starpu_data_handle_t handle)
uint32_t starpu_block_get_local_ldz (starpu_data_handle_t handle)
uintptr_t starpu_block_get_local_ptr (starpu_data_handle_t handle)
size_t starpu_block_get_elemsize (starpu_data_handle_t handle)

Accessing BCSR Data Interfaces

#define STARPU_BCSR_GET_NNZ(interface)
#define STARPU_BCSR_GET_NZVAL(interface)
#define STARPU_BCSR_GET_NZVAL_DEV_HANDLE(interface)
#define STARPU_BCSR_GET_COLIND(interface)
#define STARPU_BCSR_GET_COLIND_DEV_HANDLE(interface)
#define STARPU_BCSR_GET_ROWPTR(interface)
#define STARPU_BCSR_GET_ROWPTR_DEV_HANDLE(interface)
#define STARPU_BCSR_GET_OFFSET
uint32_t starpu_bcsr_get_nnz (starpu_data_handle_t handle)
uint32_t starpu_bcsr_get_nrow (starpu_data_handle_t handle)
uint32_t starpu_bcsr_get_firstentry (starpu_data_handle_t handle)
uintptr_t starpu_bcsr_get_local_nzval (starpu_data_handle_t handle)
uint32_t * starpu_bcsr_get_local_colind (starpu_data_handle_t handle)
uint32_t * starpu_bcsr_get_local_rowptr (starpu_data_handle_t handle)
uint32_t starpu_bcsr_get_r (starpu_data_handle_t handle)
uint32_t starpu_bcsr_get_c (starpu_data_handle_t handle)
size_t starpu_bcsr_get_elemsize (starpu_data_handle_t handle)

Accessing CSR Data Interfaces

#define STARPU_CSR_GET_NNZ(interface)
#define STARPU_CSR_GET_NROW(interface)
#define STARPU_CSR_GET_NZVAL(interface)
#define STARPU_CSR_GET_NZVAL_DEV_HANDLE(interface)
#define STARPU_CSR_GET_COLIND(interface)
#define STARPU_CSR_GET_COLIND_DEV_HANDLE(interface)
#define STARPU_CSR_GET_ROWPTR(interface)
#define STARPU_CSR_GET_ROWPTR_DEV_HANDLE(interface)
#define STARPU_CSR_GET_OFFSET
#define STARPU_CSR_GET_FIRSTENTRY(interface)
#define STARPU_CSR_GET_ELEMSIZE(interface)
uint32_t starpu_csr_get_nnz (starpu_data_handle_t handle)
uint32_t starpu_csr_get_nrow (starpu_data_handle_t handle)
uint32_t starpu_csr_get_firstentry (starpu_data_handle_t handle)
uintptr_t starpu_csr_get_local_nzval (starpu_data_handle_t handle)
uint32_t * starpu_csr_get_local_colind (starpu_data_handle_t handle)
uint32_t * starpu_csr_get_local_rowptr (starpu_data_handle_t handle)
size_t starpu_csr_get_elemsize (starpu_data_handle_t handle)

Accessing COO Data Interfaces

#define STARPU_COO_GET_COLUMNS(interface)
#define STARPU_COO_GET_COLUMNS_DEV_HANDLE(interface)
#define STARPU_COO_GET_ROWS(interface)
#define STARPU_COO_GET_ROWS_DEV_HANDLE(interface)
#define STARPU_COO_GET_VALUES(interface)
#define STARPU_COO_GET_VALUES_DEV_HANDLE(interface)
#define STARPU_COO_GET_OFFSET
#define STARPU_COO_GET_NX(interface)
#define STARPU_COO_GET_NY(interface)
#define STARPU_COO_GET_NVALUES(interface)
#define STARPU_COO_GET_ELEMSIZE(interface)

Defining Interface

Applications can provide their own interface as shown in Defining A New Data Interface.

uintptr_t starpu_malloc_on_node_flags (unsigned dst_node, size_t size, int flags)
void starpu_free_on_node_flags (unsigned dst_node, uintptr_t addr, size_t size, int flags)
uintptr_t starpu_malloc_on_node (unsigned dst_node, size_t size)
void starpu_free_on_node (unsigned dst_node, uintptr_t addr, size_t size)
void starpu_malloc_on_node_set_default_flags (unsigned node, int flags)
int starpu_interface_copy (uintptr_t src, size_t src_offset, unsigned src_node, uintptr_t dst, size_t dst_offset, unsigned dst_node, size_t size, void *async_data)
uint32_t starpu_hash_crc32c_be_n (const void *input, size_t n, uint32_t inputcrc)
uint32_t starpu_hash_crc32c_be (uint32_t input, uint32_t inputcrc)
uint32_t starpu_hash_crc32c_string (const char *str, uint32_t inputcrc)
int starpu_data_interface_get_next_id (void)

Detailed Description


Data Structure Documentation

struct starpu_data_interface_ops

Per-interface data transfer methods.

Data Fields

void(* register_data_handle )(starpu_data_handle_t handle, unsigned home_node, void *data_interface)
starpu_ssize_t(* allocate_data_on_node )(void *data_interface, unsigned node)
void(* free_data_on_node )(void *data_interface, unsigned node)
struct starpu_data_copy_methodscopy_methods
void *(* handle_to_pointer )(starpu_data_handle_t handle, unsigned node)
size_t(* get_size )(starpu_data_handle_t handle)
uint32_t(* footprint )(starpu_data_handle_t handle)
int(* compare )(void *data_interface_a, void *data_interface_b)
void(* display )(starpu_data_handle_t handle, FILE *f)
starpu_ssize_t(* describe )(void *data_interface, char *buf, size_t size)
enum starpu_data_interface_id interfaceid
size_t interface_size
char is_multiformat
char dontcache
struct
starpu_multiformat_data_interface_ops *(* 
get_mf_ops )(void *data_interface)
int(* pack_data )(starpu_data_handle_t handle, unsigned node, void **ptr, starpu_ssize_t *count)
int(* unpack_data )(starpu_data_handle_t handle, unsigned node, void *ptr, size_t count)

Field Documentation

void(* starpu_data_interface_ops::register_data_handle)(starpu_data_handle_t handle, unsigned home_node, void *data_interface)

Register an existing interface into a data handle.

starpu_ssize_t(* starpu_data_interface_ops::allocate_data_on_node)(void *data_interface, unsigned node)

Allocate data for the interface on a given node.

void(* starpu_data_interface_ops::free_data_on_node)(void *data_interface, unsigned node)

Free data of the interface on a given node.

const struct starpu_data_copy_methods * starpu_data_interface_ops::copy_methods

ram/cuda/opencl synchronous and asynchronous transfer methods.

void *(* starpu_data_interface_ops::handle_to_pointer)(starpu_data_handle_t handle, unsigned node)

Return the current pointer (if any) for the handle on the given node.

size_t(* starpu_data_interface_ops::get_size)(starpu_data_handle_t handle)

Return an estimation of the size of data, for performance models.

uint32_t(* starpu_data_interface_ops::footprint)(starpu_data_handle_t handle)

Return a 32bit footprint which characterizes the data size.

int(* starpu_data_interface_ops::compare)(void *data_interface_a, void *data_interface_b)

Compare the data size of two interfaces.

void(* starpu_data_interface_ops::display)(starpu_data_handle_t handle, FILE *f)

Dump the sizes of a handle to a file.

starpu_ssize_t(* starpu_data_interface_ops::describe)(void *data_interface, char *buf, size_t size)

Describe the data into a string.

enum starpu_data_interface_id starpu_data_interface_ops::interfaceid

An identifier that is unique to each interface.

size_t starpu_data_interface_ops::interface_size

The size of the interface data descriptor.

char starpu_data_interface_ops::is_multiformat

todo

char starpu_data_interface_ops::dontcache

If set to non-zero, StarPU will never try to reuse an allocated buffer for a different handle. This can be notably useful for application-defined interfaces which have a dynamic size, and for which it thus does not make sense to reuse the buffer since will probably not have the proper size.

struct starpu_multiformat_data_interface_ops *(* starpu_data_interface_ops::get_mf_ops)(void *data_interface)
read

todo

int(* starpu_data_interface_ops::pack_data)(starpu_data_handle_t handle, unsigned node, void **ptr, starpu_ssize_t *count)

Pack the data handle into a contiguous buffer at the address allocated with starpu_malloc_flags(ptr, size, 0) (and thus returned in ptr) and set the size of the newly created buffer in count. If ptr is NULL, the function should not copy the data in the buffer but just set count to the size of the buffer which would have been allocated. The special value -1 indicates the size is yet unknown.

int(* starpu_data_interface_ops::unpack_data)(starpu_data_handle_t handle, unsigned node, void *ptr, size_t count)

Unpack the data handle from the contiguous buffer at the address ptr of size count

struct starpu_data_copy_methods

Defines the per-interface methods. If the any_to_any method is provided, it will be used by default if no more specific method is provided. It can still be useful to provide more specific method in case of e.g. available particular CUDA or OpenCL support.

Data Fields

int(* can_copy )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, unsigned handling_node)
int(* ram_to_ram )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* ram_to_cuda )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* ram_to_opencl )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* ram_to_mic )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* cuda_to_ram )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* cuda_to_cuda )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* cuda_to_opencl )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* opencl_to_ram )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* opencl_to_cuda )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* opencl_to_opencl )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* mic_to_ram )(void *src_interface, unsigned srd_node, void *dst_interface, unsigned dst_node)
int(* scc_src_to_sink )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* scc_sink_to_src )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* scc_sink_to_sink )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* ram_to_cuda_async )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, starpu_cudaStream_t stream)
int(* cuda_to_ram_async )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, starpu_cudaStream_t stream)
int(* cuda_to_cuda_async )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, starpu_cudaStream_t stream)
int(* ram_to_opencl_async )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cl_event *event)
int(* opencl_to_ram_async )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cl_event *event)
int(* opencl_to_opencl_async )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cl_event *event)
int(* ram_to_mic_async )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)
int(* mic_to_ram_async )(void *src_interface, unsigned srd_node, void *dst_interface, unsigned dst_node)
int(* any_to_any )(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, void *async_data)

Field Documentation

int(* starpu_data_copy_methods::can_copy)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, unsigned handling_node)

If defined, allows the interface to declare whether it supports transferring from src_interface on node src_node to dst_interface on node dst_node, run from node handling_node. If not defined, it is assumed that the interface supports all transfers.

int(* starpu_data_copy_methods::ram_to_ram)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node CPU node to the dst_interface interface on the dst_node CPU node. Return 0 on success.

int(* starpu_data_copy_methods::ram_to_cuda)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node CPU node to the dst_interface interface on the dst_node CUDA node. Return 0 on success.

int(* starpu_data_copy_methods::ram_to_opencl)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node CPU node to the dst_interface interface on the dst_node OpenCL node. Return 0 on success.

int(* starpu_data_copy_methods::ram_to_mic)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node CPU node to the dst_interface interface on the dst_node MIC node. Return 0 on success.

int(* starpu_data_copy_methods::cuda_to_ram)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node CUDA node to the dst_interface interface on the dst_node CPU node. Return 0 on success.

int(* starpu_data_copy_methods::cuda_to_cuda)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node CUDA node to the dst_interface interface on the dst_node CUDA node. Return 0 on success.

int(* starpu_data_copy_methods::cuda_to_opencl)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node CUDA node to the dst_interface interface on the dst_node OpenCL node. Return 0 on success.

int(* starpu_data_copy_methods::opencl_to_ram)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node OpenCL node to the dst_interface interface on the dst_node CPU node. Return 0 on success.

int(* starpu_data_copy_methods::opencl_to_cuda)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node OpenCL node to the dst_interface interface on the dst_node CUDA node. Return 0 on success.

int(* starpu_data_copy_methods::opencl_to_opencl)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node OpenCL node to the dst_interface interface on the dst_node OpenCL node. Return 0 on success.

int(* starpu_data_copy_methods::mic_to_ram)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node MIC node to the dst_interface interface on the dst_node CPU node. Return 0 on success.

int(* starpu_data_copy_methods::scc_src_to_sink)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node node to the dst_interface interface on the dst_node node. Must return 0 if the transfer was actually completed completely synchronously, or -EAGAIN if at least some transfers are still ongoing and should be awaited for by the core.

int(* starpu_data_copy_methods::scc_sink_to_src)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node node to the dst_interface interface on the dst_node node. Must return 0 if the transfer was actually completed completely synchronously, or -EAGAIN if at least some transfers are still ongoing and should be awaited for by the core.

int(* starpu_data_copy_methods::scc_sink_to_sink)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node node to the dst_interface interface on the dst_node node. Must return 0 if the transfer was actually completed completely synchronously, or -EAGAIN if at least some transfers are still ongoing and should be awaited for by the core.

int(* starpu_data_copy_methods::ram_to_cuda_async)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cudaStream_t stream)

Define how to copy data from the src_interface interface on the src_node CPU node to the dst_interface interface on the dst_node CUDA node, using the given stream. Must return 0 if the transfer was actually completed completely synchronously, or -EAGAIN if at least some transfers are still ongoing and should be awaited for by the core.

int(* starpu_data_copy_methods::cuda_to_ram_async)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cudaStream_t stream)

Define how to copy data from the src_interface interface on the src_node CUDA node to the dst_interface interface on the dst_node CPU node, using the given stream. Must return 0 if the transfer was actually completed completely synchronously, or -EAGAIN if at least some transfers are still ongoing and should be awaited for by the core.

int(* starpu_data_copy_methods::cuda_to_cuda_async)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cudaStream_t stream)

Define how to copy data from the src_interface interface on the src_node CUDA node to the dst_interface interface on the dst_node CUDA node, using the given stream. Must return 0 if the transfer was actually completed completely synchronously, or -EAGAIN if at least some transfers are still ongoing and should be awaited for by the core.

int(* starpu_data_copy_methods::ram_to_opencl_async)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cl_event *event)

Define how to copy data from the src_interface interface on the src_node CPU node to the dst_interface interface on the dst_node OpenCL node, by recording in event, a pointer to a cl_event, the event of the last submitted transfer. Must return 0 if the transfer was actually completed completely synchronously, or -EAGAIN if at least some transfers are still ongoing and should be awaited for by the core.

int(* starpu_data_copy_methods::opencl_to_ram_async)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cl_event *event)

Define how to copy data from the src_interface interface on the src_node OpenCL node to the dst_interface interface on the dst_node CPU node, by recording in event, a pointer to a cl_event, the event of the last submitted transfer. Must return 0 if the transfer was actually completed completely synchronously, or -EAGAIN if at least some transfers are still ongoing and should be awaited for by the core.

int(* starpu_data_copy_methods::opencl_to_opencl_async)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, cl_event *event)

Define how to copy data from the src_interface interface on the src_node OpenCL node to the dst_interface interface on the dst_node OpenCL node, by recording in event, a pointer to a cl_event, the event of the last submitted transfer. Must return 0 if the transfer was actually completed completely synchronously, or -EAGAIN if at least some transfers are still ongoing and should be awaited for by the core.

int(* starpu_data_copy_methods::ram_to_mic_async)(void *src_intreface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node CPU node to the dst_interface interface on the dst_node MIC node. Must return 0 if the transfer was actually completed completely synchronously, or -EAGAIN if at least some transfers are still ongoing and should be awaited for by the core.

int(* starpu_data_copy_methods::mic_to_ram_async)(void *src_intreface, unsigned src_node, void *dst_interface, unsigned dst_node)

Define how to copy data from the src_interface interface on the src_node MIC node to the dst_interface interface on the dst_node CPU node. Must return 0 if the transfer was actually completed completely synchronously, or -EAGAIN if at least some transfers are still ongoing and should be awaited for by the core.

int(* starpu_data_copy_methods::any_to_any)(void *src_interface, unsigned src_node, void *dst_interface, unsigned dst_node, void *async_data)

Define how to copy data from the src_interface interface on the src_node node to the dst_interface interface on the dst_node node. This is meant to be implemented through the starpu_interface_copy() helper, to which async_data should be passed as such, and will be used to manage asynchronicity. This must return -EAGAIN if any of the starpu_interface_copy() calls has returned -EAGAIN (i.e. at least some transfer is still ongoing), and return 0 otherwise.

struct starpu_variable_interface

Variable interface for a single data (not a vector, a matrix, a list, ...)

Data Fields
enum starpu_data_interface_id id Identifier of the interface
uintptr_t ptr local pointer of the variable
uintptr_t dev_handle device handle of the variable.
size_t offset offset in the variable
size_t elemsize size of the variable
struct starpu_vector_interface

Vector interface

Data Fields
enum starpu_data_interface_id id Identifier of the interface
uintptr_t ptr local pointer of the vector
uintptr_t dev_handle device handle of the vector.
size_t offset offset in the vector
uint32_t nx number of elements on the x-axis of the vector
size_t elemsize size of the elements of the vector
uint32_t slice_base vector slice base, used by the StarPU OpenMP runtime support
struct starpu_matrix_interface

Matrix interface for dense matrices

Data Fields
enum starpu_data_interface_id id Identifier of the interface
uintptr_t ptr local pointer of the matrix
uintptr_t dev_handle device handle of the matrix.
size_t offset offset in the matrix
uint32_t nx number of elements on the x-axis of the matrix
uint32_t ny number of elements on the y-axis of the matrix
uint32_t ld number of elements between each row of the matrix. Maybe be equal to starpu_matrix_interface::nx when there is no padding.
size_t elemsize size of the elements of the matrix
struct starpu_block_interface

Block interface for 3D dense blocks

Data Fields
enum starpu_data_interface_id id identifier of the interface
uintptr_t ptr local pointer of the block
uintptr_t dev_handle device handle of the block.
size_t offset offset in the block.
uint32_t nx number of elements on the x-axis of the block.
uint32_t ny number of elements on the y-axis of the block.
uint32_t nz number of elements on the z-axis of the block.
uint32_t ldy number of elements between two lines
uint32_t ldz number of elements between two planes
size_t elemsize size of the elements of the block.
struct starpu_bcsr_interface

BCSR interface for sparse matrices (blocked compressed sparse row representation)

Data Fields
enum starpu_data_interface_id id Identifier of the interface
uint32_t nnz number of non-zero BLOCKS
uint32_t nrow number of rows (in terms of BLOCKS)
uintptr_t nzval non-zero values
uint32_t * colind position of non-zero entried on the row
uint32_t * rowptr index (in nzval) of the first entry of the row
uint32_t firstentry k for k-based indexing (0 or 1 usually). Also useful when partitionning the matrix.
uint32_t r size of the blocks
uint32_t c size of the blocks
size_t elemsize size of the elements of the matrix
struct starpu_csr_interface

CSR interface for sparse matrices (compressed sparse row representation)

Data Fields
enum starpu_data_interface_id id Identifier of the interface
uint32_t nnz number of non-zero entries
uint32_t nrow number of rows
uintptr_t nzval non-zero values
uint32_t * colind position of non-zero entries on the row
uint32_t * rowptr index (in nzval) of the first entry of the row
uint32_t firstentry k for k-based indexing (0 or 1 usually). also useful when partitionning the matrix.
size_t elemsize size of the elements of the matrix
struct starpu_coo_interface

COO Matrices

Data Fields
enum starpu_data_interface_id id identifier of the interface
uint32_t * columns column array of the matrix
uint32_t * rows row array of the matrix
uintptr_t values values of the matrix
uint32_t nx number of elements on the x-axis of the matrix
uint32_t ny number of elements on the y-axis of the matrix
uint32_t n_values number of values registered in the matrix
size_t elemsize size of the elements of the matrix

Macro Definition Documentation

#define STARPU_VARIABLE_GET_PTR (   interface)

Return a pointer to the variable designated by interface.

#define STARPU_VARIABLE_GET_ELEMSIZE (   interface)

Return the size of the variable designated by interface.

#define STARPU_VARIABLE_GET_DEV_HANDLE (   interface)

Return a device handle for the variable designated by interface, to be used on OpenCL. The offset documented below has to be used in addition to this.

#define STARPU_VARIABLE_GET_OFFSET (   interface)

Return the offset in the variable designated by interface, to be used with the device handle.

#define STARPU_VECTOR_GET_PTR (   interface)

Return a pointer to the array designated by interface, valid on CPUs and CUDA only. For OpenCL, the device handle and offset need to be used instead.

#define STARPU_VECTOR_GET_DEV_HANDLE (   interface)

Return a device handle for the array designated by interface, to be used on OpenCL. the offset documented below has to be used in addition to this.

#define STARPU_VECTOR_GET_OFFSET (   interface)

Return the offset in the array designated by interface, to be used with the device handle.

#define STARPU_VECTOR_GET_NX (   interface)

Return the number of elements registered into the array designated by interface.

#define STARPU_VECTOR_GET_ELEMSIZE (   interface)

Return the size of each element of the array designated by interface.

#define STARPU_VECTOR_GET_SLICE_BASE (   interface)

Return the OpenMP slice base annotation of each element of the array designated by interface.

See Also
starpu_omp_vector_annotate
#define STARPU_MATRIX_GET_PTR (   interface)

Return a pointer to the matrix designated by interface, valid on CPUs and CUDA devices only. For OpenCL devices, the device handle and offset need to be used instead.

#define STARPU_MATRIX_GET_DEV_HANDLE (   interface)

Return a device handle for the matrix designated by interface, to be used on OpenCL. The offset documented below has to be used in addition to this.

#define STARPU_MATRIX_GET_OFFSET (   interface)

Return the offset in the matrix designated by interface, to be used with the device handle.

#define STARPU_MATRIX_GET_NX (   interface)

Return the number of elements on the x-axis of the matrix designated by interface.

#define STARPU_MATRIX_GET_NY (   interface)

Return the number of elements on the y-axis of the matrix designated by interface.

#define STARPU_MATRIX_GET_LD (   interface)

Return the number of elements between each row of the matrix designated by interface. May be equal to nx when there is no padding.

#define STARPU_MATRIX_GET_ELEMSIZE (   interface)

Return the size of the elements registered into the matrix designated by interface.

#define STARPU_BLOCK_GET_PTR (   interface)

Return a pointer to the block designated by interface.

#define STARPU_BLOCK_GET_DEV_HANDLE (   interface)

Return a device handle for the block designated by interface, to be used on OpenCL. The offset document below has to be used in addition to this.

#define STARPU_BLOCK_GET_OFFSET (   interface)

Return the offset in the block designated by interface, to be used with the device handle.

#define STARPU_BLOCK_GET_NX (   interface)

Return the number of elements on the x-axis of the block designated by interface.

#define STARPU_BLOCK_GET_NY (   interface)

Return the number of elements on the y-axis of the block designated by interface.

#define STARPU_BLOCK_GET_NZ (   interface)

Return the number of elements on the z-axis of the block designated by interface.

#define STARPU_BLOCK_GET_LDY (   interface)

Return the number of elements between each row of the block designated by interface. May be equal to nx when there is no padding.

#define STARPU_BLOCK_GET_LDZ (   interface)

Return the number of elements between each z plane of the block designated by interface. May be equal to nx*ny when there is no padding.

#define STARPU_BLOCK_GET_ELEMSIZE (   interface)

Return the size of the elements of the block designated by interface.

#define STARPU_BCSR_GET_NNZ (   interface)

Return the number of non-zero values in the matrix designated by interface.

#define STARPU_BCSR_GET_NZVAL (   interface)

Return a pointer to the non-zero values of the matrix designated by interface.

#define STARPU_BCSR_GET_NZVAL_DEV_HANDLE (   interface)

Return a device handle for the array of non-zero values in the matrix designated by interface. The offset documented below has to be used in addition to this.

#define STARPU_BCSR_GET_COLIND (   interface)

Return a pointer to the column index of the matrix designated by interface.

#define STARPU_BCSR_GET_COLIND_DEV_HANDLE (   interface)

Return a device handle for the column index of the matrix designated by interface. The offset documented below has to be used in addition to this.

#define STARPU_BCSR_GET_ROWPTR (   interface)

Return a pointer to the row pointer array of the matrix designated by interface.

#define STARPU_BCSR_GET_ROWPTR_DEV_HANDLE (   interface)

Return a device handle for the row pointer array of the matrix designated by interface. The offset documented below has to be used in addition to this.

#define STARPU_BCSR_GET_OFFSET

Return the offset in the arrays (coling, rowptr, nzval) of the matrix designated by interface, to be used with the device handles.

#define STARPU_CSR_GET_NNZ (   interface)

Return the number of non-zero values in the matrix designated by interface.

#define STARPU_CSR_GET_NROW (   interface)

Return the size of the row pointer array of the matrix designated by interface.

#define STARPU_CSR_GET_NZVAL (   interface)

Return a pointer to the non-zero values of the matrix designated by interface.

#define STARPU_CSR_GET_NZVAL_DEV_HANDLE (   interface)

Return a device handle for the array of non-zero values in the matrix designated by interface. The offset documented below has to be used in addition to this.

#define STARPU_CSR_GET_COLIND (   interface)

Return a pointer to the column index of the matrix designated by interface.

#define STARPU_CSR_GET_COLIND_DEV_HANDLE (   interface)

Return a device handle for the column index of the matrix designated by interface. The offset documented below has to be used in addition to this.

#define STARPU_CSR_GET_ROWPTR (   interface)

Return a pointer to the row pointer array of the matrix designated by interface.

#define STARPU_CSR_GET_ROWPTR_DEV_HANDLE (   interface)

Return a device handle for the row pointer array of the matrix designated by interface. The offset documented below has to be used in addition to this.

#define STARPU_CSR_GET_OFFSET

Return the offset in the arrays (colind, rowptr, nzval) of the matrix designated by interface, to be used with the device handles.

#define STARPU_CSR_GET_FIRSTENTRY (   interface)

Return the index at which all arrays (the column indexes, the row pointers...) of the interface start.

#define STARPU_CSR_GET_ELEMSIZE (   interface)

Return the size of the elements registered into the matrix designated by interface.

#define STARPU_COO_GET_COLUMNS (   interface)

Return a pointer to the column array of the matrix designated by interface.

#define STARPU_COO_GET_COLUMNS_DEV_HANDLE (   interface)

Return a device handle for the column array of the matrix designated by interface, to be used on OpenCL. The offset documented below has to be used in addition to this.

#define STARPU_COO_GET_ROWS (   interface)

Return a pointer to the rows array of the matrix designated by interface.

#define STARPU_COO_GET_ROWS_DEV_HANDLE (   interface)

Return a device handle for the row array of the matrix designated by interface, to be used on OpenCL. The offset documented below has to be used in addition to this.

#define STARPU_COO_GET_VALUES (   interface)

Return a pointer to the values array of the matrix designated by interface.

#define STARPU_COO_GET_VALUES_DEV_HANDLE (   interface)

Return a device handle for the value array of the matrix designated by interface, to be used on OpenCL. The offset documented below has to be used in addition to this.

#define STARPU_COO_GET_OFFSET

Return the offset in the arrays of the COO matrix designated by interface.

#define STARPU_COO_GET_NX (   interface)

Return the number of elements on the x-axis of the matrix designated by interface.

#define STARPU_COO_GET_NY (   interface)

Return the number of elements on the y-axis of the matrix designated by interface.

#define STARPU_COO_GET_NVALUES (   interface)

Return the number of values registered in the matrix designated by interface.

#define STARPU_COO_GET_ELEMSIZE (   interface)

Return the size of the elements registered into the matrix designated by interface.

Enumeration Type Documentation

Identifier for all predefined StarPU data interfaces

Enumerator:
STARPU_UNKNOWN_INTERFACE_ID 

Unknown interface

STARPU_MATRIX_INTERFACE_ID 

Identifier for the matrix data interface

STARPU_BLOCK_INTERFACE_ID 

Identifier for block data interface

STARPU_VECTOR_INTERFACE_ID 

Identifier for the vector data interface

STARPU_CSR_INTERFACE_ID 

Identifier for the csr data interface

STARPU_BCSR_INTERFACE_ID 

Identifier for the bcsr data interface

STARPU_VARIABLE_INTERFACE_ID 

Identifier for the variable data interface

STARPU_VOID_INTERFACE_ID 

Identifier for the void data interface

STARPU_MULTIFORMAT_INTERFACE_ID 

Identifier for the multiformat data interface

STARPU_COO_INTERFACE_ID 

Identifier for the coo data interface

STARPU_MAX_INTERFACE_ID 

Maximum number of data interfaces

Function Documentation

void starpu_void_data_register ( starpu_data_handle_t handle)

Register a void interface. There is no data really associated to that interface, but it may be used as a synchronization mechanism. It also permits to express an abstract piece of data that is managed by the application internally: this makes it possible to forbid the concurrent execution of different tasks accessing the same void data in read-write concurrently.

void starpu_variable_data_register ( starpu_data_handle_t handle,
int  home_node,
uintptr_t  ptr,
size_t  size 
)

Register the size byte element pointed to by ptr, which is typically a scalar, and initialize handle to represent this data item.

Here an example of how to use the function.

float var;
starpu_variable_data_register(&var_handle, STARPU_MAIN_RAM, (uintptr_t)&var, sizeof(var));
void starpu_variable_ptr_register ( starpu_data_handle_t  handle,
unsigned  node,
uintptr_t  ptr,
uintptr_t  dev_handle,
size_t  offset 
)

Register into the handle that to store data on node node it should use the buffer located at ptr, or device handle dev_handle and offset offset (for OpenCL, notably)

void starpu_vector_data_register ( starpu_data_handle_t handle,
int  home_node,
uintptr_t  ptr,
uint32_t  nx,
size_t  elemsize 
)

Register the nx elemsize-byte elements pointed to by ptr and initialize handle to represent it.

Here an example of how to use the function.

float vector[NX];
starpu_data_handle_t vector_handle;
starpu_vector_data_register(&vector_handle, STARPU_MAIN_RAM, (uintptr_t)vector, NX, sizeof(vector[0]));
void starpu_vector_ptr_register ( starpu_data_handle_t  handle,
unsigned  node,
uintptr_t  ptr,
uintptr_t  dev_handle,
size_t  offset 
)

Register into the handle that to store data on node node it should use the buffer located at ptr, or device handle dev_handle and offset offset (for OpenCL, notably)

void starpu_matrix_data_register ( starpu_data_handle_t handle,
int  home_node,
uintptr_t  ptr,
uint32_t  ld,
uint32_t  nx,
uint32_t  ny,
size_t  elemsize 
)

Register the nx x ny 2D matrix of elemsize-byte elements pointed by ptr and initialize handle to represent it. ld specifies the number of elements between rows. a value greater than nx adds padding, which can be useful for alignment purposes.

Here an example of how to use the function.

float *matrix;
starpu_data_handle_t matrix_handle;
matrix = (float*)malloc(width * height * sizeof(float));
starpu_matrix_data_register(&matrix_handle, STARPU_MAIN_RAM, (uintptr_t)matrix, width, width, height, sizeof(float));
void starpu_matrix_ptr_register ( starpu_data_handle_t  handle,
unsigned  node,
uintptr_t  ptr,
uintptr_t  dev_handle,
size_t  offset,
uint32_t  ld 
)

Register into the handle that to store data on node node it should use the buffer located at ptr, or device handle dev_handle and offset offset (for OpenCL, notably), with ld elements between rows.

void starpu_block_data_register ( starpu_data_handle_t handle,
int  home_node,
uintptr_t  ptr,
uint32_t  ldy,
uint32_t  ldz,
uint32_t  nx,
uint32_t  ny,
uint32_t  nz,
size_t  elemsize 
)

Register the nx x ny x nz 3D matrix of elemsize byte elements pointed by ptr and initialize handle to represent it. Again, ldy and ldz specify the number of elements between rows and between z planes.

Here an example of how to use the function.

float *block;
starpu_data_handle_t block_handle;
block = (float*)malloc(nx*ny*nz*sizeof(float));
starpu_block_data_register(&block_handle, STARPU_MAIN_RAM, (uintptr_t)block, nx, nx*ny, nx, ny, nz, sizeof(float));
void starpu_block_ptr_register ( starpu_data_handle_t  handle,
unsigned  node,
uintptr_t  ptr,
uintptr_t  dev_handle,
size_t  offset,
uint32_t  ldy,
uint32_t  ldz 
)

Register into the handle that to store data on node node it should use the buffer located at ptr, or device handle dev_handle and offset offset (for OpenCL, notably), with ldy elements between rows and ldz elements between z planes.

void starpu_bcsr_data_register ( starpu_data_handle_t handle,
int  home_node,
uint32_t  nnz,
uint32_t  nrow,
uintptr_t  nzval,
uint32_t *  colind,
uint32_t *  rowptr,
uint32_t  firstentry,
uint32_t  r,
uint32_t  c,
size_t  elemsize 
)

This variant of starpu_data_register() uses the BCSR (Blocked Compressed Sparse Row Representation) sparse matrix interface. Register the sparse matrix made of nnz non-zero blocks of elements of size elemsize stored in nzval and initializes handle to represent it. Blocks have size r * c. nrow is the number of rows (in terms of blocks), colind[i] is the block-column index for block i in nzval, rowptr[i] is the block-index (in nzval) of the first block of row i. firstentry is the index of the first entry of the given arrays (usually 0 or 1).

void starpu_csr_data_register ( starpu_data_handle_t handle,
int  home_node,
uint32_t  nnz,
uint32_t  nrow,
uintptr_t  nzval,
uint32_t *  colind,
uint32_t *  rowptr,
uint32_t  firstentry,
size_t  elemsize 
)

This variant of starpu_data_register() uses the CSR (Compressed Sparse Row Representation) sparse matrix interface. TODO

void starpu_coo_data_register ( starpu_data_handle_t handleptr,
int  home_node,
uint32_t  nx,
uint32_t  ny,
uint32_t  n_values,
uint32_t *  columns,
uint32_t *  rows,
uintptr_t  values,
size_t  elemsize 
)

Register the nx x ny 2D matrix given in the COO format, using the columns, rows, values arrays, which must have n_values elements of size elemsize. Initialize handleptr.

void * starpu_data_get_interface_on_node ( starpu_data_handle_t  handle,
unsigned  memory_node 
)

Return the interface associated with handle on memory_node.

void * starpu_data_handle_to_pointer ( starpu_data_handle_t  handle,
unsigned  node 
)

Return the pointer associated with handle on node node or NULL if handle’s interface does not support this operation or data for this handle is not allocated on that node.

void * starpu_data_get_local_ptr ( starpu_data_handle_t  handle)

Return the local pointer associated with handle or NULL if handle’s interface does not have data allocated locally

enum starpu_data_interface_id starpu_data_get_interface_id ( starpu_data_handle_t  handle)

Return the unique identifier of the interface associated with the given handle.

size_t starpu_data_get_size ( starpu_data_handle_t  handle)

Return the size of the data associated with handle.

int starpu_data_pack ( starpu_data_handle_t  handle,
void **  ptr,
starpu_ssize_t *  count 
)

Execute the packing operation of the interface of the data registered at handle (see starpu_data_interface_ops). This packing operation must allocate a buffer large enough at ptr and copy into the newly allocated buffer the data associated to handle. count will be set to the size of the allocated buffer. If ptr is NULL, the function should not copy the data in the buffer but just set count to the size of the buffer which would have been allocated. The special value -1 indicates the size is yet unknown.

int starpu_data_unpack ( starpu_data_handle_t  handle,
void *  ptr,
size_t  count 
)

Unpack in handle the data located at ptr of size count as described by the interface of the data. The interface registered at handle must define a unpacking operation (see starpu_data_interface_ops). The memory at the address ptr is freed after calling the data unpacking operation.

size_t starpu_variable_get_elemsize ( starpu_data_handle_t  handle)

Return the size of the variable designated by handle.

uintptr_t starpu_variable_get_local_ptr ( starpu_data_handle_t  handle)

Return a pointer to the variable designated by handle.

uint32_t starpu_vector_get_nx ( starpu_data_handle_t  handle)

Return the number of elements registered into the array designated by handle.

size_t starpu_vector_get_elemsize ( starpu_data_handle_t  handle)

Return the size of each element of the array designated by handle.

uintptr_t starpu_vector_get_local_ptr ( starpu_data_handle_t  handle)

Return the local pointer associated with handle.

uint32_t starpu_matrix_get_nx ( starpu_data_handle_t  handle)

Return the number of elements on the x-axis of the matrix designated by handle.

uint32_t starpu_matrix_get_ny ( starpu_data_handle_t  handle)

Return the number of elements on the y-axis of the matrix designated by handle.

uint32_t starpu_matrix_get_local_ld ( starpu_data_handle_t  handle)

Return the number of elements between each row of the matrix designated by handle. Maybe be equal to nx when there is no padding.

uintptr_t starpu_matrix_get_local_ptr ( starpu_data_handle_t  handle)

Return the local pointer associated with handle.

size_t starpu_matrix_get_elemsize ( starpu_data_handle_t  handle)

Return the size of the elements registered into the matrix designated by handle.

uint32_t starpu_block_get_nx ( starpu_data_handle_t  handle)

Return the number of elements on the x-axis of the block designated by handle.

uint32_t starpu_block_get_ny ( starpu_data_handle_t  handle)

Return the number of elements on the y-axis of the block designated by handle.

uint32_t starpu_block_get_nz ( starpu_data_handle_t  handle)

Return the number of elements on the z-axis of the block designated by handle.

uint32_t starpu_block_get_local_ldy ( starpu_data_handle_t  handle)

Return the number of elements between each row of the block designated by handle, in the format of the current memory node.

uint32_t starpu_block_get_local_ldz ( starpu_data_handle_t  handle)

Return the number of elements between each z plane of the block designated by handle, in the format of the current memory node.

uintptr_t starpu_block_get_local_ptr ( starpu_data_handle_t  handle)

Return the local pointer associated with handle.

size_t starpu_block_get_elemsize ( starpu_data_handle_t  handle)

Return the size of the elements of the block designated by handle.

uint32_t starpu_bcsr_get_nnz ( starpu_data_handle_t  handle)

Return the number of non-zero elements in the matrix designated by handle.

uint32_t starpu_bcsr_get_nrow ( starpu_data_handle_t  handle)

Return the number of rows (in terms of blocks of size r*c) in the matrix designated by handle.

uint32_t starpu_bcsr_get_firstentry ( starpu_data_handle_t  handle)

Return the index at which all arrays (the column indexes, the row pointers...) of the matrix desginated by handle.

uintptr_t starpu_bcsr_get_local_nzval ( starpu_data_handle_t  handle)

Return a pointer to the non-zero values of the matrix designated by handle.

uint32_t * starpu_bcsr_get_local_colind ( starpu_data_handle_t  handle)

Return a pointer to the column index, which holds the positions of the non-zero entries in the matrix designated by handle.

uint32_t * starpu_bcsr_get_local_rowptr ( starpu_data_handle_t  handle)

Return the row pointer array of the matrix designated by handle.

uint32_t starpu_bcsr_get_r ( starpu_data_handle_t  handle)

Return the number of rows in a block.

uint32_t starpu_bcsr_get_c ( starpu_data_handle_t  handle)

Return the numberof columns in a block.

size_t starpu_bcsr_get_elemsize ( starpu_data_handle_t  handle)

Return the size of the elements in the matrix designated by handle.

uint32_t starpu_csr_get_nnz ( starpu_data_handle_t  handle)

Return the number of non-zero values in the matrix designated by handle.

uint32_t starpu_csr_get_nrow ( starpu_data_handle_t  handle)

Return the size of the row pointer array of the matrix designated by handle.

uint32_t starpu_csr_get_firstentry ( starpu_data_handle_t  handle)

Return the index at which all arrays (the column indexes, the row pointers...) of the matrix designated by handle.

uintptr_t starpu_csr_get_local_nzval ( starpu_data_handle_t  handle)

Return a local pointer to the non-zero values of the matrix designated by handle.

uint32_t * starpu_csr_get_local_colind ( starpu_data_handle_t  handle)

Return a local pointer to the column index of the matrix designated by handle.

uint32_t * starpu_csr_get_local_rowptr ( starpu_data_handle_t  handle)

Return a local pointer to the row pointer array of the matrix designated by handle.

size_t starpu_csr_get_elemsize ( starpu_data_handle_t  handle)

Return the size of the elements registered into the matrix designated by handle.

uintptr_t starpu_malloc_on_node_flags ( unsigned  dst_node,
size_t  size,
int  flags 
)

Allocate size bytes on node dst_node with the given allocation flags. This returns 0 if allocation failed, the allocation method should then return -ENOMEM as allocated size. Deallocation must be done with starpu_free_on_node.

void starpu_free_on_node_flags ( unsigned  dst_node,
uintptr_t  addr,
size_t  size,
int  flags 
)

Free addr of size bytes on node dst_node which was previously allocated with starpu_malloc_on_node with the given allocation flags.

uintptr_t starpu_malloc_on_node ( unsigned  dst_node,
size_t  size 
)

Allocate size bytes on node dst_node with the default allocation flags. This returns 0 if allocation failed, the allocation method should then return -ENOMEM as allocated size. Deallocation must be done with starpu_free_on_node.

void starpu_free_on_node ( unsigned  dst_node,
uintptr_t  addr,
size_t  size 
)

Free addr of size bytes on node dst_node which was previously allocated with starpu_malloc_on_node.

void starpu_malloc_on_node_set_default_flags ( unsigned  node,
int  flags 
)

Define the defaultflags for allocations performed by starpu_malloc_on_node() and starpu_free_on_node(). The default is STARPU_MALLOC_PINNED | STARPU_MALLOC_COUNT.

int starpu_interface_copy ( uintptr_t  src,
size_t  src_offset,
unsigned  src_node,
uintptr_t  dst,
size_t  dst_offset,
unsigned  dst_node,
size_t  size,
void *  async_data 
)

Copy size bytes from byte offset src_offset of src on src_node to byte offset dst_offset of dst on dst_node. This is to be used in the any_to_any() copy method, which is provided with the async_data to be passed to starpu_interface_copy(). this returns -EAGAIN if the transfer is still ongoing, or 0 if the transfer is already completed.

uint32_t starpu_hash_crc32c_be_n ( const void *  input,
size_t  n,
uint32_t  inputcrc 
)

Compute the CRC of a byte buffer seeded by the inputcrc current state. The return value should be considered as the new current state for future CRC computation. This is used for computing data size footprint.

uint32_t starpu_hash_crc32c_be ( uint32_t  input,
uint32_t  inputcrc 
)

Compute the CRC of a 32bit number seeded by the inputcrc current state. The return value should be considered as the new current state for future CRC computation. This is used for computing data size footprint.

uint32_t starpu_hash_crc32c_string ( const char *  str,
uint32_t  inputcrc 
)

Compute the CRC of a string seeded by the inputcrc current state. The return value should be considered as the new current state for future CRC computation. This is used for computing data size footprint.

int starpu_data_interface_get_next_id ( void  )

Return the next available id for a newly created data interface (Defining A New Data Interface).