Add runtime memory monitoring functions

cmake/modules/FindKokkos.cmake

@@ -0,0 +1,57 @@
+# set CMAKE_BUILD_TYPE if not defined
+if(NOT CMAKE_BUILD_TYPE)
+    set(default_build_type "RelWithDebInfo")
+    message(STATUS "Setting build type to '${default_build_type}' as none was specified.")
+    set(
+        CMAKE_BUILD_TYPE
+        "${default_build_type}"
+        CACHE
+        STRING
+        "Choose the type of build, options are: Debug, Release, RelWithDebInfo and MinSizeRel."
+        FORCE
+    )
+endif()
+
+# find Kokkos as an already existing target
+if(TARGET Kokkos::kokkos)
+    return()
+endif()
+
+# find Kokkos as installed
+find_package(Kokkos CONFIG)
+if(Kokkos_FOUND)
+    message(STATUS "Kokkos provided as installed: ${Kokkos_DIR} (version \"${Kokkos_VERSION}\")")
+
+    return()
+endif()
+
+# find Kokkos as an existing source directory
+set(
+    CexaExperimental_KOKKOS_SOURCE_DIR
+    "${CMAKE_CURRENT_SOURCE_DIR}/../../../vendor/kokkos"
+    CACHE
+    PATH
+    "Path to the local source directory of Kokkos"
+)
+if(EXISTS "${CexaExperimental_KOKKOS_SOURCE_DIR}/CMakeLists.txt")
+    message(STATUS "Kokkos provided as a source directory: ${CexaExperimental_KOKKOS_SOURCE_DIR}")
+
+    add_subdirectory("${CexaExperimental_KOKKOS_SOURCE_DIR}" kokkos)
+    set(Kokkos_FOUND True)
+
+    return()
+endif()
+
+# download Kokkos from release and find it
+message(STATUS "Kokkos downloaded: ${CexaExperimental_KOKKOS_SOURCE_DIR}")
+
+include(FetchContent)
+
+FetchContent_Declare(
+    kokkos
+    DOWNLOAD_EXTRACT_TIMESTAMP ON
+    URL https://github.com/kokkos/kokkos/releases/download/4.5.01/kokkos-4.5.01.zip
+    SOURCE_DIR ${CexaExperimental_KOKKOS_SOURCE_DIR}
+)
+FetchContent_MakeAvailable(kokkos)
+set(Kokkos_FOUND True)

memInfo/CMakeLists.txt

@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(cexa-experimental-meminfo LANGUAGES CXX)
+set(CMAKE_BUILD_TYPE "RelWithDebInfo")
+
+if (NOT ${Kokkos_DIR} STREQUAL "")
+    add_subdirectory(${Kokkos_DIR})
+    include_directories(${Kokkos_INCLUDE_DIRS_RET})
+endif()
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/../cmake/modules")
+
+include(CTest)
+
+find_package(Kokkos REQUIRED)
+
+add_subdirectory(src)
+add_subdirectory(unit_test)
+

memInfo/README.md

@@ -0,0 +1,9 @@
+### memInfo
+This is a wrapper for the device _memGetInfo_ function, but it's also available for unified memory space and host space.
+
+### Usage 
+```
+Kokkos::Experimental::memInfo(&free, &total);
+```
+- `total`: Amount of RAM on the system (HBM/DRAM)
+- `free`: Available memory

memInfo/src/CMakeLists.txt

@@ -0,0 +1,3 @@
+add_library(memInfo INTERFACE)
+target_include_directories(memInfo INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(memInfo INTERFACE Kokkos::kokkos)

memInfo/src/cexa_MemInfo.hpp

@@ -0,0 +1,144 @@
+#include <cstddef>
+#include <Kokkos_Core.hpp>
+#include <sstream>
+#include <fstream>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/sysinfo.h>
+#endif
+
+namespace Kokkos {
+namespace Experimental {
+
+// On some systems, overcommit is disabled, and the kernel will not allow memory
+// allocation beyond the commit limit. This means that allocations that only touch
+// a small amount of memory will be accounted for at their full allocation size.
+bool is_overcommit_limit_set() {
+  std::ifstream overcommit_file("/proc/sys/vm/overcommit_memory");
+  int overcommit_value = 0;
+
+  if (overcommit_file.is_open()) {
+    overcommit_file >> overcommit_value;
+    overcommit_file.close();
+  } else {
+    return false;
+  }
+  return (overcommit_value == 2);
+}
+
+size_t get_committed_as() {
+  std::ifstream meminfo("/proc/meminfo");
+  size_t committed_as = 0;
+  char line[256];
+
+  if (meminfo.is_open()) {
+    while (meminfo.getline(line, 256)) {
+      if (strncmp(line, "Committed_AS:", 13) == 0) {
+        std::istringstream iss(line);
+        iss.ignore(256, ':');
+        iss >> committed_as;
+        committed_as = (iss.fail()) ? 0 : committed_as * 1024;
+        meminfo.close();
+        break;
+      }
+    }
+    meminfo.close();
+  }
+  return committed_as;
+}
+
+size_t get_commitLimit() {
+  std::ifstream meminfo("/proc/meminfo");
+  size_t commitLimit = 0;
+  char line[256];
+
+  if (meminfo.is_open()) {
+    while (meminfo.getline(line, 256)) {
+      if (strncmp(line, "CommitLimit:", 12) == 0) {
+        std::istringstream iss(line);
+        iss.ignore(256, ':');
+        iss >> commitLimit;
+        commitLimit = (iss.fail()) ? 0 : commitLimit * 1024;
+        meminfo.close();
+        break;
+      }
+    }
+    meminfo.close();
+  }
+  return commitLimit;
+}
+
+template <typename Space = Kokkos::DefaultExecutionSpace::memory_space>
+void MemGetInfo(size_t* free, size_t* total) {
+  using MemorySpace = typename Space::memory_space;
+  MemGetInfo<MemorySpace>(free, total);
+}
+
+// Single node memory info
+template <>
+void MemGetInfo<Kokkos::HostSpace>(size_t* free, size_t* total) {
+#ifdef _WIN32
+  MEMORYSTATUSEX statex;
+  statex.dwLength = sizeof(statex);
+  if (GlobalMemoryStatusEx(&statex) != 0) {
+    *free  = statex.ullAvailPhys;
+    *total = statex.ullTotalPhys;
+  }
+#else
+  static bool overcommit_limit = is_overcommit_limit_set();
+  struct sysinfo info;
+  if (overcommit_limit) {
+    *total = get_commitLimit();
+    *free = *total - get_committed_as();
+    return;
+  }
+  if (sysinfo(&info) == 0) {
+    *free  = info.freeram * info.mem_unit;
+    *total = info.totalram * info.mem_unit;
+    return;
+  }
+#endif
+}
+
+#if defined(KOKKOS_ENABLE_CUDA)
+template <>
+void MemGetInfo<Kokkos::CudaSpace>(size_t* free, size_t* total) {
+  KOKKOS_IMPL_CUDA_SAFE_CALL(cudaMemGetInfo(free, total));
+}
+template <>
+void MemGetInfo<Kokkos::CudaUVMSpace>(size_t* free, size_t* total) {
+  MemGetInfo<Kokkos::HostSpace>(free, total);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_HIP)
+template <>
+void MemGetInfo<Kokkos::HIPSpace>(size_t* free, size_t* total) {
+  KOKKOS_IMPL_HIP_SAFE_CALL(hipMemGetInfo(free, total));
+}
+template <>
+void MemGetInfo<Kokkos::HIPManagedSpace>(size_t* free, size_t* total) {
+  MemGetInfo<Kokkos::HostSpace>(free, total);
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_SYCL)
+template <>
+void MemGetInfo<Kokkos::SYCLDeviceUSMSpace>(size_t* free, size_t* total) {
+  std::vector<sycl::device> devices = Kokkos::Impl::get_sycl_devices();
+  for (auto& dev : devices) {
+    if (dev.is_gpu()) {
+      *total += dev.get_info<sycl::info::device::global_mem_size>();
+      // https://github.com/triSYCL/sycl/blob/sycl/unified/master/sycl/doc/extensions/supported/sycl_ext_intel_device_info.md#free-global-memory
+      if (dev.has(sycl::aspect::ext_intel_free_memory)) {
+        *free += dev.get_info<sycl::ext::intel::info::device::free_memory>();
+      }
+    }
+  }
+}
+#endif
+
+}  // namespace Experimental
+}  // namespace Kokkos

memInfo/unit_test/CMakeLists.txt

@@ -0,0 +1,16 @@
+
+include(FetchContent)
+
+FetchContent_Declare(
+  googletest
+  URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
+  DOWNLOAD_EXTRACT_TIMESTAMP true
+  )
+FetchContent_MakeAvailable(googletest)
+
+enable_testing()
+add_executable(MemInfoTest TestMemInfo.cpp)
+target_link_libraries(MemInfoTest GTest::gtest_main Kokkos::kokkos memInfo)
+
+include(GoogleTest)
+gtest_discover_tests(MemInfoTest)

memInfo/unit_test/TestMemInfo.cpp

@@ -0,0 +1,82 @@
+#include <Kokkos_Core.hpp>
+#include <cexa_MemInfo.hpp>
+#include <gtest/gtest.h>
+#include <cstddef>
+
+template <typename MemorySpace = void>
+void testMemInfo() {
+  size_t step1_total = 0ul;
+  size_t step2_total = 0ul;
+  size_t step2_free = 0ul;
+  size_t step1_free = 0ul;
+
+  if constexpr (std::is_same<MemorySpace, void>::value) {
+    Kokkos::Experimental::MemGetInfo(&step1_free, &step1_total);
+  } else {
+    Kokkos::Experimental::MemGetInfo<MemorySpace>(&step1_free, &step1_total);
+  }
+  volatile double k = 0.0;
+  {
+    // Allocate 128 MiB of memory
+    Kokkos::View<double**, MemorySpace> data("data test", 128, 1024*1024);
+    if constexpr (std::is_same<MemorySpace, void>::value) {
+      Kokkos::Experimental::MemGetInfo(&step2_free, &step2_total);
+    } else {
+      Kokkos::Experimental::MemGetInfo<MemorySpace>(&step2_free, &step2_total);
+    }
+  }
+  // Same total memory before and after aloccation
+  EXPECT_EQ(step1_total, step2_total);
+  // Check that free memory is less after allocation
+  EXPECT_LT(step2_free, step1_free);
+}
+
+TEST(MemInfo, HostSpace) {
+  Kokkos::initialize();
+  testMemInfo<Kokkos::HostSpace>();
+  Kokkos::finalize();
+}
+TEST(MemInfo, HostSpaceUninitialized) {
+  size_t free = 0;
+  size_t total = 0;
+  Kokkos::Experimental::MemGetInfo<Kokkos::HostSpace>(&free, &total);
+  EXPECT_GT(free, 0);
+  EXPECT_GT(total, 0);
+}
+
+TEST(MemInfo, DefaultSpace) {
+  Kokkos::initialize();
+  testMemInfo<>();
+  Kokkos::finalize();
+}
+TEST(MemInfo, DefaultSpaceUninitialized) {
+  size_t free = 0;
+  size_t total = 0;
+  Kokkos::Experimental::MemGetInfo(&free, &total);
+  EXPECT_GT(free, 0);
+  EXPECT_GT(total, 0);
+}
+
+#if defined(KOKKOS_ENABLE_CUDA)
+TEST(MemInfo, CudaSpace) {
+  Kokkos::initialize();
+  testMemInfo<Kokkos::CudaSpace>();
+  testMemInfo<Kokkos::SharedSpace>();
+  Kokkos::finalize();
+}
+#endif
+
+#if defined(KOKKOS_ENABLE_HIP)
+TEST(MemInfo, HIPSpace) {
+  Kokkos::initialize();
+  testMemInfo<Kokkos::HIPSpace>();
+  testMemInfo<Kokkos::SharedSpace>();
+  Kokkos::finalize();
+}
+#endif
+
+int main(int argc, char *argv[]) {
+  ::testing::InitGoogleTest(&argc, argv);
+  int result = RUN_ALL_TESTS();
+  return result;
+}