[arrayfire] 193/284: Renaming a few internal functions
Ghislain Vaillant
ghisvail-guest at moszumanska.debian.org
Sun Feb 7 18:59:32 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 828138c60b1a3a05536650fb59a7b53d62fbc43c
Author: Pavan Yalamanchili <pavan at arrayfire.com>
Date: Mon Jan 11 10:39:12 2016 -0500
Renaming a few internal functions
- memPush --> memLock
- memPop --> memUnlock
---
src/api/c/device.cpp | 4 ++--
src/backend/cpu/Array.hpp | 2 +-
src/backend/cpu/memory.cpp | 24 ++++++++++++------------
src/backend/cpu/memory.hpp | 6 +++---
src/backend/cuda/Array.hpp | 2 +-
src/backend/cuda/memory.cpp | 30 +++++++++++++++---------------
src/backend/cuda/memory.hpp | 6 +++---
src/backend/opencl/Array.hpp | 2 +-
src/backend/opencl/memory.cpp | 28 ++++++++++++++--------------
src/backend/opencl/memory.hpp | 8 ++++----
10 files changed, 56 insertions(+), 56 deletions(-)
diff --git a/src/api/c/device.cpp b/src/api/c/device.cpp
index 731e98e..c37e293 100644
--- a/src/api/c/device.cpp
+++ b/src/api/c/device.cpp
@@ -221,7 +221,7 @@ af_err af_get_device_ptr(void **data, const af_array arr)
template <typename T>
inline void lockArray(const af_array arr)
{
- memPop<T>((const T *)getArray<T>(arr).get());
+ memLock<T>((const T *)getArray<T>(arr).get());
}
af_err af_lock_device_ptr(const af_array arr)
@@ -258,7 +258,7 @@ af_err af_lock_array(const af_array arr)
template <typename T>
inline void unlockArray(const af_array arr)
{
- memPush<T>((const T *)getArray<T>(arr).get());
+ memUnlock<T>((const T *)getArray<T>(arr).get());
}
af_err af_unlock_device_ptr(const af_array arr)
diff --git a/src/backend/cpu/Array.hpp b/src/backend/cpu/Array.hpp
index e0709d3..9cd154e 100644
--- a/src/backend/cpu/Array.hpp
+++ b/src/backend/cpu/Array.hpp
@@ -84,7 +84,7 @@ namespace cpu
void *getDevicePtr(const Array<T>& arr)
{
T *ptr = arr.device();
- memPop(ptr);
+ memLock(ptr);
return (void *)ptr;
}
diff --git a/src/backend/cpu/memory.cpp b/src/backend/cpu/memory.cpp
index 625f9b2..5eebf18 100644
--- a/src/backend/cpu/memory.cpp
+++ b/src/backend/cpu/memory.cpp
@@ -196,7 +196,7 @@ T* memAlloc(const size_t &elements)
}
template<typename T>
-void memFreeLocked(T *ptr, bool freeLocked)
+void memFreeLocked(T *ptr, bool user_unlock)
{
std::lock_guard<std::mutex> lock(memory_map_mutex);
@@ -205,7 +205,7 @@ void memFreeLocked(T *ptr, bool freeLocked)
if (iter != memory_map.end()) {
iter->second.mngr_lock = false;
- if ((iter->second).user_lock && !freeLocked) return;
+ if ((iter->second).user_lock && !user_unlock) return;
iter->second.user_lock = false;
used_bytes -= iter->second.bytes;
@@ -223,7 +223,7 @@ void memFree(T *ptr)
}
template<typename T>
-void memPop(const T *ptr)
+void memLock(const T *ptr)
{
std::lock_guard<std::mutex> lock(memory_map_mutex);
@@ -241,7 +241,7 @@ void memPop(const T *ptr)
}
template<typename T>
-void memPush(const T *ptr)
+void memUnlock(const T *ptr)
{
std::lock_guard<std::mutex> lock(memory_map_mutex);
mem_iter iter = memory_map.find((void *)ptr);
@@ -273,14 +273,14 @@ void pinnedFree(T* ptr)
memFree<T>(ptr);
}
-#define INSTANTIATE(T) \
- template T* memAlloc(const size_t &elements); \
- template void memFree(T* ptr); \
- template void memFreeLocked(T* ptr, bool freeLocked); \
- template void memPop(const T* ptr); \
- template void memPush(const T* ptr); \
- template T* pinnedAlloc(const size_t &elements); \
- template 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); \
INSTANTIATE(float)
INSTANTIATE(cfloat)
diff --git a/src/backend/cpu/memory.hpp b/src/backend/cpu/memory.hpp
index 19846c4..6524fe6 100644
--- a/src/backend/cpu/memory.hpp
+++ b/src/backend/cpu/memory.hpp
@@ -17,10 +17,10 @@ namespace cpu
// 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 freeLocked);
+ template<typename T> void memFreeLocked(T* ptr, bool user_unlock);
- template<typename T> void memPop(const T *ptr);
- template<typename T> void memPush(const T *ptr);
+ template<typename T> void memLock(const T *ptr);
+ template<typename T> void memUnlock(const T *ptr);
template<typename T> T* pinnedAlloc(const size_t &elements);
template<typename T> void pinnedFree(T* ptr);
diff --git a/src/backend/cuda/Array.hpp b/src/backend/cuda/Array.hpp
index 638b745..ad4396b 100644
--- a/src/backend/cuda/Array.hpp
+++ b/src/backend/cuda/Array.hpp
@@ -86,7 +86,7 @@ namespace cuda
void *getDevicePtr(const Array<T>& arr)
{
T *ptr = arr.device();
- memPop(ptr);
+ memLock(ptr);
return (void *)ptr;
}
diff --git a/src/backend/cuda/memory.cpp b/src/backend/cuda/memory.cpp
index 8152c8a..f37a0fe 100644
--- a/src/backend/cuda/memory.cpp
+++ b/src/backend/cuda/memory.cpp
@@ -68,19 +68,19 @@ namespace cuda
}
template<typename T>
- void memFreeLocked(T *ptr, bool freeLocked)
+ void memFreeLocked(T *ptr, bool user_unlock)
{
cudaFreeWrapper(ptr); // Free it because we are not sure what the size is
}
template<typename T>
- void memPop(const T *ptr)
+ void memLock(const T *ptr)
{
return;
}
template<typename T>
- void memPush(const T *ptr)
+ void memUnlock(const T *ptr)
{
return;
}
@@ -283,7 +283,7 @@ namespace cuda
}
template<typename T>
- void memFreeLocked(T *ptr, bool freeLocked)
+ void memFreeLocked(T *ptr, bool user_unlock)
{
int n = getActiveDeviceId();
mem_iter iter = memory_maps[n].find((void *)ptr);
@@ -291,7 +291,7 @@ namespace cuda
if (iter != memory_maps[n].end()) {
iter->second.mngr_lock = false;
- if ((iter->second.user_lock) && !freeLocked) return;
+ if ((iter->second.user_lock) && !user_unlock) return;
iter->second.user_lock = false;
@@ -310,7 +310,7 @@ namespace cuda
}
template<typename T>
- void memPop(const T *ptr)
+ void memLock(const T *ptr)
{
int n = getActiveDeviceId();
mem_iter iter = memory_maps[n].find((void *)ptr);
@@ -328,7 +328,7 @@ namespace cuda
}
template<typename T>
- void memPush(const T *ptr)
+ void memUnlock(const T *ptr)
{
int n = getActiveDeviceId();
mem_iter iter = memory_maps[n].find((void *)ptr);
@@ -427,14 +427,14 @@ namespace cuda
#endif
-#define INSTANTIATE(T) \
- template T* memAlloc(const size_t &elements); \
- template void memFree(T* ptr); \
- template void memFreeLocked(T* ptr, bool freeLocked); \
- template void memPop(const T* ptr); \
- template void memPush(const T* ptr); \
- template T* pinnedAlloc(const size_t &elements); \
- template 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); \
INSTANTIATE(float)
INSTANTIATE(cfloat)
diff --git a/src/backend/cuda/memory.hpp b/src/backend/cuda/memory.hpp
index 5644a52..29e4e76 100644
--- a/src/backend/cuda/memory.hpp
+++ b/src/backend/cuda/memory.hpp
@@ -17,9 +17,9 @@ namespace cuda
// 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 freeLocked);
- template<typename T> void memPop(const T *ptr);
- template<typename T> void memPush(const 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);
template<typename T> T* pinnedAlloc(const size_t &elements);
template<typename T> void pinnedFree(T* ptr);
diff --git a/src/backend/opencl/Array.hpp b/src/backend/opencl/Array.hpp
index 5f86d6d..a6d3f4f 100644
--- a/src/backend/opencl/Array.hpp
+++ b/src/backend/opencl/Array.hpp
@@ -77,7 +77,7 @@ namespace opencl
void *getDevicePtr(const Array<T>& arr)
{
cl::Buffer *buf = arr.device();
- memPop((T *)buf);
+ memLock((T *)buf);
return (void *)((*buf)());
}
diff --git a/src/backend/opencl/memory.cpp b/src/backend/opencl/memory.cpp
index 141610d..b75955e 100644
--- a/src/backend/opencl/memory.cpp
+++ b/src/backend/opencl/memory.cpp
@@ -194,7 +194,7 @@ namespace opencl
bufferFreeLocked(ptr, false);
}
- void bufferFreeLocked(cl::Buffer *ptr, bool freeLocked)
+ void bufferFreeLocked(cl::Buffer *ptr, bool user_unlock)
{
int n = getActiveDeviceId();
mem_iter iter = memory_maps[n].find(ptr);
@@ -202,7 +202,7 @@ namespace opencl
if (iter != memory_maps[n].end()) {
iter->second.mngr_lock = false;
- if ((iter->second).user_lock && !freeLocked) return;
+ if ((iter->second).user_lock && !user_unlock) return;
iter->second.user_lock = false;
@@ -264,19 +264,19 @@ namespace opencl
}
template<typename T>
- void memFreeLocked(T *ptr, bool freeLocked)
+ void memFreeLocked(T *ptr, bool user_unlock)
{
- return bufferFreeLocked((cl::Buffer *)ptr, freeLocked);
+ return bufferFreeLocked((cl::Buffer *)ptr, user_unlock);
}
template<typename T>
- void memPop(const T *ptr)
+ void memLock(const T *ptr)
{
return bufferPop((cl::Buffer *)ptr);
}
template<typename T>
- void memPush(const T *ptr)
+ void memUnlock(const T *ptr)
{
return bufferPush((cl::Buffer *)ptr);
}
@@ -395,14 +395,14 @@ namespace opencl
return pinnedBufferFree((void *) ptr);
}
-#define INSTANTIATE(T) \
- template T* memAlloc(const size_t &elements); \
- template void memFree(T* ptr); \
- template void memFreeLocked(T* ptr, bool freeLocked); \
- template void memPop(const T* ptr); \
- template void memPush(const T* ptr); \
- template T* pinnedAlloc(const size_t &elements); \
- template 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); \
INSTANTIATE(float)
INSTANTIATE(cfloat)
diff --git a/src/backend/opencl/memory.hpp b/src/backend/opencl/memory.hpp
index 96292cd..dce1428 100644
--- a/src/backend/opencl/memory.hpp
+++ b/src/backend/opencl/memory.hpp
@@ -20,7 +20,7 @@ namespace opencl
// This is because it is used as the deleter in shared pointer
// which cannot support default arguments
void bufferFree(cl::Buffer *buf);
- void bufferFreeLocked(cl::Buffer *buf, bool freeLocked);
+ void bufferFreeLocked(cl::Buffer *buf, bool user_unlock);
template<typename T> T *memAlloc(const size_t &elements);
@@ -28,9 +28,9 @@ namespace opencl
// 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 freeLocked);
- template<typename T> void memPop(const T *ptr);
- template<typename T> void memPush(const 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);
template<typename T> T* pinnedAlloc(const size_t &elements);
template<typename T> void pinnedFree(T* ptr);
--
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