StarPU Handbook
|
Macros | |
#define | starpu_data_malloc_pinned_if_possible |
#define | starpu_data_free_pinned_if_possible |
#define | STARPU_MALLOC_PINNED |
#define | STARPU_MALLOC_COUNT |
#define | STARPU_MALLOC_NORECLAIM |
Functions | |
int | starpu_malloc_flags (void **A, size_t dim, int flags) |
void | starpu_malloc_set_align (size_t align) |
int | starpu_malloc (void **A, size_t dim) |
int | starpu_free (void *A) |
int | starpu_free_flags (void *A, size_t dim, int flags) |
starpu_ssize_t | starpu_memory_get_total (unsigned node) |
starpu_ssize_t | starpu_memory_get_available (unsigned node) |
int | starpu_memory_allocate (unsigned node, size_t size, int flags) |
void | starpu_memory_deallocate (unsigned node, size_t size) |
#define starpu_data_malloc_pinned_if_possible |
#define starpu_data_free_pinned_if_possible |
#define STARPU_MALLOC_PINNED |
Value passed to the function starpu_malloc_flags() to indicate the memory allocation should be pinned.
#define STARPU_MALLOC_COUNT |
Value passed to the function starpu_malloc_flags() to indicate the memory allocation should be in the limit defined by the environment variables STARPU_LIMIT_CUDA_devid_MEM, STARPU_LIMIT_CUDA_MEM, STARPU_LIMIT_OPENCL_devid_MEM, STARPU_LIMIT_OPENCL_MEM and STARPU_LIMIT_CPU_MEM (see Section How to limit memory per node). If no memory is available, it tries to reclaim memory from StarPU. Memory allocated this way needs to be freed by calling the function starpu_free_flags() with the same flag.
#define STARPU_MALLOC_NORECLAIM |
Value passed to the function starpu_malloc_flags() along STARPU_MALLOC_COUNT to indicate that while the memory allocation should be kept in the limits defined for STARPU_MALLOC_COUNT, no reclaiming should be performed by starpu_malloc_flags itself, thus potentially overflowing the memory node a bit. StarPU will reclaim memory after next task termination, according to the STARPU_MINIMUM_AVAILABLE_MEM and STARPU_TARGET_AVAILABLE_MEM environment variables.
int starpu_malloc_flags | ( | void ** | A, |
size_t | dim, | ||
int | flags | ||
) |
Performs a memory allocation based on the constraints defined by the given flag.
void starpu_malloc_set_align | ( | size_t | align | ) |
This function sets an alignment constraints for starpu_malloc() allocations. align must be a power of two. This is for instance called automatically by the OpenCL driver to specify its own alignment constraints.
int starpu_malloc | ( | void ** | A, |
size_t | dim | ||
) |
This function allocates data of the given size in main memory. It will also try to pin it in CUDA or OpenCL, so that data transfers from this buffer can be asynchronous, and thus permit data transfer and computation overlapping. The allocated buffer must be freed thanks to the starpu_free() function.
int starpu_free | ( | void * | A | ) |
This function frees memory which has previously been allocated with starpu_malloc().
int starpu_free_flags | ( | void * | A, |
size_t | dim, | ||
int | flags | ||
) |
This function frees memory by specifying its size. The given flags should be consistent with the ones given to starpu_malloc_flags() when allocating the memory.
ssize_t starpu_memory_get_total | ( | unsigned | node | ) |
If a memory limit is defined on the given node (see Section How to limit memory per node), return the amount of total memory on the node. Otherwise return -1.
ssize_t starpu_memory_get_available | ( | unsigned | node | ) |
If a memory limit is defined on the given node (see Section How to limit memory per node), return the amount of available memory on the node. Otherwise return -1.
int starpu_memory_allocate | ( | unsigned | node, |
size_t | size, | ||
int | flags | ||
) |
Try to allocate memory on the given node
size | amount of memory to allocate |
node | node where the memory is to be allocated |
If a memory limit is defined on the given node (see Section How to limit memory per node), try to allocate some of it. This does not actually allocate memory, but only accounts for it. This can be useful when the application allocates data another way, but want StarPU to be aware of the allocation size e.g. for memory reclaiming. By default, the function returns -ENOMEM if there is not enough room on the given node. flags
can be either STARPU_MEMORY_MANAGER_WAIT or STARPU_MEMORY_MANAGER_OVERFLOW to change this.
int starpu_memory_deallocate | ( | unsigned | node, |
size_t | size | ||
) |
Indicates the given amount of memory is going to be deallocated from the given node
size | amount of memory to be deallocated |
node | node where the memory is going to be deallocated |
If a memory limit is defined on the given node (see Section How to limit memory per node), free some of it. This does not actually free memory, but only accounts for it, like starpu_memory_allocate(). The amount does not have to be exactly the same as what was passed to starpu_memory_allocate(), only the eventual amount needs to be the same, i.e. one call to starpu_memory_allocate() can be followed by several calls to starpu_memory_deallocate() to declare the deallocation piece by piece.