Merge branch 'develop' into feature/array_view_variant

JCSDA-internal · Sep 13, 2024 · 97eadff · 97eadff
2 parents 44d7f2b + b6a4e60
commit 97eadff
Show file tree

Hide file tree

Showing 11 changed files with 99 additions and 53 deletions.
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -121,8 +121,8 @@ jobs:
 
           - name: macos
             # Xcode compiler requires empty environment variables, so we pass null (~) here
-            os: macos-13
-            compiler: clang-14
+            os: macos-14
+            compiler: clang-15
             compiler_cc: ~
             compiler_cxx: ~
             compiler_fc: gfortran-13

diff --git a/src/atlas/array/SVector.h b/src/atlas/array/SVector.h
@@ -161,7 +161,7 @@ class SVector {
             for (idx_t c = 0; c < size; ++c) {
                 ptr[c].~T();
             }
-            util::delete_managedmem(ptr);
+            util::delete_managedmem(ptr, size);
         }
     }
 

diff --git a/src/atlas/array/native/NativeDataStore.h b/src/atlas/array/native/NativeDataStore.h
@@ -28,6 +28,7 @@
 
 #if ATLAS_HAVE_ACC
 #include "atlas_acc_support/atlas_acc_map_data.h"
+#define ATLAS_ACC_DEBUG 0
 #endif
 
 //------------------------------------------------------------------------------
@@ -213,7 +214,13 @@ class DataStore : public ArrayDataStore {
 #if ATLAS_HAVE_ACC
         if (not acc_mapped_) {
             ATLAS_ASSERT(deviceAllocated(),"Could not accMap as device data is not allocated");
+            ATLAS_ASSERT(!atlas_acc_is_present(host_data_, size_ * sizeof(Value)));
+            if constexpr(ATLAS_ACC_DEBUG) {
+                std::cout << "               + acc_map_data(hostptr:"<<host_data_<<", device:"<<device_data_<<", bytes:"<<footprint()<<")" <<std::endl;
+            }
             atlas_acc_map_data((void*)host_data_, (void*)device_data_, size_ * sizeof(Value));
+            ATLAS_ASSERT(atlas_acc_is_present(host_data_, size_ * sizeof(Value)));
+            ATLAS_ASSERT(atlas_acc_deviceptr(host_data_) == device_data_);
             acc_mapped_ = true;
         }
 #endif
@@ -226,7 +233,12 @@ class DataStore : public ArrayDataStore {
     void accUnmap() const override {
 #if ATLAS_HAVE_ACC
         if (acc_mapped_) {
+            if constexpr(ATLAS_ACC_DEBUG) {
+                std::cout << "               - acc_unmap_data(hostptr:"<<host_data_<<", device:"<<device_data_<<", bytes:"<<footprint()<<")" <<std::endl;
+            }
+            ATLAS_ASSERT(atlas_acc_is_present(host_data_, size_ * sizeof(Value)));
             atlas_acc_unmap_data(host_data_);
+            ATLAS_ASSERT(!atlas_acc_is_present(host_data_, size_ * sizeof(Value)));
             acc_mapped_ = false;
         }
 #endif
@@ -398,7 +410,13 @@ class WrappedDataStore : public ArrayDataStore {
 #if ATLAS_HAVE_ACC
         if (not acc_mapped_) {
             ATLAS_ASSERT(deviceAllocated(),"Could not accMap as device data is not allocated");
+            ATLAS_ASSERT(!atlas_acc_is_present(host_data_, size_ * sizeof(Value)));
+            if constexpr(ATLAS_ACC_DEBUG) {
+                std::cout << "               + acc_map_data(hostptr:"<<host_data_<<", device:"<<device_data_<<", bytes:"<<size_ * sizeof(Value)<<")" <<std::endl;
+            }
             atlas_acc_map_data((void*)host_data_, (void*)device_data_, size_ * sizeof(Value));
+            ATLAS_ASSERT(atlas_acc_is_present(host_data_, size_ * sizeof(Value)));
+            ATLAS_ASSERT(atlas_acc_deviceptr(host_data_) == device_data_);
             acc_mapped_ = true;
         }
 #endif
@@ -411,7 +429,12 @@ class WrappedDataStore : public ArrayDataStore {
     void accUnmap() const override {
 #if ATLAS_HAVE_ACC
         if (acc_mapped_) {
+            ATLAS_ASSERT(atlas_acc_is_present(host_data_, size_ * sizeof(Value)));
+            if constexpr(ATLAS_ACC_DEBUG) {
+                std::cout << "               - acc_unmap_data(hostptr:"<<host_data_<<", device:"<<device_data_<<", bytes:"<<size_ * sizeof(Value)<<")" <<std::endl;
+            }
             atlas_acc_unmap_data(host_data_);
+            ATLAS_ASSERT(!atlas_acc_is_present(host_data_, size_ * sizeof(Value)));
             acc_mapped_ = false;
         }
 #endif

diff --git a/src/atlas/functionspace/Spectral.h b/src/atlas/functionspace/Spectral.h
@@ -47,9 +47,10 @@ class Spectral : public functionspace::FunctionSpaceImpl {
      n = total wavenumber
   
   const auto zonal_wavenumbers = Spectral::zonal_wavenumbers();
+  const int truncation = Spectral::truncation();
   idx_t jc=0;
   for( int jm=0; jm<zonal_wavenumbers.size(); ++jm ) {
-    int m = zonal_wavenumbers(m);
+    int m = zonal_wavenumbers(jm);
     for( int n=m; m<=truncation; ++n ) {
       data( jc++, jfld ) = func_real_part(m,n);
       data( jc++, jfld ) = func_imag_part(m,n);

diff --git a/src/atlas/parallel/HaloExchange.h b/src/atlas/parallel/HaloExchange.h
@@ -90,7 +90,7 @@ class HaloExchange : public util::Object {
     DATA_TYPE* allocate_buffer(const int buffer_size, const bool on_device) const;
 
     template <typename DATA_TYPE>
-    void deallocate_buffer(DATA_TYPE* buffer, const bool on_device) const;
+    void deallocate_buffer(DATA_TYPE* buffer, const int buffer_size, const bool on_device) const;
 
     template <int ParallelDim, typename DATA_TYPE, int RANK>
     void pack_send_buffer(const array::ArrayView<DATA_TYPE, RANK>& hfield,
@@ -198,8 +198,8 @@ void HaloExchange::execute(array::Array& field, bool on_device) const {
 
     wait_for_send(inner_counts_init, inner_req);
 
-    deallocate_buffer<DATA_TYPE>(inner_buffer, on_device);
-    deallocate_buffer<DATA_TYPE>(halo_buffer, on_device);
+    deallocate_buffer<DATA_TYPE>(inner_buffer, inner_size, on_device);
+    deallocate_buffer<DATA_TYPE>(halo_buffer, halo_size, on_device);
 }
 
 template <typename DATA_TYPE, int RANK, typename ParallelDim>
@@ -249,8 +249,8 @@ void HaloExchange::execute_adjoint(array::Array& field, bool on_device) const {
 
     zero_halos<parallelDim>(field_hv, field_dv, halo_buffer, halo_size, on_device);
 
-    deallocate_buffer<DATA_TYPE>(halo_buffer, on_device);
-    deallocate_buffer<DATA_TYPE>(inner_buffer, on_device);
+    deallocate_buffer<DATA_TYPE>(halo_buffer, halo_size, on_device);
+    deallocate_buffer<DATA_TYPE>(inner_buffer, inner_size, on_device);
 }
 
 template <typename DATA_TYPE>
@@ -269,12 +269,12 @@ DATA_TYPE* HaloExchange::allocate_buffer(const int buffer_size, const bool on_de
 
 
 template <typename DATA_TYPE>
-void HaloExchange::deallocate_buffer(DATA_TYPE* buffer, const bool on_device) const {
+void HaloExchange::deallocate_buffer(DATA_TYPE* buffer, const int buffer_size, const bool on_device) const {
     if (on_device) {
-        util::delete_devicemem(buffer);
+        util::delete_devicemem(buffer, buffer_size);
     }
     else {
-        util::delete_hostmem(buffer);
+        util::delete_hostmem(buffer, buffer_size);
     }
 }
 

diff --git a/src/atlas/runtime/trace/Timings.cc b/src/atlas/runtime/trace/Timings.cc
@@ -274,8 +274,8 @@ void TimingsRegistry::report(std::ostream& out, const eckit::Configuration& conf
         }
     }
 
-    size_t max_title_length(0);
-    size_t max_location_length(0);
+    size_t max_title_length(2);
+    size_t max_location_length(9);
     size_t max_nest(0);
     long max_count(0);
     double max_seconds(0);

diff --git a/src/atlas/util/Allocate.cc b/src/atlas/util/Allocate.cc
@@ -25,41 +25,41 @@ namespace util {
 namespace detail {
 //------------------------------------------------------------------------------
 
-void allocate_managed(void** ptr, size_t size) {
+void allocate_managed(void** ptr, size_t bytes) {
     if constexpr (not ATLAS_HAVE_GPU) {
-        return allocate_host(ptr, size);
+        return allocate_host(ptr, bytes);
     }
-    HIC_CALL(hicMallocManaged(ptr, size));
+    HIC_CALL(hicMallocManaged(ptr, bytes));
 }
 
-void deallocate_managed(void* ptr) {
+void deallocate_managed(void* ptr, size_t bytes) {
     if constexpr (not ATLAS_HAVE_GPU) {
-        return deallocate_host(ptr);
+        return deallocate_host(ptr, bytes);
     }
     HIC_CALL(hicDeviceSynchronize());
     HIC_CALL(hicFree(ptr));
 }
 
-void allocate_device(void** ptr, size_t size) {
+void allocate_device(void** ptr, size_t bytes) {
     if constexpr (not ATLAS_HAVE_GPU) {
-        return allocate_host(ptr, size);
+        return allocate_host(ptr, bytes);
     }
-    HIC_CALL(hicMalloc(ptr, size));
+    HIC_CALL(hicMalloc(ptr, bytes));
 }
 
-void deallocate_device(void* ptr) {
+void deallocate_device(void* ptr, size_t bytes) {
     if constexpr (not ATLAS_HAVE_GPU) {
-        return deallocate_host(ptr);
+        return deallocate_host(ptr, bytes);
     }
     HIC_CALL(hicDeviceSynchronize());
     HIC_CALL(hicFree(ptr));
 }
 
-void allocate_host(void** ptr, size_t size) {
-    *ptr = malloc(size);
+void allocate_host(void** ptr, size_t bytes) {
+    *ptr = malloc(bytes);
 }
 
-void deallocate_host(void* ptr) {
+void deallocate_host(void* ptr, size_t /*bytes*/) {
     free(ptr);
 }
 
@@ -80,8 +80,17 @@ void atlas__allocate_managedmem_int(int*& a, size_t N) {
 void atlas__allocate_managedmem_long(long*& a, size_t N) {
     allocate_managedmem(a, N);
 }
-void atlas__deallocate_managedmem(void*& a) {
-    delete_managedmem(a);
+void atlas__deallocate_managedmem_double(double*& a, size_t N) {
+    delete_managedmem(a, N);
+}
+void atlas__deallocate_managedmem_float(float*& a, size_t N) {
+    delete_managedmem(a, N);
+}
+void atlas__deallocate_managedmem_int(int*& a, size_t N) {
+    delete_managedmem(a, N);
+}
+void atlas__deallocate_managedmem_long(long*& a, size_t N) {
+    delete_managedmem(a, N);
 }
 }
 

diff --git a/src/atlas/util/Allocate.h b/src/atlas/util/Allocate.h
@@ -18,14 +18,14 @@ namespace util {
 //------------------------------------------------------------------------------
 
 namespace detail {
-void allocate_managed(void** ptr, size_t size);
-void deallocate_managed(void* ptr);
+void allocate_managed(void** ptr, size_t bytes);
+void deallocate_managed(void* ptr, size_t bytes);
 
-void allocate_device(void** ptr, size_t size);
-void deallocate_device(void* ptr);
+void allocate_device(void** ptr, size_t bytes);
+void deallocate_device(void* ptr, size_t bytes);
 
-void allocate_host(void** ptr, size_t size);
-void deallocate_host(void* ptr);
+void allocate_host(void** ptr, size_t bytes);
+void deallocate_host(void* ptr, size_t bytes);
 
 }  // namespace detail
 
@@ -37,9 +37,9 @@ void allocate_managedmem(T*& data, size_t N) {
 }
 
 template <typename T>
-void delete_managedmem(T*& data) {
+void delete_managedmem(T*& data, size_t N) {
     if (data) {
-        detail::deallocate_managed(data);
+        detail::deallocate_managed(data, N * sizeof(T));
         data = nullptr;
     }
 }
@@ -52,9 +52,9 @@ void allocate_devicemem(T*& data, size_t N) {
 }
 
 template <typename T>
-void delete_devicemem(T*& data) {
+void delete_devicemem(T*& data, size_t N) {
     if (data) {
-        detail::deallocate_device(data);
+        detail::deallocate_device(data, N * sizeof(T));
         data = nullptr;
     }
 }
@@ -67,9 +67,9 @@ void allocate_hostmem(T*& data, size_t N) {
 }
 
 template <typename T>
-void delete_hostmem(T*& data) {
+void delete_hostmem(T*& data, size_t N) {
     if (data) {
-        detail::deallocate_host(data);
+        detail::deallocate_host(data, N * sizeof(T));
         data = nullptr;
     }
 }
@@ -82,7 +82,10 @@ void atlas__allocate_managedmem_double(double*& a, size_t N);
 void atlas__allocate_managedmem_float(float*& a, size_t N);
 void atlas__allocate_managedmem_int(int*& a, size_t N);
 void atlas__allocate_managedmem_long(long*& a, size_t N);
-void atlas__deallocate_managedmem(void*& a);
+void atlas__deallocate_managedmem_double(double*& a, size_t N);
+void atlas__deallocate_managedmem_float(float*& a, size_t N);
+void atlas__deallocate_managedmem_int(int*& a, size_t N);
+void atlas__deallocate_managedmem_long(long*& a, size_t N);
 }
 
 //------------------------------------------------------------------------------

diff --git a/src/atlas_acc_support/atlas_acc_map_data.c b/src/atlas_acc_support/atlas_acc_map_data.c
@@ -18,11 +18,19 @@
 
 #include <openacc.h>
 
-void atlas_acc_map_data(void* cpu_ptr, void* gpu_ptr, unsigned long size) {
-  acc_map_data(cpu_ptr, gpu_ptr, size);
+void atlas_acc_map_data(void* cpu_ptr, void* gpu_ptr, unsigned long bytes) {
+  acc_map_data(cpu_ptr, gpu_ptr, bytes);
 }
 
 
 void atlas_acc_unmap_data(void* cpu_ptr) {
   acc_unmap_data(cpu_ptr);
 }
+
+int atlas_acc_is_present(void* cpu_ptr, unsigned long bytes) {
+  return acc_is_present(cpu_ptr, bytes);
+}
+
+void* atlas_acc_deviceptr(void* cpu_ptr) {
+  return acc_deviceptr(cpu_ptr);
+}
diff --git a/src/atlas_acc_support/atlas_acc_map_data.h b/src/atlas_acc_support/atlas_acc_map_data.h
@@ -14,8 +14,10 @@
 extern "C" {
 #endif
 
-void atlas_acc_map_data(void* cpu_ptr, void* gpu_ptr, unsigned long size);
+void atlas_acc_map_data(void* cpu_ptr, void* gpu_ptr, unsigned long bytes);
 void atlas_acc_unmap_data(void* cpu_ptr);
+int atlas_acc_is_present(void* cpu_ptr, unsigned long bytes);
+void* atlas_acc_deviceptr(void* cpu_ptr);
 
 #ifdef __cplusplus
 }