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,22 @@
 
 #include "common/common/thread_annotations.h"
 
+#if 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)
+using ThreadId = int32_t;
+#else
+using ThreadId = DWORD;
+#endif
+
 class Thread {
 public:
   virtual ~Thread() {}

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",
 )
@@ -179,12 +182,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,43 @@
+#include "common/common/assert.h"
+#include "common/common/thread_impl.h"
+
+#ifdef __linux__
+#include <sys/syscall.h>
+#elif defined(__APPLE__)
+#include <pthread.h>
+#endif
+
+namespace Envoy {
+namespace Thread {
+
+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, "");
+}
+
+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,41 @@
+#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 ThreadImplPosix : public Thread {
+public:
+  ThreadImplPosix(std::function<void()> thread_routine);
+
+  /**
+   * Join on thread exit.
+   */
+  void join() override;
+
+private:
+  std::function<void()> thread_routine_;
+  pthread_t thread_handle_;
+};
+
+/**
+ * Implementation of ThreadFactory
+ */
+class ThreadFactoryImplPosix : public ThreadFactory {
+public:
+  ThreadFactoryImplPosix() {}
+
+  ThreadPtr createThread(std::function<void()> thread_routine) override {
+    return std::make_unique<ThreadImplPosix>(thread_routine);
+  }
+};
+
+} // namespace Thread
+} // namespace Envoy

source/common/common/thread.h

@@ -10,23 +10,11 @@
 namespace Envoy {
 namespace Thread {
 
-typedef int32_t ThreadId;
-
 /**
  * Get current thread id.
  */
 ThreadId currentThreadId();
 
-/**
- * Implementation of ThreadFactory
- */
-class ThreadFactoryImpl : public ThreadFactory {
-public:
-  ThreadFactoryImpl() {}
-
-  ThreadPtr createThread(std::function<void()> thread_routine) override;
-};
-
 /**
  * Implementation of BasicLockable
  */

source/common/common/win32/thread_impl.cc

@@ -0,0 +1,32 @@
+#include <process.h>
+
+#include "common/common/assert.h"
+#include "common/common/thread_impl.h"
+
+namespace Envoy {
+namespace Thread {
+
+ThreadImplWin32::ThreadImplWin32(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<ThreadImplWin32*>(arg)->thread_routine_();
+                         return 0;
+                       },
+                       this, 0, nullptr));
+  RELEASE_ASSERT(thread_handle_ != 0, "");
+}
+
+ThreadImplWin32::~ThreadImplWin32() { ::CloseHandle(thread_handle_); }
+
+void ThreadImplWin32::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,42 @@
+#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 ThreadImplWin32 : public Thread {
+public:
+  ThreadImplWin32(std::function<void()> thread_routine);
+  ~ThreadImplWin32();
+
+  /**
+   * Join on thread exit.
+   */
+  void join() override;
+
+private:
+  std::function<void()> thread_routine_;
+  HANDLE thread_handle_;
+};
+
+/**
+ * Implementation of ThreadFactory
+ */
+class ThreadFactoryImplWin32 : public ThreadFactory {
+public:
+  ThreadFactoryImplWin32() {}
+
+  ThreadPtr createThread(std::function<void()> thread_routine) override {
+    return std::make_unique<ThreadImplWin32>(thread_routine);
+  }
+};
+
+} // 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"