[WIP] Kokkos metadata handling in specific service

src/caliper/controllers/controllers.cpp

@@ -152,7 +152,7 @@ const char* builtin_option_specs =
     " \"type\"        : \"bool\","
     " \"description\" : \"Profile Kokkos functions\","
     " \"category\"    : \"region\","
-    " \"services\"    : [ \"kokkostime\" ]"
+    " \"services\"    : [ \"kokkostime\", \"kokkosadiak\" ]"
     "},"
     "{"
     " \"name\"        : \"main_thread_only\","

src/services/kokkos/CMakeLists.txt

@@ -2,8 +2,12 @@ set(CALIPER_KOKKOS_SOURCES
   KokkosProfilingSymbols.cpp
   KokkosLookup.cpp
   KokkosTime.cpp
-)
-
+     )
+if(WITH_ADIAK)
+include_directories(${adiak_INCLUDE_DIRS})
+    list(APPEND CALIPER_KOKKOS_SOURCES "KokkosMetadataService.cpp")
+    add_caliper_service("kokkosadiak")
+endif()
 add_library(caliper-kokkos OBJECT ${CALIPER_KOKKOS_SOURCES})
 
 add_service_objlib("caliper-kokkos")

src/services/kokkos/KokkosMetadataService.cpp

@@ -0,0 +1,88 @@
+//
+// Created by Poliakoff, David Zoeller on 4/21/21.
+//
+
+#include "caliper/CaliperService.h"
+
+#include "caliper/Caliper.h"
+#include "../../caliper/MemoryPool.h"
+
+#include "caliper/common/Log.h"
+#include "caliper/common/RuntimeConfig.h"
+#include "caliper/Annotation.h"
+
+#include <iterator>
+#include <cstdint>
+
+#include "types.hpp"
+#include "adiak.hpp"
+using namespace cali;
+
+namespace {
+
+    class KokkosAdiak {
+        static const ConfigSet::Entry s_configdata[];
+
+        KokkosAdiak(Caliper *c, Channel *chn) {
+           adiak_init(nullptr);
+           adiak::user();
+           adiak::launchdate();
+           adiak::executablepath();
+           adiak::libraries();
+           adiak::cmdline();
+           adiak::clustername();
+           adiak::jobsize();
+        }
+
+    public:
+
+        void declare(const char* key, const char* value){
+            std::string parseme(value);
+            try {
+                size_t end;
+                float v = std::stof(parseme,&end);
+                adiak::value(key, v);
+                return;
+            }
+            catch(std::invalid_argument){
+            }
+            try {
+                size_t end;
+                int i = std::stoi(parseme,&end);
+                adiak::value(key, i);
+                return;
+            }
+            catch(std::invalid_argument){
+            }
+            adiak::value(key,value);
+        }
+        static void kokkosadiak_register(Caliper *c, Channel *chn) {
+
+            auto *instance = new KokkosAdiak(c, chn);
+            chn->events().post_init_evt.connect(
+                    [instance](Caliper *c, Channel *chn) {
+                        kokkosp_callbacks.kokkosp_declare_metadata.connect([&](const char* name, const char* value){
+                            instance->declare(name,value);
+                        });
+                    });
+            chn->events().finish_evt.connect(
+                    [instance](Caliper*, Channel*){
+                        delete instance;
+                    });
+
+            Log(1).stream() << chn->name() << ": Registered kokkosadiak service" << std::endl;
+        }
+    };
+
+    const ConfigSet::Entry KokkosAdiak::s_configdata[] = {
+            ConfigSet::Terminator
+    };
+
+} // namespace [anonymous]
+
+
+namespace cali {
+
+    CaliperService kokkosadiak_service{"kokkosadiak", ::KokkosAdiak::kokkosadiak_register};
+
+}

src/services/kokkos/KokkosProfilingSymbols.cpp

@@ -105,3 +105,6 @@ kokkosp_begin_deep_copy(const SpaceHandle dst_handle, const char *dst_name,
 extern "C" void kokkosp_end_deep_copy() {
   kokkosp_callbacks.kokkosp_end_deep_copy_callback();
 }
+extern "C" void kokkosp_declare_metadata(const char* key, const char* value){
+    kokkosp_callbacks.kokkosp_declare_metadata(key, value);
+}

src/services/kokkos/types.hpp

@@ -32,8 +32,9 @@ namespace kokkos {
         using end_deep_copy_callback = util::callback<void()>;
 
 	using begin_fence_callback = util::callback<void(const char*, const uint32_t, uint64_t*)>; 
-	using end_fence_callback = util::callback<void(uint64_t)>; 
-        struct callbacks {
+	using end_fence_callback = util::callback<void(uint64_t)>;
+    using metadata_callback = util::callback<void(const char*, const char*)>;
+    struct callbacks {
 
             init_callback kokkosp_init_callback;
             finalize_callback kokkosp_finalize_callback;
@@ -58,7 +59,9 @@ namespace kokkos {
 
             begin_fence_callback kokkosp_begin_fence_callback;
             end_fence_callback kokkosp_end_fence_callback;
-        };
+
+            metadata_callback kokkosp_declare_metadata;
+    };
 
 } // end namespace kokkos