Programatically filter out tool-induced fences from the sampler tool utility

common/kokkos-sampler/kp_sampler_skip.cpp

@@ -3,15 +3,19 @@
 #include <cstdlib>
 #include <cstring>
 #include <dlfcn.h>
+// #include <impl/Kokkos_Profiling_Interface.hpp>
 #include "../../profiling/all/kp_core.hpp"
 #include "kp_config.hpp"
 
+// using Kokkos::Tools::Experimental;
+// using mytpi_type = Kokkos::Tools::Experimental::ToolProgrammingInterface;
 namespace KokkosTools {
 namespace Sampler {
 static uint64_t uniqID           = 0;
 static uint64_t kernelSampleSkip = 101;
 static int tool_verbosity        = 0;
 static int tool_globFence        = 0;
+// mytpi_type mytpi;
 
 typedef void (*initFunction)(const int, const uint64_t, const uint32_t, void*);
 typedef void (*finalizeFunction)();
@@ -27,6 +31,45 @@ static endFunction endForCallee                = NULL;
 static endFunction endScanCallee               = NULL;
 static endFunction endReduceCallee             = NULL;
 
+void getGlobFenceChoice() {
+  // re-read environment variable to get most accurate value
+  const char* tool_globFence_str = getenv("KOKKOS_TOOLS_GLOBALFENCES");
+  if (NULL != tool_globFence_str) {
+    tool_globFence = atoi(tool_globFence_str);
+  }  // else
+     // tool_globFence = 0;
+}
+
+// void kokkosp_tool_invoked_fence(const uint32_t, Kokkos_Tools_SpaceHandle*
+// myspchandle, Kokkos_Tools_toolInvokedFenceFunction tool_fence)
+//{
+//(*tool_fence)(myspchandle, );
+// }
+
+// set of functions from Kokkos ToolProgrammingInterface (includes fence)
+Kokkos::Tools::Experimental::ToolProgrammingInterface tpi_funcs;
+
+void invoke_ktools_fence(uint32_t devID) {
+  // assert( tpi_funcs ! = NULL)
+  if (tpi_funcs.fence != nullptr) {
+    tpi_funcs.fence(devID);
+  } else
+    printf(
+        "KokkosP: FATAL: Kokkos Tools Programming Interface's tool-invoked "
+        "Fence is NULL!\n");
+}
+
+void kokkosp_provide_tool_programming_interface(
+    uint32_t num_funcs, Kokkos_Tools_ToolProgrammingInterface* funcsFromTPI) {
+  if (!num_funcs) {
+    if (tool_verbosity > 0)
+      printf(
+          "KokkosP: Note: Number of functions in Tools Programming Interface "
+          "is 0!\n");
+  }
+  tpi_funcs = *funcsFromTPI;
+}
+
 void kokkosp_request_tool_settings(const uint32_t,
                                    Kokkos_Tools_ToolSettings* settings) {
   if (0 == tool_globFence) {
@@ -82,9 +125,7 @@ void kokkosp_init_library(const int loadSeq, const uint64_t interfaceVer,
       printf("KokkosP: Next library to call: %s\n", nextLibrary);
       printf("KokkosP: Loading child library ..\n");
     }
-
     void* childLibrary = dlopen(nextLibrary, RTLD_NOW | RTLD_GLOBAL);
-
     if (NULL == childLibrary) {
       fprintf(stderr, "KokkosP: Error: Unable to load: %s (Error=%s)\n",
               nextLibrary, dlerror());
@@ -103,17 +144,14 @@ void kokkosp_init_library(const int loadSeq, const uint64_t interfaceVer,
           (endFunction)dlsym(childLibrary, "kokkosp_end_parallel_for");
       endReduceCallee =
           (endFunction)dlsym(childLibrary, "kokkosp_end_parallel_reduce");
-
       initProfileLibrary =
           (initFunction)dlsym(childLibrary, "kokkosp_init_library");
       finalizeProfileLibrary =
           (finalizeFunction)dlsym(childLibrary, "kokkosp_finalize_library");
-
       if (NULL != initProfileLibrary) {
         (*initProfileLibrary)(loadSeq + 1, interfaceVer, devInfoCount,
                               deviceInfo);
       }
-
       if (tool_verbosity > 0) {
         printf("KokkosP: Function Status:\n");
         printf("KokkosP: begin-parallel-for:      %s\n",
@@ -133,9 +171,7 @@ void kokkosp_init_library(const int loadSeq, const uint64_t interfaceVer,
   }
 
   free(envBuffer);
-
-  uniqID = 1;
-
+  uniqID                  = 1;
   const char* tool_sample = getenv("KOKKOS_TOOLS_SAMPLER_SKIP");
   if (NULL != tool_sample) {
     kernelSampleSkip = atoi(tool_sample) + 1;
@@ -152,9 +188,18 @@ void kokkosp_finalize_library() {
 
 void kokkosp_begin_parallel_for(const char* name, const uint32_t devID,
                                 uint64_t* kID) {
-  *kID = uniqID++;
-
-  if (((*kID) % kernelSampleSkip) == 0) {
+  *kID = 0;
+  static uint64_t invocationNum;
+  ++invocationNum;
+  if ((invocationNum % kernelSampleSkip) == 0) {
+    getGlobFenceChoice();  // re-read environment variable to get most accurate
+                           // value
+    if (0 < tool_globFence) {
+      invoke_ktools_fence(
+          0);  // invoke tool-induced fence from device 0 for now
+    }
+    *kID =
+        1;  // set kernel ID to 1 so that it is matched with the end_parallel_*
     if (tool_verbosity > 0) {
       printf("KokkosP: sample %llu calling child-begin function...\n",
              (unsigned long long)(*kID));
@@ -167,12 +212,17 @@ void kokkosp_begin_parallel_for(const char* name, const uint32_t devID,
 }
 
 void kokkosp_end_parallel_for(const uint64_t kID) {
-  if ((kID % kernelSampleSkip) == 0) {
+  if (kID > 0) {
+    getGlobFenceChoice();  // re-read environment variable to get most accurate
+                           // value
+    if (0 < tool_globFence) {
+      invoke_ktools_fence(
+          0);  // invoke tool-induced fence from device 0 for now
+    }
     if (tool_verbosity > 0) {
       printf("KokkosP: sample %llu calling child-end function...\n",
              (unsigned long long)(kID));
     }
-
     if (NULL != endForCallee) {
       (*endForCallee)(kID);
     }
@@ -181,60 +231,89 @@ void kokkosp_end_parallel_for(const uint64_t kID) {
 
 void kokkosp_begin_parallel_scan(const char* name, const uint32_t devID,
                                  uint64_t* kID) {
-  *kID = uniqID++;
-
-  if (((*kID) % kernelSampleSkip) == 0) {
+  *kID = 0;  // set memory location value of kID to 0.
+  static uint64_t invocationNum;
+  ++invocationNum;
+  if ((invocationNum % kernelSampleSkip) == 0) {
+    getGlobFenceChoice();  // re-read environment variable to get most accurate
+                           // value
+    if (0 < tool_globFence) {
+      // using tool-induced fence from Kokkos_profiling rather than
+      // Kokkos_C_Profiling_interface. Note that this function
+      // only invokes a global (device 0 invoked) fence
+      invoke_ktools_fence(0);
+    }
+    *kID = 1;  // set kernel ID to 1 so that it is matched with the end.
     if (tool_verbosity > 0) {
       printf("KokkosP: sample %llu calling child-begin function...\n",
              (unsigned long long)(*kID));
     }
-
     if (NULL != beginScanCallee) {
       (*beginScanCallee)(name, devID, kID);
     }
   }
 }
 
 void kokkosp_end_parallel_scan(const uint64_t kID) {
-  if ((kID % kernelSampleSkip) == 0) {
+  if (kID > 0) {
+    getGlobFenceChoice();  // re-read environment variable to get most accurate
+                           // value
+    if (0 < tool_globFence) {
+      // using tool-induced fence from Kokkos_profiling rather than
+      // Kokkos_C_Profiling_interface. Note that this function
+      // only invokes a global (device 0 invoked) fence.
+      invoke_ktools_fence(0);
+    }
     if (tool_verbosity > 0) {
       printf("KokkosP: sample %llu calling child-end function...\n",
              (unsigned long long)(kID));
     }
-
     if (NULL != endScanCallee) {
       (*endScanCallee)(kID);
     }
-  }
+  }  // end kID sample
 }
 
 void kokkosp_begin_parallel_reduce(const char* name, const uint32_t devID,
                                    uint64_t* kID) {
-  *kID = uniqID++;
-
-  if (((*kID) % kernelSampleSkip) == 0) {
+  *kID = 0;
+  static uint64_t invocationNum;
+  ++invocationNum;
+  if ((invocationNum % kernelSampleSkip) == 0) {
+    getGlobFenceChoice();  // re-read environment variable to get most accurate
+                           // value
+    if (0 < tool_globFence) {
+      // using tool-induced fence from Kokkos_profiling rather than
+      // Kokkos_C_Profiling_interface. Note that this function
+      // only invokes a global (device 0 invoked) fence.
+      invoke_ktools_fence(0);
+    }
+    *kID = 1;  // set kernel ID to 1 so that it is matched with the end.
     if (tool_verbosity > 0) {
       printf("KokkosP: sample %llu calling child-begin function...\n",
              (unsigned long long)(*kID));
     }
-
     if (NULL != beginReduceCallee) {
       (*beginReduceCallee)(name, devID, kID);
     }
   }
 }
 
 void kokkosp_end_parallel_reduce(const uint64_t kID) {
-  if ((kID % kernelSampleSkip) == 0) {
+  if (kID > 0) {
+    getGlobFenceChoice();  // re-read environment variable to get most accurate
+                           // value
+    if (0 < tool_globFence) {  // Todo: see if this is a performance bottleneck
+      invoke_ktools_fence(0);
+    }
     if (tool_verbosity > 0) {
       printf("KokkosP: sample %llu calling child-end function...\n",
              (unsigned long long)(kID));
     }
-
     if (NULL != endReduceCallee) {
       (*endReduceCallee)(kID);
     }
-  }
+  }  // end kID sample
 }
 
 }  // namespace Sampler
@@ -243,8 +322,10 @@ void kokkosp_end_parallel_reduce(const uint64_t kID) {
 extern "C" {
 
 namespace impl = KokkosTools::Sampler;
-
+EXPOSE_TOOL_PROGRAMMING_INTERFACE(
+    impl::kokkosp_provide_tool_programming_interface)
 EXPOSE_TOOL_SETTINGS(impl::kokkosp_request_tool_settings)
+
 EXPOSE_INIT(impl::kokkosp_init_library)
 EXPOSE_FINALIZE(impl::kokkosp_finalize_library)
 EXPOSE_BEGIN_PARALLEL_FOR(impl::kokkosp_begin_parallel_for)

example/kernels.hpp

@@ -9,27 +9,30 @@ int run_calculation(const data_type SIZE) {
 
   Kokkos::View<data_type*> data(Kokkos::ViewAllocateWithoutInitializing("data"),
                                 SIZE);
-  Kokkos::parallel_for(
-      "initialize()", SIZE, KOKKOS_LAMBDA(data_type i) { data(i) = i; });
-  Kokkos::fence();
+  for (int tstep = 0; tstep < 1000; tstep++) {
+    Kokkos::parallel_for(
+        "initialize()", SIZE, KOKKOS_LAMBDA(data_type i) { data(i) = i; });
+    Kokkos::fence();
 
-  data_type sum = 0;
-  Kokkos::parallel_reduce(
-      "accumulate()", SIZE,
-      KOKKOS_LAMBDA(data_type i, data_type & lsum) { lsum += 1 + data(i); },
-      sum);
-  Kokkos::fence();
+    data_type sum = 0;
+    Kokkos::parallel_reduce(
+        "accumulate()", SIZE,
+        KOKKOS_LAMBDA(data_type i, data_type & lsum) { lsum += 1 + data(i); },
+        sum);
+    Kokkos::fence();
 
-  Kokkos::Profiling::popRegion();
+    Kokkos::Profiling::popRegion();
+
+    // check results
+    const data_type check = (SIZE + 1) * SIZE / 2;
+    if (sum != check) {
+      std::cout << "BAD result, got S(" << SIZE << ") = " << sum
+                << " (expected " << check << ")" << std::endl;
+      return 1;
+    }
+    std::cout << "Result OK: S(" << SIZE << ") = " << sum << std::endl;
+  }  // end timestep loop
 
-  // check results
-  const data_type check = (SIZE + 1) * SIZE / 2;
-  if (sum != check) {
-    std::cout << "BAD result, got S(" << SIZE << ") = " << sum << " (expected "
-              << check << ")" << std::endl;
-    return 1;
-  }
-  std::cout << "Result OK: S(" << SIZE << ") = " << sum << std::endl;
   return 0;
 }
 

profiling/all/CMakeLists.txt

@@ -19,4 +19,4 @@ endif()
 file(GLOB_RECURSE HEADER_FILES CONFIGURE_DEPENDS kp_all.hpp "${COMMON_HEADERS_PATH}/*.hpp")
 
 install(FILES ${HEADER_FILES} DESTINATION ${EXPORT_INCLUDE_DIR})
-install(TARGETS ${LIBNAME} EXPORT ${EXPORT_NAME})
+install(TARGETS ${LIBNAME} EXPORT ${EXPORT_NAME})

profiling/all/kp_core.hpp

@@ -55,6 +55,13 @@ using Kokkos::Tools::SpaceHandle;
     FUNC_NAME(num_actions, settings);                                    \
   }
 
+#define EXPOSE_TOOL_PROGRAMMING_INTERFACE(FUNC_NAME)                     \
+  __attribute__((weak)) void kokkosp_provide_tool_programming_interface( \
+      const uint32_t num_actions,                                        \
+      Kokkos_Tools_ToolProgrammingInterface* tool_funcs) {               \
+    FUNC_NAME(num_actions, tool_funcs);                                  \
+  }
+
 #define EXPOSE_INIT(FUNC_NAME)                                  \
   __attribute__((weak)) void kokkosp_init_library(              \
       const int loadSeq, const uint64_t interfaceVer,           \