Merge branch 'develop' of github.com:LLNL/Umpire into kab163/test-exp-RAP

Author: kab163

examples/cookbook/recipe_shared_memory.cpp

@@ -16,6 +16,7 @@
 #include "umpire/Umpire.hpp"
 #include "umpire/config.hpp"
 #include "umpire/resource/HostSharedMemoryResource.hpp"
+#include "umpire/strategy/NamedAllocationStrategy.hpp"
 #include "umpire/util/MemoryResourceTraits.hpp"
 
 //
@@ -58,6 +59,9 @@ int main(int ac, char** av)
   //
   auto node_allocator{rm.makeResource("SHARED::node_allocator", traits)};
 
+  auto named_node_allocator{
+      rm.makeAllocator<umpire::strategy::NamedAllocationStrategy>("My Node Allocator", node_allocator)};
+
   //
   // Resource of this allocator is SHARED
   //
@@ -82,6 +86,7 @@ int main(int ac, char** av)
   // Allocate shared memory
   //
   void* ptr{node_allocator.allocate("allocation_name_2", sizeof(uint64_t))};
+  void* ptr2{named_node_allocator.allocate("allocation two", 1024)};
   uint64_t* data{static_cast<uint64_t*>(ptr)};
 
   if (shared_rank == foreman_rank)
@@ -98,6 +103,7 @@ int main(int ac, char** av)
   UMPIRE_ASSERT(*data == 0xDEADBEEF);
 
   node_allocator.deallocate(ptr);
+  named_node_allocator.deallocate(ptr2);
 
   if (use_mpi) {
     MPI_Finalize();

src/umpire/ResourceManager.cpp

@@ -64,7 +64,7 @@ ResourceManager::ResourceManager()
 {
   UMPIRE_LOG(Debug, "() entering");
 
-  const char* env_enable_log{getenv("UMPIRE_LOG_LEVEL")};
+  const char* env_enable_log{std::getenv("UMPIRE_LOG_LEVEL")};
   const bool enable_log{env_enable_log != nullptr};
 
   util::initialize_io(enable_log);

src/umpire/event/event.hpp

@@ -8,6 +8,7 @@
 #define UMPIRE_event_HPP
 
 #include <cstdint>
+#include <cstdlib>
 #include <map>
 #include <sstream>
 #include <string>
@@ -57,9 +58,9 @@ namespace umpire {
 namespace event {
 
 namespace {
-static const char* replay_env{getenv("UMPIRE_REPLAY")};
+static const char* replay_env{std::getenv("UMPIRE_REPLAY")};
 static const bool enable_replay{(replay_env != NULL)};
-static const char* event_env{getenv("UMPIRE_EVENTS")};
+static const char* event_env{std::getenv("UMPIRE_EVENTS")};
 static const bool enable_event{(event_env != NULL)};
 static const bool event_build_enabled{enable_replay || enable_event};
 } // namespace

src/umpire/strategy/NamedAllocationStrategy.cpp

@@ -22,6 +22,11 @@ void* NamedAllocationStrategy::allocate(std::size_t bytes)
   return m_allocator->allocate_internal(bytes);
 }
 
+void* NamedAllocationStrategy::allocate_named(const std::string& name, std::size_t bytes)
+{
+  return m_allocator->allocate_named_internal(name, bytes);
+}
+
 void NamedAllocationStrategy::deallocate(void* ptr, std::size_t size)
 {
   return m_allocator->deallocate_internal(ptr, size);

src/umpire/strategy/NamedAllocationStrategy.hpp

@@ -18,6 +18,7 @@ class NamedAllocationStrategy : public AllocationStrategy {
   NamedAllocationStrategy(const std::string& name, int id, Allocator allocator);
 
   void* allocate(std::size_t bytes) override;
+  void* allocate_named(const std::string& name, std::size_t bytes) override;
   void deallocate(void* ptr, std::size_t size) override;
 
   Platform getPlatform() noexcept override;

src/umpire/util/Logger.cpp

@@ -33,7 +33,7 @@ Logger::Logger() noexcept
       m_is_enabled{false, false, false, false}
 {
   message::Level level{defaultLevel};
-  const char* enval = getenv(env_name);
+  const char* enval = std::getenv(env_name);
 
   if (enval) {
     for (int i = 0; i < message::Num_Levels; ++i) {

src/umpire/util/Macros.hpp

@@ -36,7 +36,7 @@
       plog = axom::slic::Logger::getActiveLogger();                                                     \
       axom::slic::message::Level level;                                                                 \
       level = axom::slic::message::Level::Error;                                                        \
-      char* enval = getenv(env_name.c_str());                                                           \
+      char* enval = std::getenv(env_name.c_str());                                                      \
       if (enval != NULL) {                                                                              \
         for (int i = 0; i < axom::slic::message::Level::Num_Levels; ++i) {                              \
           if (strcasecmp(enval, axom::slic::message::MessageLevelName[i].c_str()) == 0) {               \

src/umpire/util/backtrace.inl

@@ -41,7 +41,7 @@ bool backtrace_enabled()
   static bool initialized{false};
 
   if (!initialized) {
-    const char* enval{getenv("UMPIRE_BACKTRACE")};
+    const char* enval{std::getenv("UMPIRE_BACKTRACE")};
     if (enval) {
       std::string env_str{enval};
       std::transform(env_str.begin(), env_str.end(), env_str.begin(), ::toupper);

src/umpire/util/io.cpp

@@ -7,8 +7,7 @@
 
 #include "umpire/util/io.hpp"
 
-#include <stdlib.h> // for getenv()
-
+#include <cstdlib>
 #include <fstream>
 #include <iostream>
 #include <ostream>

tests/integration/strategy_tests.cpp

@@ -763,4 +763,22 @@ TEST(NamingShimTests, TestAllocateDeallocate)
     shim.deallocate(ptr);
   }
 }
+
+TEST(NamedAllocatorTest, ForwardName)
+{
+  auto& rm = umpire::ResourceManager::getInstance();
+
+  auto traits{umpire::get_default_resource_traits("SHARED")};
+  traits.size = 1 * 1024 * 1024;
+  traits.scope = umpire::MemoryResourceTraits::shared_scope::node;
+
+  auto node_allocator{rm.makeResource("SHARED::allocator_for_named_test", traits)};
+
+  auto allocator{rm.makeAllocator<umpire::strategy::NamedAllocationStrategy>("shared named alloc", node_allocator)};
+  {
+    void* ptr = allocator.allocate("test", 1024);
+    EXPECT_NE(ptr, nullptr);
+    allocator.deallocate(ptr);
+  }
+}
 #endif