[OpenMP] Check output of malloc in the device for debug

[jhuber6]

Summary

A common problem is the device running out of global heap memory and
crashing due to a nullptr dereference when using the data sharing stack.
This explicitly checks that a nullptr was not returned by malloc when
debugging field 1 is enabled.

[jdoerfert]

We should not make it an assert, or not one that uses the first bit of the debug field. We should add a new bit because this can be valid and properly handled by the user. That said, in the device runtime we could add ASSERT for this in various places that don't handle it otherwise.

[jhuber6]

In D112005#3070700, @jdoerfert wrote:

We should not make it an assert, or not one that uses the first bit of the debug field. We should add a new bit because this can be valid and properly handled by the user. That said, in the device runtime we could add ASSERT for this in various places that don't handle it otherwise.

I guess this bit could be for extra runtime checks? Not sure what else we could put under that umbrella.

[jdoerfert]

make it a "common issues" bit and we put things in there as we go. Things that are not necessarily wrong or problematic but most often indicate a problem.

[jhuber6]

Making suggested changes.

[jdoerfert]

LG

[jhuber6]

Updating with ASSERT for the runtime usage.

openmp/libomptarget/DeviceRTL/include/Configuration.h

 #include "Types.h"
 
 namespace _OMP {
 namespace config {
 
 enum DebugKind : uint32_t {
   Assertion = 1U << 0,
   FunctionTracing = 1U << 1,
+  CommonIssues = 1U << 2,
 };
 
 /// Return the number of devices in the system, same number as returned on the
 /// host by omp_get_num_devices.
 uint32_t getNumDevices();
 
 /// Return the number of devices in the system, same number as returned on the
 /// host by omp_get_num_devices.

openmp/libomptarget/DeviceRTL/src/State.cpp

void *SharedMemorySmartStackTy::push(uint64_t Bytes) {
 
   int TId = mapping::getThreadIdInBlock();
   if (Usage[TId] + AlignedBytes <= StorageTotal) {
     void *Ptr = getThreadDataTop(TId);
     Usage[TId] += AlignedBytes;
     return Ptr;
   }
 
-  return memory::allocGlobal(AlignedBytes,
-                             "Slow path shared memory allocation, insufficient "
-                             "shared memory stack memory!");
+  void *GlobalMemory = memory::allocGlobal(
+      AlignedBytes, "Slow path shared memory allocation, insufficient "
+  ASSERT(GlobalMemory != nullptr && "nullptr returned by malloc!");
+
+  return GlobalMemory;
 }
 
 void SharedMemorySmartStackTy::pop(void *Ptr, uint32_t Bytes) {
   uint64_t AlignedBytes = utils::align_up(Bytes, Alignment);
   if (Ptr >= &Data[0] && Ptr < &Data[state::SharedScratchpadSize]) {
     int TId = mapping::getThreadIdInBlock();
     Usage[TId] -= AlignedBytes;
     return;
void *memory::allocShared(uint64_t Bytes, const char *Reason) {
   return SharedMemorySmartStack.push(Bytes);
 }
 
 void memory::freeShared(void *Ptr, uint64_t Bytes, const char *Reason) {
   SharedMemorySmartStack.pop(Ptr, Bytes);
 }
 
 void *memory::allocGlobal(uint64_t Bytes, const char *Reason) {
-  return malloc(Bytes);
+  void *Ptr = malloc(Bytes);
+  if (config::isDebugMode(config::DebugKind::CommonIssues) && Ptr == nullptr)
+    PRINT("nullptr returned by malloc!\n");
+  return Ptr;
 }
 
 void memory::freeGlobal(void *Ptr, const char *Reason) { free(Ptr); }
 
 ///}
 
 namespace {
 

 
 uint32_t &lookupForModify32Impl(uint32_t ICVStateTy::*Var) {
   if (OMP_LIKELY(TeamState.ICVState.LevelVar == 0))
     return TeamState.ICVState.*Var;
   uint32_t TId = mapping::getThreadIdInBlock();
   if (!ThreadStates[TId]) {
     ThreadStates[TId] = reinterpret_cast<ThreadStateTy *>(memory::allocGlobal(
         sizeof(ThreadStateTy), "ICV modification outside data environment"));
+    ASSERT(ThreadStates[TId] != nullptr && "Nullptr returned by malloc!");
     ThreadStates[TId]->init();
   }
   return ThreadStates[TId]->ICVState.*Var;
 }
 
 uint32_t &lookup32Impl(uint32_t ICVStateTy::*Var) {
   uint32_t TId = mapping::getThreadIdInBlock();
   if (OMP_UNLIKELY(ThreadStates[TId]))

 
 void __kmpc_begin_sharing_variables(void ***GlobalArgs, uint64_t nArgs) {
   FunctionTracingRAII();
   if (nArgs <= NUM_SHARED_VARIABLES_IN_SHARED_MEM) {
     SharedMemVariableSharingSpacePtr = &SharedMemVariableSharingSpace[0];
   } else {
     SharedMemVariableSharingSpacePtr = (void **)memory::allocGlobal(
         nArgs * sizeof(void *), "new extended args");
+    ASSERT(SharedMemVariableSharingSpacePtr != nullptr &&
+           "Nullptr returned by malloc!");
   }
   *GlobalArgs = SharedMemVariableSharingSpacePtr;
 }
 
 void __kmpc_end_sharing_variables() {
   FunctionTracingRAII();
   if (SharedMemVariableSharingSpacePtr != &SharedMemVariableSharingSpace[0])
     memory::freeGlobal(SharedMemVariableSharingSpacePtr, "new extended args");
 }
 
 void __kmpc_get_shared_variables(void ***GlobalArgs) {
   FunctionTracingRAII();
   *GlobalArgs = SharedMemVariableSharingSpacePtr;
 }
 }
 #pragma omp end declare target