feat: Improved FPE monitoring

Core/CMakeLists.txt

@@ -34,25 +34,82 @@ find_program(addr2line_EXECUTABLE addr2line)
 if(APPLE)
   list(APPEND _fpe_options -D_GNU_SOURCE)
 else()
+
   if(dl_LIBRARY)
     target_link_libraries(ActsCore PUBLIC ${dl_LIBRARY})
-    if(addr2line_EXECUTABLE)
-      list(APPEND _fpe_options -DBOOST_STACKTRACE_USE_ADDR2LINE)
-      list(APPEND _fpe_options -DBOOST_STACKTRACE_ADDR2LINE_LOCATION=${addr2line_EXECUTABLE})
-    elseif(Backtrace_FOUND)
-      list(APPEND _fpe_options -DBOOST_STACKTRACE_USE_BACKTRACE)
-      target_link_libraries(ActsCore PUBLIC ${Backtrace_LIBRARY})
-    else()
-      list(APPEND _fpe_options -BOOST_STACKTRACE_USE_NOOP)
+
+    set(_backtrace_setup_complete FALSE)
+
+    if(Backtrace_FOUND)
+
+      # check if we need to link against bracktrace or not
+
+      file(WRITE
+        "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/backtrace.cpp"
+        "#include <boost/stacktrace.hpp>\n"
+        "#include <iostream>\n"
+        "int main() { std::cout << boost::stacktrace::stacktrace(); }\n" )
+
+      message(CHECK_START "Does backtrace work without linker flag")
+      try_compile(_backtrace_nolink "${CMAKE_BINARY_DIR}"
+          "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/backtrace.cpp"
+          LINK_LIBRARIES ${dl_LIBRARY}
+          COMPILE_DEFINITIONS -DBOOST_STACKTRACE_USE_BACKTRACE
+          OUTPUT_VARIABLE __OUTPUT)
+
+      if(_backtrace_nolink)
+        message(CHECK_PASS "yes")
+        set(_backtrace_setup_complete TRUE)
+      else()
+        message(CHECK_FAIL "no")
+
+        file(WRITE
+          "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/backtrace.cpp"
+          "#include <boost/stacktrace.hpp>\n"
+          "#include <iostream>\n"
+          "int main() { std::cout << boost::stacktrace::stacktrace(); }\n" )
+
+        message(CHECK_START "Does backtrace work with linker flag")
+        try_compile(_backtrace_link "${CMAKE_BINARY_DIR}"
+            "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/backtrace.cpp"
+            LINK_LIBRARIES backtrace ${dl_LIBRARY}
+            COMPILE_DEFINITIONS -DBOOST_STACKTRACE_USE_BACKTRACE
+            OUTPUT_VARIABLE __OUTPUT)
+
+        if(_backtrace_link)
+          message(CHECK_PASS "yes")
+          list(APPEND _fpe_options -DBOOST_STACKTRACE_USE_BACKTRACE)
+          target_link_libraries(ActsCore PUBLIC backtrace)
+
+          set(_backtrace_setup_complete TRUE)
+        else()
+          message(CHECK_FAIL "no")
+        endif()
+
+      endif()
     endif()
-  else()
+
+    if(NOT _backtrace_setup_complete)
+      message(CHECK_START "Is addr2line available")
+      if(addr2line_EXECUTABLE)
+        list(APPEND _fpe_options -DBOOST_STACKTRACE_USE_ADDR2LINE)
+        list(APPEND _fpe_options -DBOOST_STACKTRACE_ADDR2LINE_LOCATION=${addr2line_EXECUTABLE})
+        message(CHECK_PASS "yes")
+
+        set(_backtrace_setup_complete TRUE)
+      else()
+        message(CHECK_FAIL "no")
+      endif()
+    endif()
+
+    if(NOT _backtrace_setup_complete)
+      message(STATUS "Unable to set up stacktrace setup: use noop")
       list(APPEND _fpe_options -BOOST_STACKTRACE_USE_NOOP)
+    endif()
   endif()
 endif()
 
-message(STATUS ${_fpe_options})
-
-set_source_files_properties(src/Utilities/FpeMonitor.cpp PROPERTIES COMPILE_OPTIONS "${_fpe_options}")
+set_source_files_properties(src/Utilities/StackTrace.cpp PROPERTIES COMPILE_OPTIONS "${_fpe_options}")
 
 if(ACTS_PARAMETER_DEFINITIONS_HEADER)
   target_compile_definitions(

Core/include/Acts/Utilities/FpeMonitor.hpp

@@ -9,20 +9,89 @@
 #pragma once
 
 #include "Acts/Utilities/Helpers.hpp"
+#include "Acts/Utilities/StackTrace.hpp"
+
+#include <atomic>
+#include <csignal>
+#include <memory>
+#include <mutex>
+#include <stack>
 
 namespace Acts {
 
+enum class FpeType : uint32_t {
+  INTDIV = FPE_INTDIV,
+  INTOVF = FPE_INTOVF,
+  FLTDIV = FPE_FLTDIV,
+  FLTOVF = FPE_FLTOVF,
+  FLTUND = FPE_FLTUND,
+  FLTRES = FPE_FLTRES,
+  FLTINV = FPE_FLTINV,
+  FLTSUB = FPE_FLTSUB,
+};
+
+std::ostream &operator<<(std::ostream &os, FpeType type);
+
 class FpeMonitor {
  public:
+  struct Result {
+    struct FpeInfo {
+      std::size_t count;
+      FpeType type;
+      StackTrace st;
+    };
+
+    Result merge(const Result &with) const;
+    bool encountered(FpeType type) const;
+    unsigned int count(FpeType type) const;
+
+    const std::vector<FpeInfo> &stackTraces() const;
+    unsigned int numStackTraces() const;
+
+    void deduplicate();
+
+    void summary(std::ostream &os) const;
+
+    Result();
+
+   private:
+    std::vector<FpeInfo> m_stracktraces;
+    std::array<unsigned int, 32> m_counts{};
+
+    friend FpeMonitor;
+  };
+
   FpeMonitor();
   explicit FpeMonitor(int excepts);
   ~FpeMonitor();
 
-  static void enable(int excepts);
-  static void disable(int excepts);
+  const Result &result() const;
+  Result &result();
+
+  void rearm() const;
+
+  std::size_t stackLimit() const { return m_stackLimit; }
+  void setStackLimit(std::size_t limit) { m_stackLimit = limit; }
 
  private:
+  void enable();
+  void disable();
+
+  static void ensureSignalHandlerInstalled();
+  static void signalHandler(int signal, siginfo_t *si, void *ctx);
+
+  struct GlobalState {
+    std::atomic_bool isSignalHandlerInstalled{false};
+    std::mutex mutex{};
+  };
+
+  static std::stack<FpeMonitor *> &stack();
+  static GlobalState &globalState();
+
   int m_excepts;
+  std::size_t m_stackLimit = 1000;
+
+  Result m_result;
 };
 
 }  // namespace Acts

Core/include/Acts/Utilities/StackTrace.hpp

@@ -0,0 +1,36 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2022 CERN for the benefit of the Acts project
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#pragma once
+
+#include <cstddef>
+#include <memory>
+#include <string>
+
+namespace Acts {
+struct StackTrace {
+  StackTrace(std::size_t skip, std::size_t maxDepth);
+  StackTrace(StackTrace &&other);
+  StackTrace(const StackTrace &other);
+  StackTrace &operator=(StackTrace &&other);
+  StackTrace &operator=(const StackTrace &other);
+
+  std::pair<std::string, std::size_t> topSourceLocation() const;
+
+  ~StackTrace();
+
+  friend std::ostream &operator<<(std::ostream &os, const StackTrace &st);
+
+  friend bool operator==(const StackTrace &lhs, const StackTrace &rhs);
+
+ private:
+  struct Impl;
+  std::unique_ptr<Impl> m_impl;
+};
+
+}  // namespace Acts

Core/src/Utilities/CMakeLists.txt

@@ -6,4 +6,5 @@ target_sources(
     Logger.cpp
     SpacePointUtility.cpp
     FpeMonitor.cpp
+    StackTrace.cpp
 )