[arrayfire] 266/284: Cleaning up internal API for memory functions
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Sun Feb 7 18:59:40 UTC 2016
This is an automated email from the git hooks/post-receive script.
ghisvail-guest pushed a commit to branch debian/experimental
in repository arrayfire.
commit 5183a357535d10fef63862f74608bc5a5f82eadb
Author: Pavan Yalamanchili <pavan at arrayfire.com>
Date: Tue Feb 2 19:11:02 2016 -0500
Cleaning up internal API for memory functions
- Also Split up device.cpp and memory.cpp
---
include/af/device.h | 3 +
src/api/c/device.cpp | 243 -----------------------------------
src/api/c/{device.cpp => memory.cpp} | 145 +--------------------
src/backend/MemoryManager.cpp | 9 +-
src/backend/MemoryManager.hpp | 7 +-
src/backend/cpu/memory.cpp | 30 +++--
src/backend/cpu/memory.hpp | 10 +-
src/backend/cuda/memory.cpp | 38 +++---
src/backend/cuda/memory.hpp | 11 +-
src/backend/opencl/memory.cpp | 42 +++---
src/backend/opencl/memory.hpp | 13 +-
11 files changed, 94 insertions(+), 457 deletions(-)
diff --git a/include/af/device.h b/include/af/device.h
index c0d787e..b08bd51 100644
--- a/include/af/device.h
+++ b/include/af/device.h
@@ -200,6 +200,8 @@ namespace af
// manager
/// \param[out] lock_bytes The number of bytes in use
/// \param[out] lock_buffers The number of buffers in use
+ ///
+ /// \note This function performs a synchronization operation
AFAPI void deviceMemInfo(size_t *alloc_bytes, size_t *alloc_buffers,
size_t *lock_bytes, size_t *lock_buffers);
@@ -213,6 +215,7 @@ namespace af
//
/// \ingroup device_func_mem
///
+ /// \note This function performs a synchronization operation
AFAPI void printMemInfo(const char *msg = NULL, const int device_id = -1);
#endif
diff --git a/src/api/c/device.cpp b/src/api/c/device.cpp
index e3ec476..304d0c7 100644
--- a/src/api/c/device.cpp
+++ b/src/api/c/device.cpp
@@ -15,7 +15,6 @@
#include <platform.hpp>
#include <Array.hpp>
#include <handle.hpp>
-#include <memory.hpp>
#include "err_common.hpp"
#include <cstring>
@@ -156,245 +155,3 @@ af_err af_sync(const int device)
} CATCHALL;
return AF_SUCCESS;
}
-
-af_err af_device_array(af_array *arr, const void *data,
- const unsigned ndims,
- const dim_t * const dims,
- const af_dtype type)
-{
- try {
- AF_CHECK(af_init());
-
- af_array res;
-
- DIM_ASSERT(1, ndims >= 1);
- dim4 d(1, 1, 1, 1);
- for(unsigned i = 0; i < ndims; i++) {
- d[i] = dims[i];
- DIM_ASSERT(3, dims[i] >= 1);
- }
-
- switch (type) {
- case f32: res = getHandle(createDeviceDataArray<float >(d, data)); break;
- case f64: res = getHandle(createDeviceDataArray<double >(d, data)); break;
- case c32: res = getHandle(createDeviceDataArray<cfloat >(d, data)); break;
- case c64: res = getHandle(createDeviceDataArray<cdouble>(d, data)); break;
- case s32: res = getHandle(createDeviceDataArray<int >(d, data)); break;
- case u32: res = getHandle(createDeviceDataArray<uint >(d, data)); break;
- case s64: res = getHandle(createDeviceDataArray<intl >(d, data)); break;
- case u64: res = getHandle(createDeviceDataArray<uintl >(d, data)); break;
- case s16: res = getHandle(createDeviceDataArray<short >(d, data)); break;
- case u16: res = getHandle(createDeviceDataArray<ushort >(d, data)); break;
- case u8 : res = getHandle(createDeviceDataArray<uchar >(d, data)); break;
- case b8 : res = getHandle(createDeviceDataArray<char >(d, data)); break;
- default: TYPE_ERROR(4, type);
- }
-
- std::swap(*arr, res);
- } CATCHALL;
-
- return AF_SUCCESS;
-}
-
-af_err af_get_device_ptr(void **data, const af_array arr)
-{
- try {
- af_dtype type = getInfo(arr).getType();
-
- switch (type) {
- //FIXME: Perform copy if memory not continuous
- case f32: *data = getDevicePtr(getArray<float >(arr)); break;
- case f64: *data = getDevicePtr(getArray<double >(arr)); break;
- case c32: *data = getDevicePtr(getArray<cfloat >(arr)); break;
- case c64: *data = getDevicePtr(getArray<cdouble>(arr)); break;
- case s32: *data = getDevicePtr(getArray<int >(arr)); break;
- case u32: *data = getDevicePtr(getArray<uint >(arr)); break;
- case s64: *data = getDevicePtr(getArray<intl >(arr)); break;
- case u64: *data = getDevicePtr(getArray<uintl >(arr)); break;
- case s16: *data = getDevicePtr(getArray<short >(arr)); break;
- case u16: *data = getDevicePtr(getArray<ushort >(arr)); break;
- case u8 : *data = getDevicePtr(getArray<uchar >(arr)); break;
- case b8 : *data = getDevicePtr(getArray<char >(arr)); break;
-
- default: TYPE_ERROR(4, type);
- }
-
- } CATCHALL;
-
- return AF_SUCCESS;
-}
-
-template <typename T>
-inline void lockArray(const af_array arr)
-{
- memLock<T>((const T *)getArray<T>(arr).get());
-}
-
-af_err af_lock_device_ptr(const af_array arr)
-{
- return af_lock_array(arr);
-}
-
-af_err af_lock_array(const af_array arr)
-{
- try {
- af_dtype type = getInfo(arr).getType();
-
- switch (type) {
- case f32: lockArray<float >(arr); break;
- case f64: lockArray<double >(arr); break;
- case c32: lockArray<cfloat >(arr); break;
- case c64: lockArray<cdouble>(arr); break;
- case s32: lockArray<int >(arr); break;
- case u32: lockArray<uint >(arr); break;
- case s64: lockArray<intl >(arr); break;
- case u64: lockArray<uintl >(arr); break;
- case s16: lockArray<short >(arr); break;
- case u16: lockArray<ushort >(arr); break;
- case u8 : lockArray<uchar >(arr); break;
- case b8 : lockArray<char >(arr); break;
- default: TYPE_ERROR(4, type);
- }
-
- } CATCHALL;
-
- return AF_SUCCESS;
-}
-
-template <typename T>
-inline void unlockArray(const af_array arr)
-{
- memUnlock<T>((const T *)getArray<T>(arr).get());
-}
-
-af_err af_unlock_device_ptr(const af_array arr)
-{
- return af_unlock_array(arr);
-}
-
-af_err af_unlock_array(const af_array arr)
-{
- try {
- af_dtype type = getInfo(arr).getType();
-
- switch (type) {
- case f32: unlockArray<float >(arr); break;
- case f64: unlockArray<double >(arr); break;
- case c32: unlockArray<cfloat >(arr); break;
- case c64: unlockArray<cdouble>(arr); break;
- case s32: unlockArray<int >(arr); break;
- case u32: unlockArray<uint >(arr); break;
- case s64: unlockArray<intl >(arr); break;
- case u64: unlockArray<uintl >(arr); break;
- case s16: unlockArray<short >(arr); break;
- case u16: unlockArray<ushort >(arr); break;
- case u8 : unlockArray<uchar >(arr); break;
- case b8 : unlockArray<char >(arr); break;
- default: TYPE_ERROR(4, type);
- }
-
- } CATCHALL;
-
- return AF_SUCCESS;
-}
-
-
-af_err af_alloc_device(void **ptr, const dim_t bytes)
-{
- try {
- AF_CHECK(af_init());
- *ptr = (void *)memAlloc<char>(bytes);
- memLock<char>((const char *)*ptr);
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_alloc_pinned(void **ptr, const dim_t bytes)
-{
- try {
- AF_CHECK(af_init());
- *ptr = (void *)pinnedAlloc<char>(bytes);
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_free_device(void *ptr)
-{
- try {
- memFreeLocked<char>((char *)ptr, true);
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_free_pinned(void *ptr)
-{
- try {
- pinnedFree<char>((char *)ptr);
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_alloc_host(void **ptr, const dim_t bytes)
-{
- try {
- *ptr = malloc(bytes);
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_free_host(void *ptr)
-{
- try {
- free(ptr);
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_print_mem_info(const char *msg, const int device_id)
-{
- try {
- int device = device_id;
- if(device == -1) {
- device = getActiveDeviceId();
- }
-
- if(msg != NULL) ARG_ASSERT(0, strlen(msg) < 256); // 256 character limit on msg
- ARG_ASSERT(1, device >= 0 && device < getDeviceCount());
-
- printMemInfo(msg ? msg : "", device);
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_device_gc()
-{
- try {
- garbageCollect();
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_device_mem_info(size_t *alloc_bytes, size_t *alloc_buffers,
- size_t *lock_bytes, size_t *lock_buffers)
-{
- try {
- deviceMemoryInfo(alloc_bytes, alloc_buffers, lock_bytes, lock_buffers);
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_set_mem_step_size(const size_t step_bytes)
-{
- try{
- detail::setMemStepSize(step_bytes);
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_get_mem_step_size(size_t *step_bytes)
-{
- try {
- *step_bytes = detail::getMemStepSize();
- } CATCHALL;
- return AF_SUCCESS;
-}
diff --git a/src/api/c/device.cpp b/src/api/c/memory.cpp
similarity index 72%
copy from src/api/c/device.cpp
copy to src/api/c/memory.cpp
index e3ec476..098665b 100644
--- a/src/api/c/device.cpp
+++ b/src/api/c/memory.cpp
@@ -21,142 +21,6 @@
using namespace detail;
-af_err af_set_backend(const af_backend bknd)
-{
- try {
- ARG_ASSERT(0, bknd==getBackend());
- }
- CATCHALL;
-
- return AF_SUCCESS;
-}
-
-af_err af_get_backend_count(unsigned* num_backends)
-{
- *num_backends = 1;
- return AF_SUCCESS;
-}
-
-af_err af_get_available_backends(int* result)
-{
- try {
- *result = getBackend();
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_get_backend_id(af_backend *result, const af_array in)
-{
- try {
- ARG_ASSERT(1, in != 0);
- ArrayInfo info = getInfo(in);
- *result = info.getBackendId();
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_get_active_backend(af_backend *result)
-{
- *result = (af_backend)getBackend();
- return AF_SUCCESS;
-}
-
-af_err af_init()
-{
- try {
- static bool first = true;
- if(first) {
- getInfo();
- first = false;
- }
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_info()
-{
- try {
- printf("%s", getInfo().c_str());
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_info_string(char **str, const bool verbose)
-{
- try {
- std::string infoStr = getInfo();
- af_alloc_host((void**)str, sizeof(char) * (infoStr.size() + 1));
-
- // Need to do a deep copy
- // str.c_str wont cut it
- infoStr.copy(*str, infoStr.size());
- (*str)[infoStr.size()] = '\0';
- } CATCHALL;
-
- return AF_SUCCESS;
-}
-
-af_err af_get_version(int *major, int *minor, int *patch)
-{
- *major = AF_VERSION_MAJOR;
- *minor = AF_VERSION_MINOR;
- *patch = AF_VERSION_PATCH;
-
- return AF_SUCCESS;
-}
-
-af_err af_device_info(char* d_name, char* d_platform, char *d_toolkit, char* d_compute)
-{
- try {
- devprop(d_name, d_platform, d_toolkit, d_compute);
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_get_dbl_support(bool* available, const int device)
-{
- try {
- *available = isDoubleSupported(device);
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_get_device_count(int *nDevices)
-{
- try {
- *nDevices = getDeviceCount();
- } CATCHALL;
-
- return AF_SUCCESS;
-}
-
-af_err af_get_device(int *device)
-{
- try {
- *device = getActiveDeviceId();
- } CATCHALL;
- return AF_SUCCESS;
-}
-
-af_err af_set_device(const int device)
-{
- try {
- ARG_ASSERT(0, device >= 0);
- ARG_ASSERT(0, setDevice(device) >= 0);
- } CATCHALL;
-
- return AF_SUCCESS;
-}
-
-af_err af_sync(const int device)
-{
- try {
- int dev = device == -1 ? getActiveDeviceId() : device;
- detail::sync(dev);
- } CATCHALL;
- return AF_SUCCESS;
-}
-
af_err af_device_array(af_array *arr, const void *data,
const unsigned ndims,
const dim_t * const dims,
@@ -227,7 +91,7 @@ af_err af_get_device_ptr(void **data, const af_array arr)
template <typename T>
inline void lockArray(const af_array arr)
{
- memLock<T>((const T *)getArray<T>(arr).get());
+ memLock((void *)getArray<T>(arr).get());
}
af_err af_lock_device_ptr(const af_array arr)
@@ -264,7 +128,7 @@ af_err af_lock_array(const af_array arr)
template <typename T>
inline void unlockArray(const af_array arr)
{
- memUnlock<T>((const T *)getArray<T>(arr).get());
+ memUnlock((void *)getArray<T>(arr).get());
}
af_err af_unlock_device_ptr(const af_array arr)
@@ -303,8 +167,7 @@ af_err af_alloc_device(void **ptr, const dim_t bytes)
{
try {
AF_CHECK(af_init());
- *ptr = (void *)memAlloc<char>(bytes);
- memLock<char>((const char *)*ptr);
+ *ptr = memAllocUser(bytes);
} CATCHALL;
return AF_SUCCESS;
}
@@ -321,7 +184,7 @@ af_err af_alloc_pinned(void **ptr, const dim_t bytes)
af_err af_free_device(void *ptr)
{
try {
- memFreeLocked<char>((char *)ptr, true);
+ memFreeUser(ptr);
} CATCHALL;
return AF_SUCCESS;
}
diff --git a/src/backend/MemoryManager.cpp b/src/backend/MemoryManager.cpp
index d82436e..5773c19 100644
--- a/src/backend/MemoryManager.cpp
+++ b/src/backend/MemoryManager.cpp
@@ -19,7 +19,6 @@
namespace common
{
-const size_t ONE_GB = 1 << 30;
MemoryManager::MemoryManager(int num_devices, unsigned MAX_BUFFERS, bool debug):
mem_step_size(1024),
max_buffers(MAX_BUFFERS),
@@ -115,7 +114,7 @@ void MemoryManager::unlock(void *ptr, bool user_unlock)
}
}
-void *MemoryManager::alloc(const size_t bytes)
+void *MemoryManager::alloc(const size_t bytes, bool user_lock)
{
lock_guard_t lock(this->memory_mutex);
@@ -277,4 +276,10 @@ void MemoryManager::bufferInfo(size_t *alloc_bytes, size_t *alloc_buffers,
if (lock_bytes ) *lock_bytes = current.lock_bytes;
if (lock_buffers ) *lock_buffers = current.lock_buffers;
}
+
+unsigned MemoryManager::getMaxBuffers()
+{
+ return this->max_buffers;
+}
+
}
diff --git a/src/backend/MemoryManager.hpp b/src/backend/MemoryManager.hpp
index faae7fa..a010f30 100644
--- a/src/backend/MemoryManager.hpp
+++ b/src/backend/MemoryManager.hpp
@@ -19,6 +19,9 @@ namespace common
typedef std::recursive_mutex mutex_t;
typedef std::lock_guard<mutex_t> lock_guard_t;
+const unsigned MAX_BUFFERS = 1000;
+const size_t ONE_GB = 1 << 30;
+
class MemoryManager
{
typedef struct
@@ -65,7 +68,7 @@ public:
void setMaxMemorySize();
- void *alloc(const size_t bytes);
+ void *alloc(const size_t bytes, bool user_lock);
void unlock(void *ptr, bool user_unlock);
@@ -84,6 +87,8 @@ public:
size_t getMaxBytes();
+ unsigned getMaxBuffers();
+
void setMemStepSize(size_t new_step_size);
virtual void *nativeAlloc(const size_t bytes)
diff --git a/src/backend/cpu/memory.cpp b/src/backend/cpu/memory.cpp
index 8a89cb1..016428a 100644
--- a/src/backend/cpu/memory.cpp
+++ b/src/backend/cpu/memory.cpp
@@ -55,7 +55,7 @@ size_t MemoryManager::getMaxMemorySize(int id)
}
MemoryManager::MemoryManager() :
- common::MemoryManager(getDeviceCount(), MAX_BUFFERS, AF_MEM_DEBUG || AF_CPU_MEM_DEBUG)
+ common::MemoryManager(getDeviceCount(), common::MAX_BUFFERS, AF_MEM_DEBUG || AF_CPU_MEM_DEBUG)
{
this->setMaxMemorySize();
}
@@ -94,6 +94,11 @@ size_t getMaxBytes()
return getMemoryManager().getMaxBytes();
}
+unsigned getMaxBuffers()
+{
+ return getMemoryManager().getMaxBuffers();
+}
+
void garbageCollect()
{
getMemoryManager().garbageCollect();
@@ -107,34 +112,34 @@ void printMemInfo(const char *msg, const int device)
template<typename T>
T* memAlloc(const size_t &elements)
{
- return (T *)getMemoryManager().alloc(elements * sizeof(T));
+ return (T *)getMemoryManager().alloc(elements * sizeof(T), false);
}
+void* memAllocUser(const size_t &bytes)
+{
+ return getMemoryManager().alloc(bytes, true);
+}
template<typename T>
void memFree(T *ptr)
{
return getMemoryManager().unlock((void *)ptr, false);
}
-template<typename T>
-void memFreeLocked(T *ptr, bool user_unlock)
+void memFreeUser(void *ptr)
{
- getMemoryManager().unlock((void *)ptr, user_unlock);
+ getMemoryManager().unlock((void *)ptr, true);
}
-template<typename T>
-void memLock(const T *ptr)
+void memLock(const void *ptr)
{
getMemoryManager().userLock((void *)ptr);
}
-template<typename T>
-void memUnlock(const T *ptr)
+void memUnlock(const void *ptr)
{
getMemoryManager().userUnlock((void *)ptr);
}
-
void deviceMemoryInfo(size_t *alloc_bytes, size_t *alloc_buffers,
size_t *lock_bytes, size_t *lock_buffers)
{
@@ -146,7 +151,7 @@ void deviceMemoryInfo(size_t *alloc_bytes, size_t *alloc_buffers,
template<typename T>
T* pinnedAlloc(const size_t &elements)
{
- return (T *)getMemoryManager().alloc(elements * sizeof(T));
+ return (T *)getMemoryManager().alloc(elements * sizeof(T), false);
}
template<typename T>
@@ -158,9 +163,6 @@ void pinnedFree(T* ptr)
#define INSTANTIATE(T) \
template T* memAlloc(const size_t &elements); \
template void memFree(T* ptr); \
- template void memFreeLocked(T* ptr, bool user_unlock); \
- template void memLock(const T* ptr); \
- template void memUnlock(const T* ptr); \
template T* pinnedAlloc(const size_t &elements); \
template void pinnedFree(T* ptr); \
diff --git a/src/backend/cpu/memory.hpp b/src/backend/cpu/memory.hpp
index 8f61f11..80ee86d 100644
--- a/src/backend/cpu/memory.hpp
+++ b/src/backend/cpu/memory.hpp
@@ -13,22 +13,22 @@
namespace cpu
{
template<typename T> T* memAlloc(const size_t &elements);
+ void *memAllocUser(const size_t &bytes);
// Need these as 2 separate function and not a default argument
// This is because it is used as the deleter in shared pointer
// which cannot support default arguments
template<typename T> void memFree(T* ptr);
- template<typename T> void memFreeLocked(T* ptr, bool user_unlock);
+ void memFreeUser(void* ptr);
- template<typename T> void memLock(const T *ptr);
- template<typename T> void memUnlock(const T *ptr);
+ void memLock(const void *ptr);
+ void memUnlock(const void *ptr);
template<typename T> T* pinnedAlloc(const size_t &elements);
template<typename T> void pinnedFree(T* ptr);
- static const unsigned MAX_BUFFERS = 1000;
-
size_t getMaxBytes();
+ unsigned getMaxBuffers();
void deviceMemoryInfo(size_t *alloc_bytes, size_t *alloc_buffers,
size_t *lock_bytes, size_t *lock_buffers);
diff --git a/src/backend/cuda/memory.cpp b/src/backend/cuda/memory.cpp
index 6a947c6..ff62661 100644
--- a/src/backend/cuda/memory.cpp
+++ b/src/backend/cuda/memory.cpp
@@ -50,11 +50,7 @@ public:
cuda::setDevice(n);
this->garbageCollect();
} catch(AfError err) {
- if(err.getError() == AF_ERR_DRIVER) { // Can happen from cudaErrorDevicesUnavailable
- continue;
- } else {
- throw err;
- }
+ continue; // Do not throw any errors while shutting down
}
}
}
@@ -90,7 +86,7 @@ size_t MemoryManager::getMaxMemorySize(int id)
}
MemoryManager::MemoryManager() :
- common::MemoryManager(getDeviceCount(), MAX_BUFFERS, AF_MEM_DEBUG || AF_CUDA_MEM_DEBUG)
+ common::MemoryManager(getDeviceCount(), common::MAX_BUFFERS, AF_MEM_DEBUG || AF_CUDA_MEM_DEBUG)
{
this->setMaxMemorySize();
}
@@ -127,7 +123,7 @@ size_t MemoryManagerPinned::getMaxMemorySize(int id)
}
MemoryManagerPinned::MemoryManagerPinned() :
- common::MemoryManager(1, MAX_BUFFERS, AF_MEM_DEBUG || AF_CUDA_MEM_DEBUG)
+ common::MemoryManager(1, common::MAX_BUFFERS, AF_MEM_DEBUG || AF_CUDA_MEM_DEBUG)
{
this->setMaxMemorySize();
}
@@ -168,6 +164,11 @@ size_t getMaxBytes()
return getMemoryManager().getMaxBytes();
}
+unsigned getMaxBuffers()
+{
+ return getMemoryManager().getMaxBuffers();
+}
+
void garbageCollect()
{
getMemoryManager().garbageCollect();
@@ -181,34 +182,34 @@ void printMemInfo(const char *msg, const int device)
template<typename T>
T* memAlloc(const size_t &elements)
{
- return (T *)getMemoryManager().alloc(elements * sizeof(T));
+ return (T *)getMemoryManager().alloc(elements * sizeof(T), false);
}
+void* memAllocUser(const size_t &bytes)
+{
+ return getMemoryManager().alloc(bytes, true);
+}
template<typename T>
void memFree(T *ptr)
{
return getMemoryManager().unlock((void *)ptr, false);
}
-template<typename T>
-void memFreeLocked(T *ptr, bool user_unlock)
+void memFreeUser(void *ptr)
{
- getMemoryManager().unlock((void *)ptr, user_unlock);
+ getMemoryManager().unlock((void *)ptr, true);
}
-template<typename T>
-void memLock(const T *ptr)
+void memLock(const void *ptr)
{
getMemoryManager().userLock((void *)ptr);
}
-template<typename T>
-void memUnlock(const T *ptr)
+void memUnlock(const void *ptr)
{
getMemoryManager().userUnlock((void *)ptr);
}
-
void deviceMemoryInfo(size_t *alloc_bytes, size_t *alloc_buffers,
size_t *lock_bytes, size_t *lock_buffers)
{
@@ -219,7 +220,7 @@ void deviceMemoryInfo(size_t *alloc_bytes, size_t *alloc_buffers,
template<typename T>
T* pinnedAlloc(const size_t &elements)
{
- return (T *)getMemoryManagerPinned().alloc(elements * sizeof(T));
+ return (T *)getMemoryManagerPinned().alloc(elements * sizeof(T), false);
}
template<typename T>
@@ -231,9 +232,6 @@ void pinnedFree(T* ptr)
#define INSTANTIATE(T) \
template T* memAlloc(const size_t &elements); \
template void memFree(T* ptr); \
- template void memFreeLocked(T* ptr, bool user_unlock); \
- template void memLock(const T* ptr); \
- template void memUnlock(const T* ptr); \
template T* pinnedAlloc(const size_t &elements); \
template void pinnedFree(T* ptr); \
diff --git a/src/backend/cuda/memory.hpp b/src/backend/cuda/memory.hpp
index 590ba3b..9bf69df 100644
--- a/src/backend/cuda/memory.hpp
+++ b/src/backend/cuda/memory.hpp
@@ -13,21 +13,22 @@
namespace cuda
{
template<typename T> T* memAlloc(const size_t &elements);
+ void *memAllocUser(const size_t &bytes);
// Need these as 2 separate function and not a default argument
// This is because it is used as the deleter in shared pointer
// which cannot support default arguments
template<typename T> void memFree(T* ptr);
- template<typename T> void memFreeLocked(T* ptr, bool user_unlock);
- template<typename T> void memLock(const T *ptr);
- template<typename T> void memUnlock(const T *ptr);
+ void memFreeUser(void* ptr);
+
+ void memLock(const void *ptr);
+ void memUnlock(const void *ptr);
template<typename T> T* pinnedAlloc(const size_t &elements);
template<typename T> void pinnedFree(T* ptr);
- static const unsigned MAX_BUFFERS = 1000;
-
size_t getMaxBytes();
+ unsigned getMaxBuffers();
void deviceMemoryInfo(size_t *alloc_bytes, size_t *alloc_buffers,
size_t *lock_bytes, size_t *lock_buffers);
diff --git a/src/backend/opencl/memory.cpp b/src/backend/opencl/memory.cpp
index 01c93bb..756d187 100644
--- a/src/backend/opencl/memory.cpp
+++ b/src/backend/opencl/memory.cpp
@@ -88,7 +88,7 @@ size_t MemoryManager::getMaxMemorySize(int id)
}
MemoryManager::MemoryManager() :
- common::MemoryManager(getDeviceCount(), MAX_BUFFERS, AF_MEM_DEBUG || AF_OPENCL_MEM_DEBUG)
+ common::MemoryManager(getDeviceCount(), common::MAX_BUFFERS, AF_MEM_DEBUG || AF_OPENCL_MEM_DEBUG)
{
this->setMaxMemorySize();
}
@@ -128,7 +128,7 @@ size_t MemoryManagerPinned::getMaxMemorySize(int id)
}
MemoryManagerPinned::MemoryManagerPinned() :
- common::MemoryManager(getDeviceCount(), MAX_BUFFERS, AF_MEM_DEBUG || AF_OPENCL_MEM_DEBUG),
+ common::MemoryManager(getDeviceCount(), common::MAX_BUFFERS, AF_MEM_DEBUG || AF_OPENCL_MEM_DEBUG),
pinned_maps(getDeviceCount())
{
this->setMaxMemorySize();
@@ -184,6 +184,11 @@ size_t getMaxBytes()
return getMemoryManager().getMaxBytes();
}
+unsigned getMaxBuffers()
+{
+ return getMemoryManager().getMaxBuffers();
+}
+
void garbageCollect()
{
getMemoryManager().garbageCollect();
@@ -197,44 +202,44 @@ void printMemInfo(const char *msg, const int device)
template<typename T>
T* memAlloc(const size_t &elements)
{
- return (T *)getMemoryManager().alloc(elements * sizeof(T));
+ return (T *)getMemoryManager().alloc(elements * sizeof(T), false);
}
-cl::Buffer *bufferAlloc(const size_t &bytes)
+void* memAllocUser(const size_t &bytes)
{
- return (cl::Buffer *)getMemoryManager().alloc(bytes);
+ return getMemoryManager().alloc(bytes, true);
}
-
template<typename T>
void memFree(T *ptr)
{
return getMemoryManager().unlock((void *)ptr, false);
}
-void bufferFree(cl::Buffer *buf)
+void memFreeUser(void *ptr)
{
- return getMemoryManager().unlock((void *)buf, false);
+ getMemoryManager().unlock((void *)ptr, true);
}
-template<typename T>
-void memFreeLocked(T *ptr, bool user_unlock)
+cl::Buffer *bufferAlloc(const size_t &bytes)
{
- getMemoryManager().unlock((void *)ptr, user_unlock);
+ return (cl::Buffer *)getMemoryManager().alloc(bytes, false);
}
-template<typename T>
-void memLock(const T *ptr)
+void bufferFree(cl::Buffer *buf)
+{
+ return getMemoryManager().unlock((void *)buf, false);
+}
+
+void memLock(const void *ptr)
{
getMemoryManager().userLock((void *)ptr);
}
-template<typename T>
-void memUnlock(const T *ptr)
+void memUnlock(const void *ptr)
{
getMemoryManager().userUnlock((void *)ptr);
}
-
void deviceMemoryInfo(size_t *alloc_bytes, size_t *alloc_buffers,
size_t *lock_bytes, size_t *lock_buffers)
{
@@ -245,7 +250,7 @@ void deviceMemoryInfo(size_t *alloc_bytes, size_t *alloc_buffers,
template<typename T>
T* pinnedAlloc(const size_t &elements)
{
- return (T *)getMemoryManagerPinned().alloc(elements * sizeof(T));
+ return (T *)getMemoryManagerPinned().alloc(elements * sizeof(T), false);
}
template<typename T>
@@ -257,9 +262,6 @@ void pinnedFree(T* ptr)
#define INSTANTIATE(T) \
template T* memAlloc(const size_t &elements); \
template void memFree(T* ptr); \
- template void memFreeLocked(T* ptr, bool user_unlock); \
- template void memLock(const T* ptr); \
- template void memUnlock(const T* ptr); \
template T* pinnedAlloc(const size_t &elements); \
template void pinnedFree(T* ptr); \
diff --git a/src/backend/opencl/memory.hpp b/src/backend/opencl/memory.hpp
index ea40b4b..f4d06a3 100644
--- a/src/backend/opencl/memory.hpp
+++ b/src/backend/opencl/memory.hpp
@@ -17,22 +17,23 @@ namespace opencl
cl::Buffer *bufferAlloc(const size_t &bytes);
void bufferFree(cl::Buffer *buf);
- template<typename T> T *memAlloc(const size_t &elements);
+ template<typename T> T* memAlloc(const size_t &elements);
+ void *memAllocUser(const size_t &bytes);
// Need these as 2 separate function and not a default argument
// This is because it is used as the deleter in shared pointer
// which cannot support default arguments
template<typename T> void memFree(T* ptr);
- template<typename T> void memFreeLocked(T* ptr, bool user_unlock);
- template<typename T> void memLock(const T *ptr);
- template<typename T> void memUnlock(const T *ptr);
+ void memFreeUser(void* ptr);
+
+ void memLock(const void *ptr);
+ void memUnlock(const void *ptr);
template<typename T> T* pinnedAlloc(const size_t &elements);
template<typename T> void pinnedFree(T* ptr);
- static const unsigned MAX_BUFFERS = 1000;
-
size_t getMaxBytes();
+ unsigned getMaxBuffers();
void deviceMemoryInfo(size_t *alloc_bytes, size_t *alloc_buffers,
size_t *lock_bytes, size_t *lock_buffers);
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-science/packages/arrayfire.git
More information about the debian-science-commits
mailing list