Merge pull request #504 from Cytnx-dev/templatise_functions

Refactor: Templatise `Movemem()` function
Cytnx-dev · Nov 19, 2024 · 6ff4e31 · 6ff4e31
2 parents 0b510a6 + 83b07ca
commit 6ff4e31
Show file tree

Hide file tree

Showing 15 changed files with 294 additions and 1,284 deletions.
diff --git a/src/backend/BoolStorage.cpp b/src/backend/BoolStorage.cpp
@@ -89,10 +89,10 @@ namespace cytnx {
                                  const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      utils_internal::Movemem_cpu_b(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryCpu<cytnx_bool>(tmp, old_shape, mapper, invmapper, 1);
     } else {
 #ifdef UNI_GPU
-      utils_internal::cuMovemem_gpu_b(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryGpu<cytnx_bool>(tmp, old_shape, mapper, invmapper, 1);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
 #endif
@@ -104,10 +104,10 @@ namespace cytnx {
     const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      return utils_internal::Movemem_cpu_b(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryCpu<cytnx_bool>(tmp, old_shape, mapper, invmapper, 0);
     } else {
 #ifdef UNI_GPU
-      return utils_internal::cuMovemem_gpu_b(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryGpu<cytnx_bool>(tmp, old_shape, mapper, invmapper, 0);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
       return nullptr;

diff --git a/src/backend/ComplexDoubleStorage.cpp b/src/backend/ComplexDoubleStorage.cpp
@@ -90,11 +90,11 @@ namespace cytnx {
                                           const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      utils_internal::Movemem_cpu_cd(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryCpu<cytnx_complex128>(tmp, old_shape, mapper, invmapper, 1);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      utils_internal::cuMovemem_gpu_cd(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryGpu<cytnx_complex128>(tmp, old_shape, mapper, invmapper, 1);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
 #endif
@@ -106,11 +106,11 @@ namespace cytnx {
     const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      return utils_internal::Movemem_cpu_cd(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryCpu<cytnx_complex128>(tmp, old_shape, mapper, invmapper, 0);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      return utils_internal::cuMovemem_gpu_cd(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryGpu<cytnx_complex128>(tmp, old_shape, mapper, invmapper, 0);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
 #endif

diff --git a/src/backend/ComplexFloatStorage.cpp b/src/backend/ComplexFloatStorage.cpp
@@ -91,11 +91,11 @@ namespace cytnx {
                                          const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      utils_internal::Movemem_cpu_cf(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryCpu<cytnx_complex64>(tmp, old_shape, mapper, invmapper, 1);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      utils_internal::cuMovemem_gpu_cf(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryGpu<cytnx_complex64>(tmp, old_shape, mapper, invmapper, 1);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
 #endif
@@ -107,11 +107,11 @@ namespace cytnx {
     const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      return utils_internal::Movemem_cpu_cf(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryCpu<cytnx_complex64>(tmp, old_shape, mapper, invmapper, 0);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      return utils_internal::cuMovemem_gpu_cf(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryGpu<cytnx_complex64>(tmp, old_shape, mapper, invmapper, 0);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
       return nullptr;

diff --git a/src/backend/DoubleStorage.cpp b/src/backend/DoubleStorage.cpp
@@ -93,11 +93,11 @@ namespace cytnx {
                                    const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      utils_internal::Movemem_cpu_d(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryCpu<cytnx_double>(tmp, old_shape, mapper, invmapper, 1);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      utils_internal::cuMovemem_gpu_d(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryGpu<cytnx_double>(tmp, old_shape, mapper, invmapper, 1);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
 #endif
@@ -111,11 +111,11 @@ namespace cytnx {
     // cout << this->device << " " << Device.cpu << endl;
     if (this->device == Device.cpu) {
       // cout << "[OK]" << endl;
-      return utils_internal::Movemem_cpu_d(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryCpu<cytnx_double>(tmp, old_shape, mapper, invmapper, 0);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      return utils_internal::cuMovemem_gpu_d(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryGpu<cytnx_double>(tmp, old_shape, mapper, invmapper, 0);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
       return nullptr;

diff --git a/src/backend/FloatStorage.cpp b/src/backend/FloatStorage.cpp
@@ -90,10 +90,10 @@ namespace cytnx {
                                   const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      utils_internal::Movemem_cpu_f(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryCpu<cytnx_float>(tmp, old_shape, mapper, invmapper, 1);
     } else {
 #ifdef UNI_GPU
-      utils_internal::cuMovemem_gpu_f(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryGpu<cytnx_float>(tmp, old_shape, mapper, invmapper, 1);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
 #endif
@@ -105,10 +105,10 @@ namespace cytnx {
     const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      return utils_internal::Movemem_cpu_f(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryCpu<cytnx_float>(tmp, old_shape, mapper, invmapper, 0);
     } else {
 #ifdef UNI_GPU
-      return utils_internal::cuMovemem_gpu_f(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryGpu<cytnx_float>(tmp, old_shape, mapper, invmapper, 0);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
       return nullptr;

diff --git a/src/backend/Int16Storage.cpp b/src/backend/Int16Storage.cpp
@@ -85,11 +85,11 @@ namespace cytnx {
                                   const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      utils_internal::Movemem_cpu_i16(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryCpu<cytnx_int16>(tmp, old_shape, mapper, invmapper, 1);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      utils_internal::cuMovemem_gpu_i16(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryGpu<cytnx_int16>(tmp, old_shape, mapper, invmapper, 1);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
 #endif
@@ -101,11 +101,11 @@ namespace cytnx {
     const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      return utils_internal::Movemem_cpu_i16(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryCpu<cytnx_int16>(tmp, old_shape, mapper, invmapper, 0);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      return utils_internal::cuMovemem_gpu_i16(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryGpu<cytnx_int16>(tmp, old_shape, mapper, invmapper, 0);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
       return nullptr;

diff --git a/src/backend/Int32Storage.cpp b/src/backend/Int32Storage.cpp
@@ -88,11 +88,11 @@ namespace cytnx {
                                   const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      utils_internal::Movemem_cpu_i32(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryCpu<cytnx_int32>(tmp, old_shape, mapper, invmapper, 1);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      utils_internal::cuMovemem_gpu_i32(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryGpu<cytnx_int32>(tmp, old_shape, mapper, invmapper, 1);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
 #endif
@@ -104,11 +104,11 @@ namespace cytnx {
     const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      return utils_internal::Movemem_cpu_i32(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryCpu<cytnx_int32>(tmp, old_shape, mapper, invmapper, 0);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      return utils_internal::cuMovemem_gpu_i32(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryGpu<cytnx_int32>(tmp, old_shape, mapper, invmapper, 0);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
       return nullptr;

diff --git a/src/backend/Int64Storage.cpp b/src/backend/Int64Storage.cpp
@@ -87,11 +87,11 @@ namespace cytnx {
                                   const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      utils_internal::Movemem_cpu_i64(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryCpu<cytnx_int64>(tmp, old_shape, mapper, invmapper, 1);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      utils_internal::cuMovemem_gpu_i64(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryGpu<cytnx_int64>(tmp, old_shape, mapper, invmapper, 1);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
 #endif
@@ -103,11 +103,11 @@ namespace cytnx {
     const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      return utils_internal::Movemem_cpu_i64(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryCpu<cytnx_int64>(tmp, old_shape, mapper, invmapper, 0);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      return utils_internal::cuMovemem_gpu_i64(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryGpu<cytnx_int64>(tmp, old_shape, mapper, invmapper, 0);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
       return nullptr;

diff --git a/src/backend/Uint16Storage.cpp b/src/backend/Uint16Storage.cpp
@@ -85,11 +85,11 @@ namespace cytnx {
                                    const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      utils_internal::Movemem_cpu_u16(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryCpu<cytnx_uint16>(tmp, old_shape, mapper, invmapper, 1);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      utils_internal::cuMovemem_gpu_u16(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryGpu<cytnx_uint16>(tmp, old_shape, mapper, invmapper, 1);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
 #endif
@@ -101,11 +101,11 @@ namespace cytnx {
     const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      return utils_internal::Movemem_cpu_u16(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryCpu<cytnx_uint16>(tmp, old_shape, mapper, invmapper, 0);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      return utils_internal::cuMovemem_gpu_u16(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryGpu<cytnx_uint16>(tmp, old_shape, mapper, invmapper, 0);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
       return nullptr;

diff --git a/src/backend/Uint32Storage.cpp b/src/backend/Uint32Storage.cpp
@@ -91,11 +91,11 @@ namespace cytnx {
                                    const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      utils_internal::Movemem_cpu_u32(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryCpu<cytnx_uint32>(tmp, old_shape, mapper, invmapper, 1);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      utils_internal::cuMovemem_gpu_u32(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryGpu<cytnx_uint32>(tmp, old_shape, mapper, invmapper, 1);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
 #endif
@@ -107,11 +107,11 @@ namespace cytnx {
     const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      return utils_internal::Movemem_cpu_u32(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryCpu<cytnx_uint32>(tmp, old_shape, mapper, invmapper, 0);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      return utils_internal::cuMovemem_gpu_u32(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryGpu<cytnx_uint32>(tmp, old_shape, mapper, invmapper, 0);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
       return nullptr;

diff --git a/src/backend/Uint64Storage.cpp b/src/backend/Uint64Storage.cpp
@@ -87,11 +87,11 @@ namespace cytnx {
                                    const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      utils_internal::Movemem_cpu_u64(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryCpu<cytnx_uint64>(tmp, old_shape, mapper, invmapper, 1);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      utils_internal::cuMovemem_gpu_u64(tmp, old_shape, mapper, invmapper, 1);
+      utils_internal::MoveMemoryGpu<cytnx_uint64>(tmp, old_shape, mapper, invmapper, 1);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
 #endif
@@ -103,11 +103,11 @@ namespace cytnx {
     const std::vector<cytnx_uint64> &invmapper) {
     boost::intrusive_ptr<Storage_base> tmp(this);
     if (this->device == Device.cpu) {
-      return utils_internal::Movemem_cpu_u64(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryCpu<cytnx_uint64>(tmp, old_shape, mapper, invmapper, 0);
     } else {
 #ifdef UNI_GPU
       checkCudaErrors(cudaSetDevice(this->device));
-      return utils_internal::cuMovemem_gpu_u64(tmp, old_shape, mapper, invmapper, 0);
+      return utils_internal::MoveMemoryGpu<cytnx_uint64>(tmp, old_shape, mapper, invmapper, 0);
 #else
       cytnx_error_msg(1, "%s", "[ERROR][Internal] try to call GPU section without CUDA support");
       return nullptr;