Signal watcher functionality with test

Author: iivlev

bindings/cpp/include/wtf/macros.h

@@ -154,4 +154,45 @@
 // Same as WTF_TASK_IF conditioned on the current namespace.
 #define WTF_TASK(name) WTF_TASK_IF(kWtfEnabledForNamespace, name)
 
+#if defined(WTF_SINGLE_THREADED)
+
+#include <signal.h>
+void __wtfOnSignal(int) {}
+#define WTF_INIT_SIGNAL_WATCHER(unused)
+#define WTF_WATCH_SIGNAL(number)  do { signal(number, __wtfOnSignal); } while (false)
+
+#else
+
+#include <signal.h>
+#include <thread>
+
+#define __WTF_PLATFORM __INTERNAL_WTF_NAMESPACE::platform
+
+#define WTF_INIT_SIGNAL_WATCHER(filename)                               \
+    __WTF_PLATFORM::condition_variable __WTF_INTERNAL_UNIQUE(cv);       \
+    __WTF_PLATFORM::mutex  __WTF_INTERNAL_UNIQUE(mutex);                \
+    void __wtfOnSignal(int) {                                           \
+        __WTF_INTERNAL_UNIQUE(cv).notify_all();                         \
+    };                                                                  \
+    void __wtfSignalWatcherThread () {                                  \
+        __WTF_PLATFORM::unique_lock<__WTF_PLATFORM::mutex>              \
+            lock { __WTF_INTERNAL_UNIQUE(mutex) };                      \
+        while (true) {                                                  \
+            __WTF_INTERNAL_UNIQUE(cv).wait(lock);                       \
+            __INTERNAL_WTF_NAMESPACE::Runtime::GetInstance()->SaveToFile(filename); \
+        }                                                               \
+    }
+
+#define WTF_WATCH_SIGNAL(number)                                        \
+    std::thread __WTF_INTERNAL_UNIQUE(thread) {__wtfSignalWatcherThread}; \
+    do {                                                                \
+        signal(number, __wtfOnSignal);                                  \
+        __WTF_INTERNAL_UNIQUE(thread).detach();                         \
+    } while(0)
+
+#undef __WTF_PLATFORM
+
+#endif
+
+
 #endif  // TRACING_FRAMEWORK_BINDINGS_CPP_INCLUDE_WTF_MACROS_H_

bindings/cpp/include/wtf/platform/platform_aux_pthreads_threaded_inl.h

@@ -7,6 +7,7 @@
 
 #include <atomic>
 #include <mutex>
+#include <condition_variable>
 
 namespace wtf {
 
@@ -17,9 +18,14 @@ using mutex = std::mutex;
 template <typename T>
 using lock_guard = std::lock_guard<T>;
 
+template <typename T>
+using unique_lock = std::unique_lock<T>;
+
 template <typename T>
 using atomic = std::atomic<T>;
 
+using condition_variable = std::condition_variable;
+
 // Since memory_order is an old-school enum, it needs to be imported
 // individually.
 using std::memory_order;

bindings/cpp/include/wtf/platform/platform_aux_std_threaded_inl.h

@@ -7,6 +7,7 @@
 #include <atomic>
 #include <mutex>
 #include <thread>
+#include <condition_variable>
 
 namespace wtf {
 
@@ -17,9 +18,14 @@ using mutex = std::mutex;
 template <typename T>
 using lock_guard = std::lock_guard<T>;
 
+template <typename T>
+using unique_lock = std::unique_lock<T>;
+
 template <typename T>
 using atomic = std::atomic<T>;
 
+using condition_variable = std::condition_variable;
+
 using once_flag = std::once_flag;
 template <class Callable>
 inline void call_once(once_flag& flag, Callable&& f) {

bindings/cpp/macros_test.cc

@@ -1,13 +1,19 @@
 #include "wtf/macros.h"
 
 #include <fstream>
+#include <unistd.h>
+#include <sys/stat.h>
 
 #include "gtest/gtest.h"
 
 #ifndef TMP_PREFIX
 #define TMP_PREFIX ""
 #endif
 
+char const* kSignalWatcherFilename = "./tmptstsignal_watcher.wtf-trace";
+
+WTF_INIT_SIGNAL_WATCHER(kSignalWatcherFilename);
+
 namespace wtf {
 namespace {
 
@@ -231,6 +237,31 @@ TEST_F(MacrosTest, BasicEndToEnd) {
       Runtime::GetInstance()->SaveToFile(TMP_PREFIX "tmpmacrobuf.wtf-trace"));
 }
 
+TEST_F(MacrosTest, SignalWatcher) {
+    ClearEventBuffer();
+    unlink(kSignalWatcherFilename);
+    // watch SIGALRM
+    WTF_WATCH_SIGNAL(14);
+    WTF_EVENT0("MacrosTest#SignalWatcher");
+
+    alarm(1);
+
+    const int second = 1000;
+    usleep(5000 * second);
+
+    alarm(0);
+    // allow the thread to finish it's work
+    usleep(1000 * second);
+    struct stat buffer;
+
+#if defined(WTF_SINGLE_THREADED)
+    EXPECT_FALSE(stat(kSignalWatcherFilename, &buffer) == 0);
+#else
+    EXPECT_TRUE(stat(kSignalWatcherFilename, &buffer) == 0);
+    EXPECT_TRUE(buffer.st_size > 0);
+#endif
+}
+
 }  // namespace
 }  // namespace wtf