device.h

Go to the documentation of this file.

/*******************************************************
 * Copyright (c) 2014, ArrayFire
 * All rights reserved.
 *
 * This file is distributed under 3-clause BSD license.
 * The complete license agreement can be obtained at:
 * http://arrayfire.com/licenses/BSD-3-Clause
 ********************************************************/
 
#pragma once
#include <af/defines.h>
 
#ifdef __cplusplus
namespace af
{
    AFAPI void info();
    AFAPI const char* infoString(const bool verbose = false);
    AFAPI void deviceInfo(char* d_name, char* d_platform, char *d_toolkit, char* d_compute);
 
    AFAPI int getDeviceCount();
 
    AFAPI int getDevice();
 
    AFAPI bool isDoubleAvailable(const int device);
 
    AFAPI bool isHalfAvailable(const int device);
 
    AFAPI void setDevice(const int device);
 
    AFAPI void sync(const int device = -1);
 
    AF_DEPRECATED("Use af::allocV2 instead")
    AFAPI void *alloc(const size_t elements, const dtype type);
 
#if AF_API_VERSION >= 38
    AFAPI void *allocV2(const size_t bytes);
#endif
 
    //
    template <typename T>
    AF_DEPRECATED("Use af::allocV2 instead")
    T *alloc(const size_t elements);
 
    AF_DEPRECATED("Use af::freeV2 instead")
    AFAPI void free(const void *ptr);
 
#if AF_API_VERSION >= 38
    AFAPI void freeV2(const void *ptr);
#endif
 
    AFAPI void *pinned(const size_t elements, const dtype type);
 
    template<typename T>
    T* pinned(const size_t elements);
 
    AFAPI void freePinned(const void *ptr);
 
#if AF_API_VERSION >= 33
    AFAPI void *allocHost(const size_t elements, const dtype type);
#endif
 
#if AF_API_VERSION >= 33
    template<typename T>
    AFAPI T* allocHost(const size_t elements);
#endif
 
#if AF_API_VERSION >= 33
    //
    AFAPI void freeHost(const void *ptr);
#endif
 
    //                          manager
    //                              manager
    AFAPI void deviceMemInfo(size_t *alloc_bytes, size_t *alloc_buffers,
                             size_t *lock_bytes, size_t *lock_buffers);
 
#if AF_API_VERSION >= 33
    //
    //
    AFAPI void printMemInfo(const char *msg = NULL, const int device_id = -1);
#endif
 
    AFAPI void deviceGC();
 
    AFAPI void setMemStepSize(const size_t size);
 
    AFAPI size_t getMemStepSize();
}
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
    AFAPI af_err af_info();
 
    AFAPI af_err af_init();
 
    AFAPI af_err af_info_string(char** str, const bool verbose);
 
    AFAPI af_err af_device_info(char* d_name, char* d_platform, char *d_toolkit, char* d_compute);
 
    AFAPI af_err af_get_device_count(int *num_of_devices);
 
    AFAPI af_err af_get_dbl_support(bool* available, const int device);
 
    AFAPI af_err af_get_half_support(bool *available, const int device);
 
    AFAPI af_err af_set_device(const int device);
 
    AFAPI af_err af_get_device(int *device);
 
    AFAPI af_err af_sync(const int device);
 
    AF_DEPRECATED("Use af_alloc_device_v2 instead")
    AFAPI af_err af_alloc_device(void **ptr, const dim_t bytes);
 
    AF_DEPRECATED("Use af_free_device_v2 instead")
    AFAPI af_err af_free_device(void *ptr);
 
#if AF_API_VERSION >= 38
    AFAPI af_err af_alloc_device_v2(void **ptr, const dim_t bytes);
 
    AFAPI af_err af_free_device_v2(void *ptr);
#endif
    AFAPI af_err af_alloc_pinned(void **ptr, const dim_t bytes);
 
    AFAPI af_err af_free_pinned(void *ptr);
 
#if AF_API_VERSION >= 33
    AFAPI af_err af_alloc_host(void **ptr, const dim_t bytes);
#endif
 
#if AF_API_VERSION >= 33
    AFAPI af_err af_free_host(void *ptr);
#endif
 
    AFAPI af_err af_device_array(af_array *arr, void *data, const unsigned ndims, const dim_t * const dims, const af_dtype type);
 
    AFAPI af_err af_device_mem_info(size_t *alloc_bytes, size_t *alloc_buffers,
                                    size_t *lock_bytes, size_t *lock_buffers);
 
#if AF_API_VERSION >= 33
    AFAPI af_err af_print_mem_info(const char *msg, const int device_id);
#endif
 
    AFAPI af_err af_device_gc();
 
    AFAPI af_err af_set_mem_step_size(const size_t step_bytes);
 
    AFAPI af_err af_get_mem_step_size(size_t *step_bytes);
 
#if AF_API_VERSION >= 31
#if AF_API_VERSION >= 33
    AF_DEPRECATED("Use af_lock_array instead")
#endif
    AFAPI af_err af_lock_device_ptr(const af_array arr);
#endif
 
#if AF_API_VERSION >= 31
#if AF_API_VERSION >= 33
    AF_DEPRECATED("Use af_unlock_array instead")
#endif
    AFAPI af_err af_unlock_device_ptr(const af_array arr);
#endif
 
#if AF_API_VERSION >= 33
    AFAPI af_err af_lock_array(const af_array arr);
#endif
 
#if AF_API_VERSION >= 33
    AFAPI af_err af_unlock_array(const af_array arr);
#endif
 
#if AF_API_VERSION >= 34
    AFAPI af_err af_is_locked_array(bool *res, const af_array arr);
#endif
 
    AFAPI af_err af_get_device_ptr(void **ptr, const af_array arr);
 
#if AF_API_VERSION >= 38
    AFAPI af_err af_set_kernel_cache_directory(const char* path,
                                               int override_env);
 
    AFAPI af_err af_get_kernel_cache_directory(size_t *length, char *path);
 
#endif
 
#ifdef __cplusplus
}
#endif