Get the Total Amount of Umpire Memory Allocated

examples/size_limiter.cpp

@@ -7,6 +7,7 @@
 #include <iostream>
 
 #include "umpire/ResourceManager.hpp"
+#include "umpire/Umpire.hpp"
 #include "umpire/strategy/QuickPool.hpp"
 #include "umpire/strategy/SizeLimiter.hpp"
 #include "umpire/util/Macros.hpp"
@@ -18,15 +19,30 @@ int main(int, char**)
       rm.makeAllocator<umpire::strategy::SizeLimiter>("size_limited_alloc", rm.getAllocator("HOST"), 1024);
 
   auto pool = rm.makeAllocator<umpire::strategy::QuickPool>("pool", size_limited_alloc, 64, 64);
+  void* data;
 
   // This will throw an exception because the pool is limited to 1024 bytes.
   std::cout << "Attempting to allocate 2098 bytes..." << std::endl;
   try {
-    void* data = pool.allocate(2048);
+    data = pool.allocate(2048);
     UMPIRE_USE_VAR(data);
   } catch (...) {
     std::cout << "Exception caught! Pool is limited to 1024 bytes." << std::endl;
   }
+  std::cout << "The total amount of memory used was: " << umpire::get_total_memory_allocated() << std::endl;
+
+  std::cout << "Attempting to allocate 512 bytes..." << std::endl;
+  try {
+    data = pool.allocate(512);
+    UMPIRE_USE_VAR(data);
+  } catch (...) {
+    std::cout << "Exception caught! Pool is limited to 1024 bytes." << std::endl;
+  }
+  std::cout << "The total amount of memory used was: " << umpire::get_total_memory_allocated() << std::endl;
+
+  if (data != nullptr) {
+    pool.deallocate(data);
+  }
 
   return 0;
 }

examples/tutorial/tut_allocator.cpp

@@ -6,6 +6,7 @@
 //////////////////////////////////////////////////////////////////////////////
 #include "umpire/Allocator.hpp"
 #include "umpire/ResourceManager.hpp"
+#include "umpire/Umpire.hpp"
 
 int main(int, char**)
 {
@@ -31,6 +32,8 @@ int main(int, char**)
   std::cout << "Created an add-on allocator of size " << addon_allocator.getCurrentSize() << " using the "
             << allocator.getName() << " allocator." << std::endl;
 
+  std::cout << "The total amount of memory used was: " << umpire::get_total_memory_allocated() << std::endl;
+
   // _sphinx_tag_tut_deallocate_start
   allocator.deallocate(data);
   // _sphinx_tag_tut_deallocate_end

src/umpire/ResourceManager.cpp

@@ -155,6 +155,10 @@ Allocator ResourceManager::makeResource(const std::string& name, MemoryResourceT
     traits.granularity = MemoryResourceTraits::granularity_type::fine_grained;
   }
 
+  if (name.find("SHARED") != std::string::npos) {
+    m_shared_allocators_by_name.push_back(name);
+  }
+
   std::unique_ptr<strategy::AllocationStrategy> allocator{registry.makeMemoryResource(name, getNextId(), traits)};
   allocator->setTracking(traits.tracking);
 

src/umpire/ResourceManager.hpp

@@ -328,6 +328,7 @@ class ResourceManager {
   util::AllocationMap m_allocations;
 
   std::list<std::unique_ptr<strategy::AllocationStrategy>> m_allocators;
+  std::vector<std::string> m_shared_allocators_by_name;
 
   std::unordered_map<int, strategy::AllocationStrategy*> m_allocators_by_id;
   std::unordered_map<std::string, strategy::AllocationStrategy*> m_allocators_by_name;
@@ -347,6 +348,7 @@ class ResourceManager {
   friend std::vector<util::AllocationRecord> get_allocator_records(Allocator);
   friend strategy::ZeroByteHandler;
   friend strategy::mixins::AllocateNull;
+  friend std::size_t get_total_memory_allocated();
 };
 
 } // end namespace umpire

src/umpire/Umpire.cpp

@@ -173,6 +173,24 @@ void mark_event(const std::string& event)
       [&](auto& e) { e.name("event").category(event::category::metadata).arg("name", event).tag("replay", "true"); });
 }
 
+std::size_t get_total_memory_allocated()
+{
+  auto& rm = umpire::ResourceManager::getInstance();
+  std::size_t total_memory{0};
+
+  for (auto s : rm.getResourceNames()) {
+    umpire::Allocator alloc = rm.getAllocator(s);
+    total_memory += alloc.getActualSize();
+  }
+
+  for (auto s : rm.m_shared_allocators_by_name) {
+    umpire::Allocator alloc = rm.getAllocator(s);
+    total_memory += alloc.getActualSize();
+  }
+
+  return total_memory;
+}
+
 std::size_t get_device_memory_usage(int device_id)
 {
 #if defined(UMPIRE_ENABLE_CUDA)

src/umpire/Umpire.hpp

@@ -162,6 +162,11 @@ std::size_t get_process_memory_usage_hwm();
  */
 void mark_event(const std::string& event);
 
+/*!
+ * \brief Get the total umpire memory usage in bytes across all memory resources
+ */
+std::size_t get_total_memory_allocated();
+
 /*!
  * \brief Get memory usage of device device_id, using appropriate underlying
  * vendor API.