thread: add Windows implementation

include/envoy/api/api.h

@@ -48,10 +48,9 @@ class Api {
   virtual std::string fileReadToEnd(const std::string& path) PURE;
 
   /**
-   * Create a thread.
-   * @param thread_routine supplies the function to invoke in the thread.
+   * @return a reference to the ThreadFactory
    */
-  virtual Thread::ThreadPtr createThread(std::function<void()> thread_routine) PURE;
+  virtual Thread::ThreadFactory& threadFactory() PURE;
 };
 
 typedef std::unique_ptr<Api> ApiPtr;

include/envoy/common/platform.h

@@ -1,14 +1,14 @@
 #pragma once
 
 // NOLINT(namespace-envoy)
-#if !defined(_MSC_VER)
-#define PACKED_STRUCT(definition, ...) definition, ##__VA_ARGS__ __attribute__((packed))
-
-#else
+#ifdef _MSC_VER
 #include <malloc.h>
 
 #define PACKED_STRUCT(definition, ...)                                                             \
   __pragma(pack(push, 1)) definition, ##__VA_ARGS__;                                               \
   __pragma(pack(pop))
 
+#else
+#define PACKED_STRUCT(definition, ...) definition, ##__VA_ARGS__ __attribute__((packed))
+
 #endif

include/envoy/event/BUILD

@@ -48,7 +48,6 @@ envoy_cc_library(
     hdrs = ["timer.h"],
     deps = [
         "//include/envoy/common:time_interface",
-        "//source/common/common:thread_lib",
         "//source/common/event:libevent_lib",
     ],
 )

include/envoy/event/timer.h

@@ -7,7 +7,6 @@
 #include "envoy/common/pure.h"
 #include "envoy/common/time.h"
 
-#include "common/common/thread.h"
 #include "common/event/libevent.h"
 
 namespace Envoy {

include/envoy/server/BUILD

@@ -64,6 +64,7 @@ envoy_cc_library(
     deps = [
         "//include/envoy/server:watchdog_interface",
         "//include/envoy/stats:stats_interface",
+        "//include/envoy/thread:thread_interface",
     ],
 )
 
@@ -134,6 +135,7 @@ envoy_cc_library(
     deps = [
         "//include/envoy/event:dispatcher_interface",
         "//include/envoy/network:address_interface",
+        "//include/envoy/thread:thread_interface",
     ],
 )
 

include/envoy/server/guarddog.h

@@ -26,9 +26,9 @@ class GuardDog {
    * to avoid triggering the GuardDog. If no longer needed use the
    * stopWatching() method to remove it from the list of watched objects.
    *
-   * @param thread_id A numeric thread ID, like from Thread::currentThreadId()
+   * @param thread_id a Thread::ThreadIdPtr containing the system thread id
    */
-  virtual WatchDogSharedPtr createWatchDog(int32_t thread_id) PURE;
+  virtual WatchDogSharedPtr createWatchDog(Thread::ThreadIdPtr&& thread_id) PURE;
 
   /**
    * Tell the GuardDog to forget about this WatchDog.

include/envoy/server/watchdog.h

@@ -4,6 +4,7 @@
 
 #include "envoy/common/pure.h"
 #include "envoy/event/dispatcher.h"
+#include "envoy/thread/thread.h"
 
 namespace Envoy {
 namespace Server {
@@ -35,7 +36,7 @@ class WatchDog {
    * This can be used if this is later used on a thread where there is no dispatcher.
    */
   virtual void touch() PURE;
-  virtual int32_t threadId() const PURE;
+  virtual const Thread::ThreadId& threadId() const PURE;
   virtual MonotonicTime lastTouchTime() const PURE;
 };
 

include/envoy/thread/thread.h

@@ -10,6 +10,16 @@
 namespace Envoy {
 namespace Thread {
 
+class ThreadId {
+public:
+  virtual ~ThreadId() {}
+
+  virtual std::string debugString() const PURE;
+  virtual bool isCurrentThreadId() const PURE;
+};
+
+typedef std::unique_ptr<ThreadId> ThreadIdPtr;
+
 class Thread {
 public:
   virtual ~Thread() {}
@@ -34,6 +44,11 @@ class ThreadFactory {
    * @param thread_routine supplies the function to invoke in the thread.
    */
   virtual ThreadPtr createThread(std::function<void()> thread_routine) PURE;
+
+  /**
+   * Return the current system thread ID
+   */
+  virtual ThreadIdPtr currentThreadId() PURE;
 };
 
 /**

source/common/api/api_impl.cc

@@ -16,7 +16,7 @@ Impl::Impl(std::chrono::milliseconds file_flush_interval_msec,
       file_system_(file_flush_interval_msec, thread_factory, stats_store) {}
 
 Event::DispatcherPtr Impl::allocateDispatcher(Event::TimeSystem& time_system) {
-  return Event::DispatcherPtr{new Event::DispatcherImpl(time_system)};
+  return std::make_unique<Event::DispatcherImpl>(time_system, *this);
 }
 
 Filesystem::FileSharedPtr Impl::createFile(const std::string& path, Event::Dispatcher& dispatcher,
@@ -28,9 +28,7 @@ bool Impl::fileExists(const std::string& path) { return Filesystem::fileExists(p
 
 std::string Impl::fileReadToEnd(const std::string& path) { return Filesystem::fileReadToEnd(path); }
 
-Thread::ThreadPtr Impl::createThread(std::function<void()> thread_routine) {
-  return thread_factory_.createThread(thread_routine);
-}
+Thread::ThreadFactory& Impl::threadFactory() { return thread_factory_; }
 
 } // namespace Api
 } // namespace Envoy

source/common/api/api_impl.h

@@ -27,7 +27,7 @@ class Impl : public Api::Api {
                                        Thread::BasicLockable& lock) override;
   bool fileExists(const std::string& path) override;
   std::string fileReadToEnd(const std::string& path) override;
-  Thread::ThreadPtr createThread(std::function<void()> thread_routine) override;
+  Thread::ThreadFactory& threadFactory() override;
   Filesystem::Instance& fileSystem() { return file_system_; }
 
 private:

source/common/common/BUILD

@@ -4,6 +4,9 @@ load(
     "//bazel:envoy_build_system.bzl",
     "envoy_basic_cc_library",
     "envoy_cc_library",
+    "envoy_cc_platform_dep",
+    "envoy_cc_posix_library",
+    "envoy_cc_win32_library",
     "envoy_include_prefix",
     "envoy_package",
     "envoy_select_boringssl",
@@ -180,12 +183,29 @@ envoy_cc_library(
 
 envoy_cc_library(
     name = "thread_lib",
-    srcs = ["thread.cc"],
     hdrs = ["thread.h"],
     external_deps = ["abseil_synchronization"],
+    deps = envoy_cc_platform_dep("thread_impl_lib"),
+)
+
+envoy_cc_posix_library(
+    name = "thread_impl_lib",
+    srcs = ["posix/thread_impl.cc"],
+    hdrs = ["posix/thread_impl.h"],
+    strip_include_prefix = "posix",
+    deps = [
+        ":assert_lib",
+        "//include/envoy/thread:thread_interface",
+    ],
+)
+
+envoy_cc_win32_library(
+    name = "thread_impl_lib",
+    srcs = ["win32/thread_impl.cc"],
+    hdrs = ["win32/thread_impl.h"],
+    strip_include_prefix = "win32",
     deps = [
         ":assert_lib",
-        ":macros",
         "//include/envoy/thread:thread_interface",
     ],
 )

source/common/common/posix/thread_impl.cc

@@ -0,0 +1,59 @@
+#include "common/common/assert.h"
+#include "common/common/thread_impl.h"
+
+#if defined(__linux__)
+#include <sys/syscall.h>
+#endif
+
+namespace Envoy {
+namespace Thread {
+
+namespace {
+
+int64_t getCurrentThreadId() {
+#ifdef __linux__
+  return static_cast<int64_t>(syscall(SYS_gettid));
+#elif defined(__APPLE__)
+  uint64_t tid;
+  pthread_threadid_np(NULL, &tid);
+  return tid;
+#else
+#error "Enable and test pthread id retrieval code for you arch in pthread/thread_impl.cc"
+#endif
+}
+
+} // namespace
+
+ThreadIdImplPosix::ThreadIdImplPosix(int64_t id) : id_(id) {}
+
+std::string ThreadIdImplPosix::debugString() const { return std::to_string(id_); }
+
+bool ThreadIdImplPosix::isCurrentThreadId() const { return id_ == getCurrentThreadId(); }
+
+ThreadImplPosix::ThreadImplPosix(std::function<void()> thread_routine)
+    : thread_routine_(thread_routine) {
+  RELEASE_ASSERT(Logger::Registry::initialized(), "");
+  const int rc = pthread_create(&thread_handle_, nullptr,
+                                [](void* arg) -> void* {
+                                  static_cast<ThreadImplPosix*>(arg)->thread_routine_();
+                                  return nullptr;
+                                },
+                                this);
+  RELEASE_ASSERT(rc == 0, "");
+}
+
+void ThreadImplPosix::join() {
+  const int rc = pthread_join(thread_handle_, nullptr);
+  RELEASE_ASSERT(rc == 0, "");
+}
+
+ThreadPtr ThreadFactoryImplPosix::createThread(std::function<void()> thread_routine) {
+  return std::make_unique<ThreadImplPosix>(thread_routine);
+}
+
+ThreadIdPtr ThreadFactoryImplPosix::currentThreadId() {
+  return std::make_unique<ThreadIdImplPosix>(getCurrentThreadId());
+}
+
+} // namespace Thread
+} // namespace Envoy

source/common/common/posix/thread_impl.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <pthread.h>
+
+#include <functional>
+
+#include "envoy/thread/thread.h"
+
+namespace Envoy {
+namespace Thread {
+
+class ThreadIdImplPosix : public ThreadId {
+public:
+  ThreadIdImplPosix(int64_t id);
+
+  // Thread::ThreadId
+  std::string debugString() const override;
+  bool isCurrentThreadId() const override;
+
+private:
+  int64_t id_;
+};
+
+/**
+ * Wrapper for a pthread thread. We don't use std::thread because it eats exceptions and leads to
+ * unusable stack traces.
+ */
+class ThreadImplPosix : public Thread {
+public:
+  ThreadImplPosix(std::function<void()> thread_routine);
+
+  // Thread::Thread
+  void join() override;
+
+private:
+  std::function<void()> thread_routine_;
+  pthread_t thread_handle_;
+};
+
+/**
+ * Implementation of ThreadFactory
+ */
+class ThreadFactoryImplPosix : public ThreadFactory {
+public:
+  // Thread::ThreadFactory
+  ThreadPtr createThread(std::function<void()> thread_routine) override;
+  ThreadIdPtr currentThreadId() override;
+};
+
+} // namespace Thread
+} // namespace Envoy

source/common/common/stack_array.h

@@ -1,10 +1,10 @@
 #pragma once
 
-#if !defined(WIN32)
-#include <alloca.h>
+#ifdef WIN32
+#include <malloc.h>
 
 #else
-#include <malloc.h>
+#include <alloca.h>
 #endif
 
 #include <stddef.h>