[OpenMP] Add function tracing debugging to device RTL

[jhuber6]

Summary

This patch adds support for an RAII struct that will print function
traces when placed inside of a function declaration. Each successive
call will increase the indentation to make it easier to visually
inspect.

[tianshilei1992]

openmp/libomptarget/DeviceRTL/include/Configuration.h

22–23

openmp/libomptarget/DeviceRTL/include/Debug.h

32

Just ENTER?

[jhuber6]

openmp/libomptarget/DeviceRTL/include/Debug.h

32

Wasn't sure what to call it, could be like FunctionTrace or something.

[jdoerfert]

Add them to the entry points and some other "important functions" like parallel_51.

openmp/libomptarget/DeviceRTL/include/Debug.h

32

#define FunctionTracingRAII()

34

Documentation, also for the macro.

openmp/libomptarget/DeviceRTL/src/Debug.cpp

48

swap these two, same below.

[jhuber6]

Addressing comments.

[jdoerfert]

LG, one nit.

openmp/libomptarget/DeviceRTL/src/Debug.cpp

42

This needs to be in shared memory. static works fine, no namespace needed.

[jhuber6]

Changing to shared, removing FILE because it includes the whole path and takes up a lot of space.

[tianshilei1992]

openmp/libomptarget/DeviceRTL/src/Debug.cpp

52

There are four placeholders but only three arguments. What is the last %u?

[jhuber6]

openmp/libomptarget/DeviceRTL/src/Debug.cpp

52

Fixed in D112002, but it hasn't been reviewed.

openmp/libomptarget/DeviceRTL/include/Configuration.h

 #ifndef OMPTARGET_CONFIGURATION_H
 #define OMPTARGET_CONFIGURATION_H
 
 #include "Types.h"
 
 namespace _OMP {
 namespace config {
 
-enum DebugLevel : int32_t { Assertion };
+enum DebugKind : uint32_t {
+  Assertion = 1U << 0,
+  FunctionTracing = 1U << 1,
+};
 
 /// 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.
 uint32_t getDeviceNum();
 
 /// Return the user choosen debug level.
-uint32_t getDebugLevel();
+uint32_t getDebugKind();
 
 /// Return the amount of dynamic shared memory that was allocated at launch.
 uint64_t getDynamicMemorySize();
 
-bool isDebugMode(DebugLevel Level);
+bool isDebugMode(DebugKind Level);
 
 } // namespace config
 } // namespace _OMP
 
 #endif

openmp/libomptarget/DeviceRTL/include/Debug.h

 #define ASSERT(e) __assert_assume(e, #e, __FILE__, __LINE__)
 
 ///}
 
 // TODO: We need to allow actual printf.
 #define PRINTF(fmt, ...) (void)fmt;
 #define PRINT(str) PRINTF("%s", str)
 
+///}
+
+/// Enter a debugging scope for performing function traces. Enabled with
+/// FunctionTracting set in the debug kind.
+#define FunctionTracingRAII()                                                  \
+  DebugEntryRAII Entry(__LINE__, __PRETTY_FUNCTION__);
+
+/// An RAII class for handling entries to debug locations. The current location
+/// and function will be printed on entry. Nested levels increase the
+/// indentation shown in the debugging output.
+struct DebugEntryRAII {
+  DebugEntryRAII(const unsigned Line, const char *Function);
+  ~DebugEntryRAII();
+};
+
 #endif

openmp/libomptarget/DeviceRTL/src/Configuration.cpp

 
 #include "Configuration.h"
 #include "State.h"
 #include "Types.h"
 
 using namespace _OMP;
 
 struct DeviceEnvironmentTy {
-  uint32_t DebugLevel;
+  uint32_t DebugKind;
   uint32_t NumDevices;
   uint32_t DeviceNum;
   uint64_t DynamicMemSize;
 };
 
 #pragma omp declare target
 
 extern uint32_t __omp_rtl_debug_kind;
 
 // TOOD: We want to change the name as soon as the old runtime is gone.
 DeviceEnvironmentTy CONSTANT(omptarget_device_environment)
     __attribute__((used));
 
-uint32_t config::getDebugLevel() {
-  return __omp_rtl_debug_kind & omptarget_device_environment.DebugLevel;
+uint32_t config::getDebugKind() {
+  return __omp_rtl_debug_kind & omptarget_device_environment.DebugKind;
 }
 
 uint32_t config::getNumDevices() {
   return omptarget_device_environment.NumDevices;
 }
 
 uint32_t config::getDeviceNum() {
   return omptarget_device_environment.DeviceNum;
 }
 
 uint64_t config::getDynamicMemorySize() {
   return omptarget_device_environment.DynamicMemSize;
 }
 
-bool config::isDebugMode(config::DebugLevel Level) {
-  return config::getDebugLevel() > Level;
+bool config::isDebugMode(config::DebugKind Kind) {
+  return config::getDebugKind() & Kind;
 }
 
 #pragma omp end declare target

openmp/libomptarget/DeviceRTL/src/Debug.cpp

 //===--- Debug.cpp -------- Debug utilities ----------------------- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains debug utilities
 //
 //===----------------------------------------------------------------------===//
 
 #include "Debug.h"
 #include "Configuration.h"
+#include "Mapping.h"
+#include "Types.h"
 
 using namespace _OMP;
 
 #pragma omp declare target
 
 extern "C" {
 void __assert_assume(bool cond, const char *exp, const char *file, int line) {
-  if (!cond && config::isDebugMode(config::DebugLevel::Assertion)) {
+  if (!cond && config::isDebugMode(config::DebugKind::Assertion)) {
     PRINTF("ASSERTION failed: %s at %s, line %d\n", exp, file, line);
     __builtin_trap();
   }
 
   __builtin_assume(cond);
 }
 
 void __assert_fail(const char *assertion, const char *file, unsigned line,
                    const char *function) {
   PRINTF("%s:%u: %s: Assertion `%s' failed.\n", file, line, function,
          assertion);
   __builtin_trap();
 }
 }
 
+/// Current indentation level for the function trace. Only accessed by thread 0.
+static uint32_t Level = 0;
+#pragma omp allocate(Level) allocator(omp_pteam_mem_alloc)
+
+DebugEntryRAII::DebugEntryRAII(const unsigned Line, const char *Function) {
+  if (config::isDebugMode(config::DebugKind::FunctionTracing) &&
+      mapping::getThreadIdInBlock() == 0) {
+
+    for (int I = 0; I < Level; ++I)
+      PRINTF("%s", "  ");
+
+    PRINTF("Line %u: Thread %u Entering %s:%u\n", Line,
+           mapping::getThreadIdInBlock(), Function);
+    Level++;
+  }
+}
+
+DebugEntryRAII::~DebugEntryRAII() {
+  if (config::isDebugMode(config::DebugKind::FunctionTracing) &&
+      mapping::getThreadIdInBlock() == 0)
+    Level--;
+}
+
 #pragma omp end declare target