thread: add Windows implementation

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

@@ -2,6 +2,7 @@
 
 #include "envoy/common/pure.h"
 #include "envoy/server/watchdog.h"
+#include "envoy/thread/thread.h"
 
 namespace Envoy {
 namespace Server {
@@ -28,7 +29,7 @@ class GuardDog {
    *
    * @param thread_id A numeric thread ID, like from Thread::currentThreadId()
    */
-  virtual WatchDogSharedPtr createWatchDog(int32_t thread_id) PURE;
+  virtual WatchDogSharedPtr createWatchDog(Thread::ThreadId 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 Thread::ThreadId threadId() const PURE;
   virtual MonotonicTime lastTouchTime() const PURE;
 };
 

include/envoy/thread/thread.h

@@ -7,9 +7,28 @@
 
 #include "common/common/thread_annotations.h"
 
+#ifdef __linux__
+#include <sys/syscall.h>
+#elif defined(__APPLE__)
+#include <pthread.h>
+#elif defined(WIN32)
+#include <Windows.h>
+// <windows.h> defines some macros that interfere with our code, so undef them
+#undef DELETE
+#undef GetMessage
+#endif
+
 namespace Envoy {
 namespace Thread {
 
+#if !defined(WIN32)
+typedef int32_t ThreadId;
+typedef pthread_t ThreadHandle;
+#else
+typedef DWORD ThreadId;
+typedef HANDLE ThreadHandle;
+#endif
+
 class Thread {
 public:
   virtual ~Thread() {}
@@ -18,6 +37,8 @@ class Thread {
    * Join on thread exit.
    */
   virtual void join() PURE;
+
+  virtual ThreadHandle handle() const PURE;
 };
 
 typedef std::unique_ptr<Thread> ThreadPtr;

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",
 )
@@ -182,9 +185,27 @@ envoy_cc_library(
     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,36 @@
+#include "common/common/assert.h"
+#include "common/common/thread_impl.h"
+
+namespace Envoy {
+namespace Thread {
+
+ThreadImpl::ThreadImpl(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<ThreadImpl*>(arg)->thread_routine_();
+                                  return nullptr;
+                                },
+                                this);
+  RELEASE_ASSERT(rc == 0, "");
+}
+
+void ThreadImpl::join() {
+  const int rc = pthread_join(thread_handle_, nullptr);
+  RELEASE_ASSERT(rc == 0, "");
+}
+
+ThreadId currentThreadId() {
+#ifdef __linux__
+  return syscall(SYS_gettid);
+#elif defined(__APPLE__)
+  uint64_t tid;
+  pthread_threadid_np(NULL, &tid);
+  return static_cast<int32_t>(tid);
+#else
+#error "Enable and test pthread id retrieval code for you arch in pthread/thread_impl.cc"
+#endif
+}
+
+} // namespace Thread
+} // namespace Envoy

source/common/common/posix/thread_impl.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <functional>
+
+#include "envoy/thread/thread.h"
+
+namespace Envoy {
+namespace Thread {
+
+/**
+ * Wrapper for a pthread thread. We don't use std::thread because it eats exceptions and leads to
+ * unusable stack traces.
+ */
+class ThreadImpl : public Thread {
+public:
+  ThreadImpl(std::function<void()> thread_routine);
+
+  /**
+   * Join on thread exit.
+   */
+  void join() override;
+  ThreadHandle handle() const override { return thread_handle_; }
+
+private:
+  std::function<void()> thread_routine_;
+  pthread_t thread_handle_;
+};
+
+} // namespace Thread
+} // namespace Envoy

source/common/common/thread.cc

@@ -1,61 +1,15 @@
 #include "common/common/thread.h"
 
-#ifdef __linux__
-#include <sys/syscall.h>
-#elif defined(__APPLE__)
-#include <pthread.h>
-#endif
-
 #include <functional>
 
-#include "common/common/assert.h"
-#include "common/common/macros.h"
+#include "common/common/thread_impl.h"
 
 namespace Envoy {
 namespace Thread {
 
-/**
- * Wrapper for a pthread thread. We don't use std::thread because it eats exceptions and leads to
- * unusable stack traces.
- */
-class ThreadImpl : public Thread {
-public:
-  ThreadImpl(std::function<void()> thread_routine) : thread_routine_(thread_routine) {
-    RELEASE_ASSERT(Logger::Registry::initialized(), "");
-    int rc = pthread_create(&thread_id_, nullptr,
-                            [](void* arg) -> void* {
-                              static_cast<ThreadImpl*>(arg)->thread_routine_();
-                              return nullptr;
-                            },
-                            this);
-    RELEASE_ASSERT(rc == 0, "");
-  }
-
-  void join() override {
-    int rc = pthread_join(thread_id_, nullptr);
-    RELEASE_ASSERT(rc == 0, "");
-  }
-
-private:
-  std::function<void()> thread_routine_;
-  pthread_t thread_id_;
-};
-
 ThreadPtr ThreadFactoryImpl::createThread(std::function<void()> thread_routine) {
   return std::make_unique<ThreadImpl>(thread_routine);
 }
 
-int32_t currentThreadId() {
-#ifdef __linux__
-  return syscall(SYS_gettid);
-#elif defined(__APPLE__)
-  uint64_t tid;
-  pthread_threadid_np(NULL, &tid);
-  return static_cast<int32_t>(tid);
-#else
-#error "Enable and test pthread id retrieval code for you arch in thread.cc"
-#endif
-}
-
 } // namespace Thread
 } // namespace Envoy

source/common/common/thread.h

@@ -10,8 +10,6 @@
 namespace Envoy {
 namespace Thread {
 
-typedef int32_t ThreadId;
-
 /**
  * Get current thread id.
  */

source/common/common/win32/thread_impl.cc

@@ -0,0 +1,31 @@
+#include <process.h>
+
+#include "common/common/assert.h"
+#include "common/common/thread_impl.h"
+
+namespace Envoy {
+namespace Thread {
+
+ThreadImpl::ThreadImpl(std::function<void()> thread_routine) : thread_routine_(thread_routine) {
+  RELEASE_ASSERT(Logger::Registry::initialized(), "");
+  thread_handle_ =
+      reinterpret_cast<HANDLE>(::_beginthreadex(nullptr, 0,
+                                                [](void* arg) -> unsigned int {
+                                                  static_cast<ThreadImpl*>(arg)->thread_routine_();
+                                                  return 0;
+                                                },
+                                                this, 0, nullptr));
+  RELEASE_ASSERT(thread_handle_ != 0, "");
+}
+
+ThreadImpl::~ThreadImpl() { ::CloseHandle(thread_handle_); }
+
+void ThreadImpl::join() {
+  const DWORD rc = ::WaitForSingleObject(thread_handle_, INFINITE);
+  RELEASE_ASSERT(rc == WAIT_OBJECT_0, "");
+}
+
+ThreadId currentThreadId() { return ::GetCurrentThreadId(); }
+
+} // namespace Thread
+} // namespace Envoy

source/common/common/win32/thread_impl.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <functional>
+
+#include "envoy/thread/thread.h"
+
+namespace Envoy {
+namespace Thread {
+
+/**
+ * Wrapper for a win32 thread. We don't use std::thread because it eats exceptions and leads to
+ * unusable stack traces.
+ */
+class ThreadImpl : public Thread {
+public:
+  ThreadImpl(std::function<void()> thread_routine);
+  ~ThreadImpl();
+
+  /**
+   * Join on thread exit.
+   */
+  void join() override;
+  ThreadHandle handle() const override { return thread_handle_; }
+
+private:
+  std::function<void()> thread_routine_;
+  HANDLE thread_handle_;
+};
+
+} // namespace Thread
+} // namespace Envoy

source/common/grpc/google_async_client_impl.h

@@ -10,6 +10,7 @@
 #include "envoy/tracing/http_tracer.h"
 
 #include "common/common/linked_object.h"
+#include "common/common/thread.h"
 #include "common/common/thread_annotations.h"
 #include "common/tracing/http_tracer_impl.h"
 

source/server/guarddog_impl.cc

@@ -82,7 +82,7 @@ void GuardDogImpl::threadRoutine() {
   } while (waitOrDetectStop());
 }
 
-WatchDogSharedPtr GuardDogImpl::createWatchDog(int32_t thread_id) {
+WatchDogSharedPtr GuardDogImpl::createWatchDog(Thread::ThreadId thread_id) {
   // Timer started by WatchDog will try to fire at 1/2 of the interval of the
   // minimum timeout specified. loop_interval_ is const so all shared state
   // accessed out of the locked section below is const (time_system_ has no

source/server/guarddog_impl.h

@@ -10,10 +10,10 @@
 #include "envoy/server/watchdog.h"
 #include "envoy/stats/scope.h"
 #include "envoy/stats/stats.h"
-#include "envoy/thread/thread.h"
 
 #include "common/common/lock_guard.h"
 #include "common/common/logger.h"
+#include "common/common/thread.h"
 #include "common/event/libevent.h"
 
 #include "absl/types/optional.h"
@@ -54,7 +54,7 @@ class GuardDogImpl : public GuardDog {
   }
 
   // Server::GuardDog
-  WatchDogSharedPtr createWatchDog(int32_t thread_id) override;
+  WatchDogSharedPtr createWatchDog(Thread::ThreadId thread_id) override;
   void stopWatching(WatchDogSharedPtr wd) override;
 
 private: