7.2
general documentation
cs_base_accel.h File Reference
#include "cs_defs.h"
#include <stdio.h>
#include "bft_mem.h"
+ Include dependency graph for cs_base_accel.h:

Go to the source code of this file.

Macros

#define CS_MALLOC_HD(_ptr, _ni, _type, _mode)
 
#define CS_REALLOC_HD(_ptr, _ni, _type, _mode)
 
#define CS_FREE_HD(_ptr)   cs_free_hd(_ptr, #_ptr, __FILE__, __LINE__), _ptr = NULL
 
#define CS_FREE(_ptr)   cs_free(_ptr, #_ptr, __FILE__, __LINE__), _ptr = NULL
 
#define cs_alloc_mode   CS_ALLOC_HOST
 
#define cs_associate_device_ptr(_host_ptr, _ni, _size)   ;
 Associate device memory with a given host memory pointer. More...
 
#define cs_disassociate_device_ptr(_host_ptr)   ;
 Detach device memory from a given host memory pointer. More...
 
#define cs_set_alloc_mode(_host_ptr, mode)   ;
 Set allocation mode for an already allocated pointer. More...
 

Enumerations

enum  cs_alloc_mode_t {
  CS_ALLOC_HOST, CS_ALLOC_HOST_DEVICE, CS_ALLOC_HOST_DEVICE_PINNED, CS_ALLOC_HOST_DEVICE_SHARED,
  CS_ALLOC_DEVICE
}
 

Functions

static int cs_get_device_id (void)
 Return currently associated device id. More...
 
static void * cs_malloc_hd (cs_alloc_mode_t mode, size_t ni, size_t size, const char *var_name, const char *file_name, int line_num)
 Allocate memory on host and device for ni elements of size bytes. More...
 
static void * cs_realloc_hd (void *ptr, cs_alloc_mode_t mode, size_t ni, size_t size, const char *var_name, const char *file_name, int line_num)
 Reallocate memory on host and device for ni elements of size bytes. More...
 
static void cs_free_hd (void *ptr, const char *var_name, const char *file_name, int line_num)
 Free memory on host and device for a given host pointer. More...
 
static void cs_free (void *ptr, const char *var_name, const char *file_name, int line_num)
 Free memory on host and device for a given pointer. More...
 
static void * cs_get_device_ptr (void *ptr)
 Return matching device pointer for a given pointer. More...
 
static const void * cs_get_device_ptr_const (const void *ptr)
 Return matching device pointer for a given constant pointer. More...
 
static const void * cs_get_device_ptr_const_pf (const void *ptr)
 Return matching device pointer for a given constant pointer, prefetching if applicable. More...
 
static cs_alloc_mode_t cs_check_device_ptr (const void *ptr)
 Check if a pointer is associated with a device. More...
 
static void cs_sync_h2d (const void *ptr)
 Synchronize data from host to device. More...
 
static void cs_sync_h2d_future (const void *ptr)
 Initiate synchronization of data from host to device for future access. More...
 
static void cs_sync_d2h (void *ptr)
 Synchronize data from device to host. More...
 
static void cs_prefetch_h2d (void *ptr, size_t size)
 Prefetch data from host to device. More...
 
static void cs_prefetch_d2h (void *ptr, size_t size)
 Prefetch data from device to host. More...
 
static int cs_get_n_allocations_hd (void)
 Return number of host-device allocations. More...
 
static size_t cs_get_allocation_hd_size (void *host_ptr)
 Check if a given host pointer is allocated with associated with cs_alloc_hd or cs_realloc_hd. More...
 

Macro Definition Documentation

◆ cs_alloc_mode

#define cs_alloc_mode   CS_ALLOC_HOST

◆ cs_associate_device_ptr

#define cs_associate_device_ptr (   _host_ptr,
  _ni,
  _size 
)    ;

Associate device memory with a given host memory pointer.

If the host memory is already associated with the device, the existing device pointer is returned. Otherwise, a new device allocation is called and returned.

Parameters
[in]host_ptrhost pointer
[in]ninumber of elements
[in]sizeelement size
Returns
pointer to allocated memory.

◆ cs_disassociate_device_ptr

#define cs_disassociate_device_ptr (   _host_ptr)    ;

Detach device memory from a given host memory pointer.

If the host memory is shared with the device (i.e. using CS_ALLOC_SHARED), device memory stays shared.

Parameters
[in]host_ptrhost pointer

◆ CS_FREE

#define CS_FREE (   _ptr)    cs_free(_ptr, #_ptr, __FILE__, __LINE__), _ptr = NULL

◆ CS_FREE_HD

#define CS_FREE_HD (   _ptr)    cs_free_hd(_ptr, #_ptr, __FILE__, __LINE__), _ptr = NULL

◆ CS_MALLOC_HD

#define CS_MALLOC_HD (   _ptr,
  _ni,
  _type,
  _mode 
)
Value:
_ptr = (_type *) cs_malloc_hd(_mode, _ni, sizeof(_type), \
#_ptr, __FILE__, __LINE__)
static void * cs_malloc_hd(cs_alloc_mode_t mode, size_t ni, size_t size, const char *var_name, const char *file_name, int line_num)
Allocate memory on host and device for ni elements of size bytes.
Definition: cs_base_accel.h:230

◆ CS_REALLOC_HD

#define CS_REALLOC_HD (   _ptr,
  _ni,
  _type,
  _mode 
)
Value:
_ptr = (_type *) cs_realloc_hd(_ptr, _mode, _ni, sizeof(_type), \
#_ptr, __FILE__, __LINE__)
static void * cs_realloc_hd(void *ptr, cs_alloc_mode_t mode, size_t ni, size_t size, const char *var_name, const char *file_name, int line_num)
Reallocate memory on host and device for ni elements of size bytes.
Definition: cs_base_accel.h:287

◆ cs_set_alloc_mode

#define cs_set_alloc_mode (   _host_ptr,
  mode 
)    ;

Set allocation mode for an already allocated pointer.

If the allocation mode is different from the previous one, the associated memory will be reallocated with the desired mode, and the previous allocation freed.

Parameters
[in,out]host_ptrpointer to host pointer to modify
[in]modedesired allocation mode

Enumeration Type Documentation

◆ cs_alloc_mode_t

Allocation modes for accelerated code.

Enumerator
CS_ALLOC_HOST 

allocation on host only

CS_ALLOC_HOST_DEVICE 

allocation on host and device

CS_ALLOC_HOST_DEVICE_PINNED 

allocation on host and device, using page-locked memory on host if possible

CS_ALLOC_HOST_DEVICE_SHARED 

allocation on host and device, using mapped/shared memory

CS_ALLOC_DEVICE 

allocation on device only

Function Documentation

◆ cs_check_device_ptr()

static cs_alloc_mode_t cs_check_device_ptr ( const void *  ptr)
inlinestatic

Check if a pointer is associated with a device.

If separate pointers are used on the host and device, the host pointer should be used with this function.

Returns
allocation mode associated with pointer

◆ cs_free()

static void cs_free ( void *  ptr,
const char *  var_name,
const char *  file_name,
int  line_num 
)
inlinestatic

Free memory on host and device for a given pointer.

Compared to , this function also allows freeing memory allocated through BFT_MEM_MALLOC / bft_mem_malloc.

Parameters
[in]ptrpointer to free
[in]var_nameallocated variable name string
[in]file_namename of calling source file
[in]line_numline number in calling source file

◆ cs_free_hd()

static void cs_free_hd ( void *  ptr,
const char *  var_name,
const char *  file_name,
int  line_num 
)
inlinestatic

Free memory on host and device for a given host pointer.

If separate pointers are used on the host and device, the host pointer should be used with this function.

Parameters
[in]ptrpointer to free
[in]var_nameallocated variable name string
[in]file_namename of calling source file
[in]line_numline number in calling source file

◆ cs_get_allocation_hd_size()

static size_t cs_get_allocation_hd_size ( void *  host_ptr)
inlinestatic

Check if a given host pointer is allocated with associated with cs_alloc_hd or cs_realloc_hd.

Returns
allocated memory size, or zero if not allocated with this mechanism.

◆ cs_get_device_id()

static int cs_get_device_id ( void  )
inlinestatic

Return currently associated device id.

Returns
currently available device id, or -1 if none is available.

◆ cs_get_device_ptr()

static void* cs_get_device_ptr ( void *  ptr)
inlinestatic

Return matching device pointer for a given pointer.

If separate pointers are used on the host and device, the host pointer should be used with this function.

If memory is not allocated on device yet at the call site, it will be allocated automatically by this function.

Parameters
[in]ptrpointer
Returns
pointer to device memory.

◆ cs_get_device_ptr_const()

static const void* cs_get_device_ptr_const ( const void *  ptr)
inlinestatic

Return matching device pointer for a given constant pointer.

If separate pointers are used on the host and device, the host pointer should be used with this function.

If memory is not allocated on device yet at the call site, it will be allocated automatically by this function.

Parameters
[in]ptrpointer
Returns
pointer to device memory.

◆ cs_get_device_ptr_const_pf()

static const void* cs_get_device_ptr_const_pf ( const void *  ptr)
inlinestatic

Return matching device pointer for a given constant pointer, prefetching if applicable.

If separate pointers are used on the host and device, the host pointer should be used with this function. In this case, it is assumed that the host and device values have already been synchronized, unless memory is not allocated on device yet at the call site, in which case it will be allocated automatically by this function.

Parameters
[in]ptrpointer
Returns
pointer to device memory.

◆ cs_get_n_allocations_hd()

static int cs_get_n_allocations_hd ( void  )
inlinestatic

Return number of host-device allocations.

Returns
current number of host-device allocations.

◆ cs_malloc_hd()

static void* cs_malloc_hd ( cs_alloc_mode_t  mode,
size_t  ni,
size_t  size,
const char *  var_name,
const char *  file_name,
int  line_num 
)
inlinestatic

Allocate memory on host and device for ni elements of size bytes.

This function calls the appropriate allocation function based on the requested mode, and allows introspection of the allocated memory.

If separate pointers are used on the host and device, the host pointer is returned.

Parameters
[in]modeallocation mode
[in]ninumber of elements
[in]sizeelement size
[in]var_nameallocated variable name string
[in]file_namename of calling source file
[in]line_numline number in calling source file
Returns
pointer to allocated memory.

◆ cs_prefetch_d2h()

static void cs_prefetch_d2h ( void *  ptr,
size_t  size 
)
inlinestatic

Prefetch data from device to host.

This function should only be used on arrays using shared host and device memory, shuch as those allocated using CS_ALLOC_HOST_DEVICE_SHARED. It should be usable on a subset of such an array.

Parameters
[in,out]ptrpointer to data to prefetch
[in]sizenumber of bytes to prefetch

◆ cs_prefetch_h2d()

static void cs_prefetch_h2d ( void *  ptr,
size_t  size 
)
inlinestatic

Prefetch data from host to device.

This function should only be used on arrays using shared host and device memory, shuch as those allocated using CS_ALLOC_HOST_DEVICE_SHARED. It should be usable on a subset of such an array.

Parameters
[in,out]ptrpointer to data to prefetch
[in]sizenumber of bytes to prefetch

◆ cs_realloc_hd()

static void* cs_realloc_hd ( void *  ptr,
cs_alloc_mode_t  mode,
size_t  ni,
size_t  size,
const char *  var_name,
const char *  file_name,
int  line_num 
)
inlinestatic

Reallocate memory on host and device for ni elements of size bytes.

This function calls the appropriate reallocation function based on the requested mode, and allows introspection of the allocated memory.

If separate pointers are used on the host and device, the host pointer should be used with this function.

If the allocation parameters are unchanged, no actual reallocation occurs on the host.

If the device uses a separate allocation, it is freed, and a new allocation is delayed (as per initial allocation) so as to invalidate copies which will not be up to date anymore after the associated values modification.

Parameters
[in]ptrpointer to previously allocated memory
[in]modeallocation mode
[in]ninumber of elements
[in]sizeelement size
[in]var_nameallocated variable name string
[in]file_namename of calling source file
[in]line_numline number in calling source file
Returns
pointer to allocated memory.

◆ cs_sync_d2h()

static void cs_sync_d2h ( void *  ptr)
inlinestatic

Synchronize data from device to host.

If separate allocations are used on the host and device (mode == CS_ALLOC_HOST_DEVICE), the host pointer should be passed to this function.

Depending on the allocaton type, this can imply a copy, data prefetch, or a no-op.

This function assumes the provided pointer was allocated using CS_MALLOC_HD or CS_REALLOC_HD, as it uses the associated mapping to determine associated metadata.

Parameters
[in,out]ptrpointer to values to copy or prefetch

◆ cs_sync_h2d()

static void cs_sync_h2d ( const void *  ptr)
inlinestatic

Synchronize data from host to device.

If separate pointers are used on the host and device, the host pointer should be used with this function.

Depending on the allocation type, this can imply a copy, data prefetch, or a no-op.

This function assumes the provided pointer was allocated using CS_MALLOC_HD or CS_REALLOC_HD, as it uses the associated mapping to determine associated metadata.

Parameters
[in,out]ptrhost pointer to values to copy or prefetch

◆ cs_sync_h2d_future()

static void cs_sync_h2d_future ( const void *  ptr)
inlinestatic

Initiate synchronization of data from host to device for future access.

If separate pointers are used on the host and device, the host pointer should be used with this function. In this case, synchronization is started (asynchronously if the allocation mode supports it).

In other cases, synchronization will be delayed until actual use. the host pointer should be used with this function.

Depending on the allocation type, this can imply a copy, data prefetch, or a no-op.

This function assumes the provided pointer was allocated using CS_MALLOC_HD or CS_REALLOC_HD, as it uses the associated mapping to determine associated metadata.

Parameters
[in,out]ptrhost pointer to values to copy or prefetch