Signal watcher functionality with test

Author: iivlev

bindings/cpp/Makefile

@@ -41,6 +41,10 @@ else
 $(error Expected value of THREADING to be single/pthread/std)
 endif
 
+ifneq "$(THREADING)" "std"
+override POSIX_SUPPORT = "0"
+endif
+
 # Required flag customizations.
 override CPPFLAGS += -Iinclude
 override CPPFLAGS += -I$(GTEST_DIR)/include
@@ -67,6 +71,10 @@ PLATFORM_HEADERS := \
 	include/wtf/platform/platform_myriad2sparc_impl.h \
 	include/wtf/platform/platform_myriad2sparc_inl.h
 
+ifeq "$(POSIX_SUPPORT)" "1"
+LIBRARY_HEADERS += include/wtf/posix_utils.h
+endif
+
 ALL_HEADERS := $(LIBRARY_HEADERS) $(PLATFORM_HEADERS)
 
 LIBRARY_SOURCES := \
@@ -81,6 +89,11 @@ TEST_SOURCES := \
 	runtime_test.cc \
 	threaded_torture_test.cc
 
+ifeq "$(POSIX_SUPPORT)" "1"
+LIBRARY_SOURCES += posix_utils.cc
+TEST_SOURCES += posix_utils_test.cc
+endif
+
 LIBRARY_OBJECTS := $(LIBRARY_SOURCES:%.cc=%.o)
 
 .PHONY: clean all test
@@ -113,7 +126,13 @@ clean:
 		$(wildcard tmp*.wtf-trace)
 
 ### TESTING.
+ifneq "$(POSIX_SUPPORT)" "1"
 test: buffer_test macros_test runtime_test threaded_torture_test
+else
+test: buffer_test macros_test runtime_test threaded_torture_test posix_utils_test
+	@echo "Running posix_utils_test"
+	./posix_utils_test
+endif
 	@echo "Running buffer_test"
 	./buffer_test
 	@echo "Running macros_test"
@@ -138,6 +157,9 @@ macros_test: macros_test.o gtest.o libwtf.a
 runtime_test: runtime_test.o gtest.o libwtf.a
 	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -o $@ $+ $(LDLIBS)
 
+posix_utils_test: posix_utils_test.o gtest.o libwtf.a
+	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -o $@ $+ $(LDLIBS)
+
 ### THREADED TORTURE TEST
 ifneq "$(THREADING)" "single"
 threaded_torture_test: threaded_torture_test.o libwtf.a

bindings/cpp/include/wtf/macros.h

@@ -154,4 +154,40 @@
 // 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>
+
+#define WTF_INIT_SIGNAL_WATCHER(filename)                               \
+    __INTERNAL_WTF_NAMESPACE::platform::condition_variable __WTF_INTERNAL_UNIQUE(cv); \
+    __INTERNAL_WTF_NAMESPACE::platform::mutex  __WTF_INTERNAL_UNIQUE(mutex); \
+    void __wtfOnSignal(int) {                                           \
+        __WTF_INTERNAL_UNIQUE(cv).notify_all();                         \
+    };                                                                  \
+    void __wtfSignalWatcherThread () {                                  \
+        __INTERNAL_WTF_NAMESPACE::platform::unique_lock<__INTERNAL_WTF_NAMESPACE::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)                                        \
+    __INTERNAL_WTF_NAMESPACE::platform::thread __WTF_INTERNAL_UNIQUE(thread) {__wtfSignalWatcherThread}; \
+    do {                                                                \
+        signal(number, __wtfOnSignal);                                  \
+        __WTF_INTERNAL_UNIQUE(thread).detach();                         \
+    } while(0)
+
+#endif
+
+
 #endif  // TRACING_FRAMEWORK_BINDINGS_CPP_INCLUDE_WTF_MACROS_H_

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

@@ -6,7 +6,9 @@
 #include <pthread.h>
 
 #include <atomic>
+#include <condition_variable>
 #include <mutex>
+#include <thread>
 
 namespace wtf {
 
@@ -17,9 +19,16 @@ 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 thread = std::thread;
+
+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

@@ -5,6 +5,7 @@
 #define TRACING_FRAMEWORK_BINDINGS_CPP_INCLUDE_WTF_PLATFORM_AUX_STD_THREADED_INL_H_
 
 #include <atomic>
+#include <condition_variable>
 #include <mutex>
 #include <thread>
 
@@ -17,9 +18,16 @@ 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 thread = std::thread;
+
+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/include/wtf/posix_utils.h

@@ -0,0 +1,12 @@
+#ifndef POSIX_UTILS_H
+#define POSIX_UTILS_H
+
+namespace wtf {
+namespace posix_utils {
+
+    void InstallSignalHandler(int number, char const* filename);
+
+} // namespace posix_utils
+} // namespace wtf
+
+#endif // POSIX_UTILS_H

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
 

bindings/cpp/posix_utils.cc

@@ -0,0 +1,50 @@
+#include <wtf/runtime.h>
+#include <signal.h>
+
+namespace {
+
+std::condition_variable gCv;
+std::mutex gMutex;
+std::string gFilename;
+
+void wtfOnSignal(int) {
+  gCv.notify_all();
+};
+
+void wtfSignalWatcherThread () {
+  std::unique_lock<std::mutex> lock { gMutex };
+  while (true) {
+    gCv.wait(lock);
+    wtf::Runtime::GetInstance()->SaveToFile(gFilename.c_str());
+  }
+}
+
+} // namespace
+
+namespace wtf {
+namespace posix_utils {
+
+void InstallSignalHandler(int number, char const* filename) {
+  if (!filename) {
+    fprintf(stderr, "%s: Error: filename can't be null\n", __PRETTY_FUNCTION__);
+    return;
+  }
+
+  static bool onlyOnce {false}:
+  if (onlyOnce) {
+    fprintf(stderr, "%s: Error: method be called only once per program execution.\n", __PRETTY_FUNCTION__);
+    return;
+  }
+
+  onlyOnce = true;
+
+  gFilename = filename;
+  std::thread thread { wtfSignalWatcherThread };
+
+  signal(number, wtfOnSignal);
+
+  thread.detach();
+}
+
+} // namespace posix_utils
+} // namespace wtf

bindings/cpp/posix_utils_test.cc

@@ -0,0 +1,47 @@
+#include <unistd.h>
+#include <sys/stat.h>
+
+#include "wtf/posix_utils.h"
+#include "wtf/macros.h"
+
+#include "gtest/gtest.h"
+
+char const* kSignalWatcherFilename = "./tmptstsignal_watcher.wtf-trace";
+
+namespace wtf {
+
+class PosixUtilsTest : public ::testing::Test {
+protected:
+  void TearDown() override {
+    wtf::Runtime::GetInstance()->DisableCurrentThread();
+    wtf::Runtime::GetInstance()->ResetForTesting();
+  }
+
+};
+
+
+TEST_F(PosixUtilsTest, SignalWatcher) {
+  unlink(kSignalWatcherFilename);
+// watch SIGALRM
+  wtf::posix_utils::InstallSignalHandler(14, kSignalWatcherFilename);
+  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;
+
+  EXPECT_TRUE(stat(kSignalWatcherFilename, &buffer) == 0);
+  EXPECT_TRUE(buffer.st_size > 0);
+}
+} //namespace wtf
+
+int main(int argc, char** argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}