Merge master to plugin/0.2

.github/workflows/tb_plugin_ci.yml

@@ -5,13 +5,13 @@ on:
     branches:
       - master
       - release/**
-      - tb_plugin
+      - plugin/**
 
   pull_request:
     branches:
       - master
       - release/**
-      - tb_plugin
+      - plugin/**
 
 jobs:
   build:
@@ -37,6 +37,6 @@ jobs:
           set -e
           cd tb_plugin
           sh ./ci_scripts/install_env.sh
-          pip install .
+          pip install .[gs]
           cd test
           pytest

libkineto/CMakeLists.txt

@@ -42,19 +42,19 @@ endif()
 
 # Set LIBKINETO_NOCUPTI to explicitly disable CUPTI
 # Otherwise, CUPTI is disabled if not found
-IF (NOT CUDA_SOURCE_DIR AND NOT CUPTI_INCLUDE_DIR)
+IF (NOT CUDA_SOURCE_DIR OR NOT CUPTI_INCLUDE_DIR OR NOT CUDA_cupti_LIBRARY)
     set(LIBKINETO_NOCUPTI ON CACHE BOOL "" FORCE)
 endif()
 
 # Define file lists
 if (LIBKINETO_NOCUPTI)
-    get_filelist("get_libkineto_cpu_only_srcs()" LIBKINETO_SRCS)
+    get_filelist("get_libkineto_cpu_only_srcs(with_api=False)" LIBKINETO_SRCS)
     message(INFO " CUPTI unavailable or disabled - not building GPU profilers")
 else()
-    get_filelist("get_libkineto_srcs()" LIBKINETO_SRCS)
+    get_filelist("get_libkineto_srcs(with_api=False)" LIBKINETO_SRCS)
 endif()
 get_filelist("get_libkineto_public_headers()" LIBKINETO_PUBLIC_HEADERS)
-set(LIBKINETO_API_SRCS "${LIBKINETO_SOURCE_DIR}/libkineto_api.cpp")
+get_filelist("get_libkineto_api_srcs()" LIBKINETO_API_SRCS)
 
 add_library(kineto_base OBJECT ${LIBKINETO_SRCS})
 add_library(kineto_api OBJECT ${LIBKINETO_API_SRCS})
@@ -69,13 +69,22 @@ set_target_properties(kineto_base kineto_api PROPERTIES
       CXX_EXTENSIONS NO
       CXX_VISIBILITY_PRESET hidden)
 
-target_compile_options(kineto_base PRIVATE "-DKINETO_NAMESPACE=libkineto"
-"-std=gnu++14")
-target_compile_options(kineto_api PRIVATE "-std=gnu++14")
+set(KINETO_COMPILE_OPTIONS "-DKINETO_NAMESPACE=libkineto")
+list(APPEND KINETO_COMPILE_OPTIONS "-DFMT_HEADER_ONLY")
+if(NOT MSVC)
+  list(APPEND KINETO_COMPILE_OPTIONS "-std=c++14")
+else()
+  list(APPEND KINETO_COMPILE_OPTIONS "/std:c++14")
+  list(APPEND KINETO_COMPILE_OPTIONS "-DWIN32_LEAN_AND_MEAN")
+  list(APPEND KINETO_COMPILE_OPTIONS "-DNOGDI")
+endif()
 if (NOT LIBKINETO_NOCUPTI)
-    target_compile_options(kineto_base PRIVATE "-DHAS_CUPTI")
+    list(APPEND KINETO_COMPILE_OPTIONS "-DHAS_CUPTI")
 endif()
 
+target_compile_options(kineto_base PRIVATE "${KINETO_COMPILE_OPTIONS}")
+target_compile_options(kineto_api PRIVATE "${KINETO_COMPILE_OPTIONS}")
+
 if(NOT TARGET fmt)
   if(NOT FMT_SOURCE_DIR)
     set(FMT_SOURCE_DIR "${LIBKINETO_THIRDPARTY_DIR}/fmt"
@@ -95,6 +104,8 @@ if(NOT TARGET fmt)
 endif()
 
 set(FMT_INCLUDE_DIR "${FMT_SOURCE_DIR}/include")
+message(STATUS "Kineto: FMT_SOURCE_DIR = ${FMT_SOURCE_DIR}")
+message(STATUS "Kineto: FMT_INCLUDE_DIR = ${FMT_INCLUDE_DIR}")
 if (NOT CUPTI_INCLUDE_DIR)
     set(CUPTI_INCLUDE_DIR "${CUDA_SOURCE_DIR}/extras/CUPTI/include")
 endif()
@@ -112,6 +123,7 @@ target_include_directories(kineto_base PUBLIC
       $<BUILD_INTERFACE:${CUDA_INCLUDE_DIRS}>)
 
 target_include_directories(kineto_api PUBLIC
+      $<BUILD_INTERFACE:${FMT_INCLUDE_DIR}>
       $<BUILD_INTERFACE:${LIBKINETO_INCLUDE_DIR}>)
 
 if(KINETO_LIBRARY_TYPE STREQUAL "default")
@@ -132,10 +144,11 @@ else()
   message(FATAL_ERROR "Unsupported library type ${KINETO_LIBRARY_TYPE}")
 endif()
 
-target_link_libraries(kineto "${CUDA_cupti_LIBRARY}")
-
-target_link_libraries(kineto $<BUILD_INTERFACE:fmt>)
-add_dependencies(kineto fmt)
+if(NOT LIBKINETO_NOCUPTI)
+  target_link_libraries(kineto "${CUDA_cupti_LIBRARY}")
+endif()
+target_link_libraries(kineto $<BUILD_INTERFACE:fmt::fmt-header-only>)
+add_dependencies(kineto fmt::fmt-header-only)
 
 install(TARGETS kineto EXPORT kinetoLibraryConfig
   ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}

libkineto/include/ActivityProfilerInterface.h

@@ -9,6 +9,7 @@
 
 #include <memory>
 #include <set>
+#include <thread>
 #include <vector>
 
 #include "ActivityType.h"
@@ -17,7 +18,7 @@
 namespace libkineto {
 
 class ActivityProfilerController;
-class CpuTraceBuffer;
+struct CpuTraceBuffer;
 class Config;
 
 class ActivityProfilerInterface {
@@ -76,6 +77,14 @@ class ActivityProfilerInterface {
   virtual bool enableForRegion(const std::string& match) {
     return true;
   }
+
+  // Saves information for the current thread to be used in profiler output
+  // Client must record any new kernel thread where the activity has occured.
+  virtual void recordThreadInfo() {}
+
+  // Record trace metadata, currently supporting only string key and values,
+  // values with the same key are overwritten
+  virtual void addMetadata(const std::string& key, const std::string& value) = 0;
 };
 
 } // namespace libkineto

libkineto/include/ActivityTraceInterface.h

@@ -12,7 +12,7 @@
 
 namespace libkineto {
 
-class TraceActivity;
+struct TraceActivity;
 
 class ActivityTraceInterface {
  public:

libkineto/include/ActivityType.h

@@ -7,15 +7,30 @@
 
 #pragma once
 
+#include <array>
+#include <string>
+
 namespace libkineto {
 
 enum class ActivityType {
-    CPU_OP,
+    CPU_OP = 0, // cpu side ops
+    USER_ANNOTATION,
+    GPU_USER_ANNOTATION,
     GPU_MEMCPY,
     GPU_MEMSET,
-    CONCURRENT_KERNEL,
+    CONCURRENT_KERNEL, // on-device kernels
     EXTERNAL_CORRELATION,
-    CUDA_RUNTIME
+    CUDA_RUNTIME, // host side cuda runtime events
+    GLOW_RUNTIME, // host side glow runtime events
+    CPU_INSTANT_EVENT, // host side point-like events
+    ENUM_COUNT
 };
 
+const char* toString(ActivityType t);
+ActivityType toActivityType(const std::string& str);
+
+// Return an array of all activity types except COUNT
+constexpr int activityTypeCount = (int)ActivityType::ENUM_COUNT;
+const std::array<ActivityType, activityTypeCount> activityTypes();
+
 } // namespace libkineto

libkineto/include/GenericTraceActivity.h

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ * All rights reserved.
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <fmt/format.h>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "ThreadUtil.h"
+#include "TraceActivity.h"
+#include "TraceSpan.h"
+
+namespace libkineto {
+
+// @lint-ignore-every CLANGTIDY cppcoreguidelines-non-private-member-variables-in-classes
+// @lint-ignore-every CLANGTIDY cppcoreguidelines-pro-type-member-init
+class GenericTraceActivity : public TraceActivity {
+
+ public:
+  GenericTraceActivity() = delete;
+
+  GenericTraceActivity(
+      const TraceSpan& trace, ActivityType type, const std::string& name)
+      : activityType(type), activityName(name), traceSpan_(&trace) {
+  }
+
+  int64_t deviceId() const override {
+    return device;
+  }
+
+  int64_t resourceId() const override {
+    return resource;
+  }
+
+  int64_t timestamp() const override {
+    return startTime;
+  }
+
+  int64_t duration() const override {
+    return endTime - startTime;
+  }
+
+  int64_t correlationId() const override {
+    return id;
+  }
+
+  ActivityType type() const override {
+    return activityType;
+  }
+
+  const std::string name() const override {
+    return activityName;
+  }
+
+  const TraceActivity* linkedActivity() const override {
+    return nullptr;
+  }
+
+  const TraceSpan* traceSpan() const override {
+    return traceSpan_;
+  }
+
+  void log(ActivityLogger& logger) const override;
+
+  //Encode client side metadata as a key/value string.
+  void addMetadata(const std::string& key, const std::string& value) {
+    metadata_.push_back(fmt::format("\"{}\": {}", key, value));
+  }
+
+  const std::string getMetadata() const {
+    return fmt::format("{}", fmt::join(metadata_, ", "));
+  }
+
+  virtual ~GenericTraceActivity() {};
+
+  int64_t startTime{0};
+  int64_t endTime{0};
+  int32_t id{0};
+  int32_t device{0};
+  int32_t resource{0};
+  ActivityType activityType;
+  std::string activityName;
+
+ private:
+  const TraceSpan* traceSpan_;
+  std::vector<std::string> metadata_;
+};
+
+} // namespace libkineto