replaced {fmt} by <format> and <print>

 * requires Clang >=18 (libc++) and GCC >=14 (stdlibc++)
 * bumped boost/ut to v2.3.1 (latest as of 2023-04-02)
 * bumped vir-simd to v0.4.4 (latest as of 2025-05-10, thanks to @mattkretz)
 * fixed stricter formatting and consteval-related rule issues
 * updated docker image to Ubuntu 25.04 (valid for 9 month)
   * added gcc-15 and clang-20 dependencies
 * disabled/removed `-lto` flags due to LLVM/mold bug (not yet deployed: https://github.com/rui314/mold/releases/tag/v2.39.1)

Signed-off-by: Ralph J. Steinhagen <[email protected]>
Signed-off-by: rstein <[email protected]>
Signed-off-by: Ralph J. Steinhagen <[email protected]>

Author: RalphSteinhagen

.github/workflows/ci.yml

@@ -76,12 +76,15 @@ jobs:
           - cc: gcc-14
             cxx: g++-14
             cmake_flags: "-DADDRESS_SANITIZER=ON"
-          - cc: gcc-13
-            cxx: g++-13
-            cmake_flags: "-DADDRESS_SANITIZER=OFF"
+          - cc: gcc-15
+            cxx: g++-15
+            cmake_flags: "-DADDRESS_SANITIZER=ON"
           - cc: clang-18
             cxx: clang++-18
             cmake_flags: "-DADDRESS_SANITIZER=ON -DCMAKE_LINKER=/usr/bin/clang-18"
+          - cc: clang-20
+            cxx: clang++-20
+            cmake_flags: "-DADDRESS_SANITIZER=ON -DCMAKE_LINKER=/usr/bin/clang-20"
           - cmake_wrapper: emcmake
             cc: emcc
             cmake_flags: "-DENABLE_COVERAGE=OFF -DCMAKE_CROSSCOMPILING_EMULATOR=${SYSTEM_NODE} -DGNURADIO_PARSE_REGISTRATIONS_TOOL_CXX_COMPLILER=g++-14"
@@ -164,7 +167,7 @@ jobs:
         if: matrix.compiler.cmake_wrapper != null
         working-directory: ${{runner.workspace}}/build
         shell: bash
-        run: node --experimental-wasm-threads ./core/src/main.js
+        run: node ./core/src/main.js
 
       - name: Show final ccache stats
         run: ccache --show-stats

CMakeLists.txt

@@ -31,19 +31,6 @@ if(NOT MSVC)
 
   set(_LD_GC_SECTIONS "-Wl,--gc-sections -ffunction-sections -fdata-sections")
 
-  if(NOT EMSCRIPTEN)
-    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU"
-       AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 13
-       AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 15)
-      message(STATUS "GCC <15 detected – disabling LTO due to known IPA/modref crash issues.")
-    else()
-      set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -flto=auto -fno-fat-lto-objects")
-      set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -flto=auto -fno-fat-lto-objects")
-      set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} -flto=auto -fno-fat-lto-objects")
-      set(_LD_GC_SECTIONS "${_LD_GC_SECTIONS} -flto=auto -fno-fat-lto-objects")
-    endif()
-  endif()
-
   find_program(MOLD_BIN ld.mold)
   if(MOLD_BIN)
     set(_LD_GC_SECTIONS "${_LD_GC_SECTIONS} -fuse-ld=mold")
@@ -305,54 +292,39 @@ target_include_directories(exprtk PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/third_part
                                          "${CMAKE_CURRENT_SOURCE_DIR}/third_party/exprtk")
 if(EMSCRIPTEN)
   target_compile_options(exprtk PRIVATE -O1 -g0)
-elseif(
-  CMAKE_CXX_COMPILER_ID STREQUAL "GNU"
-  AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 13
-  AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS_EQUAL 14)
-  message(STATUS "GCC <15 detected – disabling LTO for exprtk due to known IPA/modref crash issues.")
+elseif()
   target_compile_options(exprtk PRIVATE -O1 -g0 -fvisibility=hidden)
-else()
-  target_compile_options(
-    exprtk
-    PRIVATE -O1
-            -g0
-            -flto=auto
-            -ffat-lto-objects
-            -fvisibility=hidden)
 endif()
 set_source_files_properties(third_party/exprtk.cpp PROPERTIES COMPILE_OPTIONS "-fvisibility=hidden")
 # include exprtk header-only - END
 
 include(FetchContent)
-FetchContent_Declare(
-  fmt
-  GIT_REPOSITORY https://github.com/fmtlib/fmt.git
-  GIT_TAG 10.2.1)
-
 FetchContent_Declare(
   pmt
   GIT_REPOSITORY https://github.com/gnuradio/pmt.git
   GIT_TAG e1a46cb61decb044f6ab0a58a77211beb3630340 # latest as of 2023-12-06
 )
 
+set(BOOST_UT_DISABLE_MODULE
+    ON
+    CACHE BOOL "Disable UT Module Support" FORCE)
 FetchContent_Declare(
   ut
   GIT_REPOSITORY https://github.com/boost-ext/ut.git
-  GIT_TAG v2.0.1 # latest tag as of 2023-12-18
+  GIT_TAG 53e17f25119598c6458d30351b260193096ba67e # latest tag as of 2023-04-02
 )
 
 FetchContent_Declare(
   vir-simd
   GIT_REPOSITORY https://github.com/mattkretz/vir-simd.git
-  GIT_TAG v0.4.0)
+  GIT_TAG v0.4.4)
 
 FetchContent_Declare(
   cpp-httplib
   GIT_REPOSITORY https://github.com/yhirose/cpp-httplib.git
   GIT_TAG v0.18.1)
 
 FetchContent_MakeAvailable(
-  fmt
   pmt
   ut
   vir-simd

algorithm/CMakeLists.txt

@@ -7,7 +7,6 @@ target_link_libraries(
             gnuradio-meta
             vir
             fftw
-            fmt
             magic_enum)
 
 if(ENABLE_EXAMPLES)

algorithm/include/gnuradio-4.0/algorithm/ImChart.hpp

@@ -11,7 +11,7 @@
 #include <sys/ioctl.h>
 #include <vector>
 
-#include <fmt/format.h> // TODO: remove for fmt::print until std::format and std::print is available in gcc & emscripten
+#include <format>
 #ifdef __GNUC__
 #pragma GCC diagnostic push // ignore warning of external libraries that from this lib-context we do not have any control over
 #ifndef __clang__
@@ -76,7 +76,7 @@ struct LogAxisTransform {
     template<typename T>
     [[nodiscard]] static constexpr std::size_t toScreen(T value, T axisMin, T axisMax, std::size_t screenOffset, std::size_t screenSize) {
         if (value <= 0 || axisMin <= 0 || axisMax <= axisMin) {
-            throw std::invalid_argument(fmt::format("{} not defined for non-positive value {} in [{}, {}].", gr::meta::type_name<LogAxisTransform>(), value, axisMin, axisMax));
+            throw std::invalid_argument(std::format("{} not defined for non-positive value {} in [{}, {}].", gr::meta::type_name<LogAxisTransform>(), value, axisMin, axisMax));
         }
 
         const T log_min    = std::log10(axisMin);
@@ -87,7 +87,7 @@ struct LogAxisTransform {
     template<std::floating_point T>
     [[nodiscard]] static constexpr T fromScreen(std::size_t screenCoordinate, T axisMin, T axisMax, std::size_t screenOffset, std::size_t screenSize) {
         if (axisMin <= 0UZ || axisMax <= axisMin) {
-            throw std::invalid_argument(fmt::format("{} not defined for non-positive ranges [{}, {}].", gr::meta::type_name<LogAxisTransform>(), axisMin, axisMax));
+            throw std::invalid_argument(std::format("{} not defined for non-positive ranges [{}, {}].", gr::meta::type_name<LogAxisTransform>(), axisMin, axisMax));
         }
 
         const T proportion = static_cast<T>(screenCoordinate - screenOffset) / (static_cast<T>(screenSize - screenOffset - 1UZ)); // convert screen coordinates back to a proportion of the axis
@@ -117,7 +117,7 @@ inline std::vector<std::size_t> optimalTickScreenPositions(std::size_t axisWidth
 
 } // namespace detail
 
-inline void resetView() { fmt::println("\033[2J\033[H"); }
+inline void resetView() { std::puts("\033[2J\033[H"); }
 
 /**
  * @brief compact class for ASCII charting in terminal environments, supporting custom dimensions and styles.
@@ -337,15 +337,18 @@ struct ImChart {
                 if (!datasetInvolved) {
                     continue;
                 }
-                const auto     colourStr     = Color::get(_lastColor);
-                constexpr auto defaultColour = Color::get(Color::Type::Default);
-                auto&          screen        = _screen[bRowIdx / kCellHeight][bColIdx / kCellWidth];
+                const auto colourStr = Color::get(_lastColor);
+                auto&      screen    = _screen[bRowIdx / kCellHeight][bColIdx / kCellWidth];
+                screen.clear();
+                screen += colourStr;
+
                 switch (style) {
-                case Style::Bars: screen.assign(fmt::format("{}{}{}", colourStr, kBars[dot], defaultColour)); break;
-                case Style::Marker: screen.assign(fmt::format("{}{}{}", colourStr, kMarker[_n_datasets - 1], Color::get(Color::Type::Default))); break;
+                case Style::Bars: screen += kBars[dot]; break;
+                case Style::Marker: screen += kMarker[_n_datasets - 1]; break;
                 case Style::Braille:
-                default: screen.assign(fmt::format("{}{}{}", colourStr, kBrailleCharacter[dot], Color::get(Color::Type::Default))); break;
+                default: screen += kBrailleCharacter[dot]; break;
                 }
+                screen += Color::get(Color::Type::Default);
             }
         }
         _lastColor = Color::next(_lastColor);
@@ -368,17 +371,17 @@ struct ImChart {
         _n_datasets = 0UZ;
     }
 
-    void reset() const noexcept { fmt::print("\033[0;0H"); }
+    void reset() const noexcept { std::puts("\033[0;0H"); }
 
     void printScreen() const noexcept {
         for (const auto& row : _screen) {
             for (const auto& cell : row) {
-                fmt::print("{}", cell);
+                std::fwrite(cell.data(), 1, cell.size(), stdout);
             }
-            fmt::print("\n");
+            std::fputs("\n", stdout);
         }
         // Reset terminal colour after printing
-        fmt::print("{}", Color::get(Color::Type::Default));
+        std::fputs(Color::get(Color::Type::Default), stdout);
     }
 
     void printSourceLocation() {
@@ -389,7 +392,7 @@ struct ImChart {
             std::size_t cutPosition = fullPath.find_last_of('/', fullPath.size() - maxLength);
             fullPath                = (cutPosition != std::string::npos) ? "[..]" + fullPath.substr(cutPosition) : std::move(fullPath);
         }
-        std::string srcLocation = fmt::format("{}:{}", fullPath, _location.line());
+        std::string srcLocation = std::format("{}:{}", fullPath, _location.line());
 
         // calculate starting position, clamping to screen width
         std::size_t startX = std::max(0LU, _screen_width - srcLocation.size() - 1UZ);
@@ -409,7 +412,7 @@ struct ImChart {
     [[nodiscard]] constexpr std::size_t getVerticalAxisPositionX() const noexcept {
         auto y_axis_x = std::is_same_v<horAxisTransform, LogAxisTransform> ? 0UZ : static_cast<std::size_t>((std::max(0. - axis_min_x, 0.) / (axis_max_x - axis_min_x)) * static_cast<double>(_screen_width - 1UZ));
         // adjust for axis labels
-        std::size_t y_label_width = std::max(fmt::format("{:G}", axis_min_y).size(), fmt::format("{:G}", axis_max_y).size());
+        std::size_t y_label_width = std::max(std::format("{:G}", axis_min_y).size(), std::format("{:G}", axis_max_y).size());
         return std::clamp(y_axis_x, y_label_width + 3, _screen_width); // Ensure axis positions are within screen bounds
     }
 
@@ -428,7 +431,7 @@ struct ImChart {
         }
 
         // x-axis labels and ticks
-        const std::size_t maxHorLabelWidth = std::max(fmt::format("{:+G}", axis_min_x).size(), fmt::format("{:+G}", axis_max_x).size());
+        const std::size_t maxHorLabelWidth = std::max(std::format("{:+G}", axis_min_x).size(), std::format("{:+G}", axis_max_x).size());
         for (const auto& relTickScreenPos : detail::optimalTickScreenPositions(_screen_width - horOffset, 1UZ)) {
             const std::size_t tickPos   = horOffset + relTickScreenPos;
             const double      tickValue = horAxisTransform::fromScreen(tickPos, axis_min_x, axis_max_x, horOffset, _screen_width);
@@ -437,8 +440,8 @@ struct ImChart {
             }
             _screen[horAxisPosY][tickPos] = relTickScreenPos == 0 ? "┌" : ((tickPos + 1) >= _screen_width) ? "┐" : "┬"; // NOSONAR
 
-            const std::string rawLabel = axis_min_x < 0 ? fmt::format("{:+G}", tickValue) : fmt::format("{:G}", tickValue);
-            const std::string label    = fmt::format("{:.{}}", rawLabel, maxHorLabelWidth);
+            const std::string rawLabel = axis_min_x < 0 ? std::format("{:+G}", tickValue) : std::format("{:G}", tickValue);
+            const std::string label    = std::format("{:.{}}", rawLabel, maxHorLabelWidth);
 
             // Calculate the start and end positions for the label to be centred around tickPos and clamp to ensure they're within screen bounds
             const std::size_t start_pos = std::clamp((tickPos >= label.size() / 2) ? tickPos - label.size() / 2 : 0, 0UZ, _screen_width - label.size());
@@ -458,8 +461,8 @@ struct ImChart {
             }
             _screen[tickPos][verAxisPosX] = relTickScreenPos == 0 ? "┘" : (tickPos < _screen_height) ? "┤" : (axis_max_y == 0) ? "┬" : "┐"; // NOSONAR
 
-            const std::string rawLabel = axis_min_y < 0 ? fmt::format("{:+G}", tickValue) : fmt::format("{:G}", tickValue);
-            const std::string label    = fmt::format("{:.{}}", rawLabel, verAxisPosX - 2UZ);
+            const std::string rawLabel = axis_min_y < 0 ? std::format("{:+G}", tickValue) : std::format("{:G}", tickValue);
+            const std::string label    = std::format("{:.{}}", rawLabel, verAxisPosX - 2UZ);
 
             // Calculate the starting position for the label ensuring it's within bounds.
             const std::size_t label_start_pos = (verAxisPosX > label.size() + 1UZ) ? verAxisPosX - label.size() - 1UZ : 0UZ;

algorithm/include/gnuradio-4.0/algorithm/dataset/DataSetEstimators.hpp

@@ -15,7 +15,7 @@
 #include <string_view>
 #include <vector>
 
-#include <fmt/format.h>
+#include <format>
 
 #include <gnuradio-4.0/DataSet.hpp>
 #include <gnuradio-4.0/Message.hpp>
@@ -472,7 +472,7 @@ template<MetaInfo mode = MetaInfo::Apply, DataSetLike D, typename T = typename s
         const std::uint64_t period          = 1'000'000'000;
         const std::uint64_t time            = static_cast<std::uint64_t>(gr::value(value)) * period;
         const std::uint64_t timeUncertainty = static_cast<std::uint64_t>(gr::uncertainty(value)) * period;
-        property_map        data            = property_map{{gr::tag::TRIGGER_NAME.shortKey(), fmt::format("{}_EDGE_LEVEL_{}", isRising ? "RISING" : "FALLING", threshold)}, //,                        //
+        property_map        data            = property_map{{gr::tag::TRIGGER_NAME.shortKey(), std::format("{}_EDGE_LEVEL_{}", isRising ? "RISING" : "FALLING", threshold)}, //,                        //
                               {gr::tag::TRIGGER_TIME.shortKey(), time}, {"trigger_time_error", timeUncertainty}, {gr::tag::TRIGGER_OFFSET.shortKey(), 0.f},                 //
                               {gr::tag::CONTEXT.shortKey(), context}};
         dataSet.timing_events[signalIndex].push_back({idx, std::move(data)});
@@ -495,7 +495,7 @@ std::optional<StepStartDetectionResult<T>> detectStepStart(D& ds, TValue thresho
 
     std::expected<void, gr::Error> dsCheck = gr::dataset::checkConsistency(ds, "", location);
     if (!dsCheck.has_value()) {
-        throw gr::exception(fmt::format("Invalid DataSet for step/pulse start detection: {}", dsCheck.error()), location);
+        throw gr::exception(std::format("Invalid DataSet for step/pulse start detection: {}", dsCheck.error()), location);
     }
     indexMax = detail::checkIndexRange(ds, indexMin, indexMax, signalIndex, location);
 
@@ -543,7 +543,7 @@ std::optional<StepStartDetectionResult<T>> detectStepStart(D& ds, TValue thresho
         const std::uint64_t period          = 1'000'000'000;
         const std::uint64_t time            = static_cast<std::uint64_t>(gr::value(xAxis[index])) * period;
         const std::uint64_t timeUncertainty = 0UZ;
-        property_map        data            = property_map{{gr::tag::TRIGGER_NAME.shortKey(), fmt::format("{}_EDGE_LEVEL_{}", isRising ? "RISING" : "FALLING", threshold)}, //
+        property_map        data            = property_map{{gr::tag::TRIGGER_NAME.shortKey(), std::format("{}_EDGE_LEVEL_{}", isRising ? "RISING" : "FALLING", threshold)}, //
                               {gr::tag::TRIGGER_TIME.shortKey(), time}, {"trigger_time_error", timeUncertainty}, {gr::tag::TRIGGER_OFFSET.shortKey(), 0.f},                 //
                               {gr::tag::CONTEXT.shortKey(), context}};
         ds.timing_events[signalIndex].push_back({index, std::move(data)});

algorithm/include/gnuradio-4.0/algorithm/dataset/DataSetHelper.hpp

@@ -31,7 +31,7 @@ std::size_t checkIndexRange(const DataSet<T>& ds, std::size_t minIndex = 0UZ, st
         maxIndex = maxDataSetIndex;
     }
     if (minIndex > maxIndex || minIndex >= maxDataSetIndex || maxIndex > maxDataSetIndex || signalIndex >= ds.size()) {
-        throw gr::exception(fmt::format("DataSet<{}> ({}/{}: \"{}\") indices [{}, {}] out of range [0, {}]",                                    //
+        throw gr::exception(std::format("DataSet<{}> ({}/{}: \"{}\") indices [{}, {}] out of range [0, {}]",                                    //
                                 gr::meta::type_name<T>(), signalIndex, ds.size(), signalIndex < ds.size() ? ds.signalName(signalIndex) : "???", //
                                 minIndex, maxIndex, maxDataSetIndex),
             location);
@@ -74,7 +74,7 @@ template<typename T, typename TValue = gr::meta::fundamental_base_value_type_t<T
         return static_cast<T>(vals[sampleIndex]);
     }
 
-    throw gr::exception(fmt::format("axis dimIndex {} is out of range [0, {}] and", dimIndex, dataSet.axisCount()));
+    throw gr::exception(std::format("axis dimIndex {} is out of range [0, {}] and", dimIndex, dataSet.axisCount()));
 }
 
 template<typename T>
@@ -88,7 +88,7 @@ T getDistance(const DataSet<T>& dataSet, std::size_t dimIndex, std::size_t index
         return getIndexValue(dataSet, dimIndex, indexMax, signalIndex) - getIndexValue(dataSet, dimIndex, indexMin, signalIndex);
     }
 
-    throw gr::exception(fmt::format("axis dimIndex {} is out of range [0, {}] and", dimIndex, dataSet.axisCount()));
+    throw gr::exception(std::format("axis dimIndex {} is out of range [0, {}] and", dimIndex, dataSet.axisCount()));
 }
 
 /*!
@@ -145,7 +145,7 @@ template<typename T, typename TValue = gr::meta::fundamental_base_value_type_t<T
         return yLow + t * (yHigh - yLow);
     }
 
-    throw gr::exception(fmt::format("axis dimIndex {} is out of range [0, {}] and", dimIndex, dataSet.axisCount()));
+    throw gr::exception(std::format("axis dimIndex {} is out of range [0, {}] and", dimIndex, dataSet.axisCount()));
 }
 
 template<typename T>
@@ -181,14 +181,16 @@ template<typename T>
 
 template<typename T>
 [[nodiscard]] std::expected<void, gr::Error> checkConsistency(const DataSet<T>& ds, std::string_view dsName = "unnamed", std::source_location location = std::source_location::current()) {
-    auto handleFailure = [&]<typename... Args>(std::string_view fmtStr, Args&&... args) -> std::expected<void, gr::Error> {
-        std::string combinedFmt = "Mismatch in DataSet<{}>-\"{}\": " + std::string(fmtStr) + "\n";
-        return std::unexpected(gr::Error(fmt::format(fmt::runtime_format_string<>(combinedFmt), gr::meta::type_name<T>(), dsName, std::forward<Args>(args)...), location));
+    auto handleFailure = [&](std::string_view fmtStr, auto&&... args) -> std::expected<void, gr::Error> {
+        auto formatted = std::vformat(fmtStr, std::make_format_args(args...));
+        auto fullMsg   = std::format("Mismatch in DataSet<{}>-\"{}\": {}\n", gr::meta::type_name<T>(), dsName, formatted);
+        return std::unexpected(gr::Error(std::move(fullMsg), location));
     };
 
     // check all extents are non-negative
-    if (std::ranges::any_of(ds.extents, [](std::int32_t e) { return e <= 0; })) {
-        return handleFailure("found 0 or negative extend values [{}]", fmt::join(ds.extents, ", "));
+    if (std::ranges::any_of(ds.extents, [](std::int32_t e) { return e <= 0; })) { // clang-20 bug workaround "immediate function 'operator()<const std::string &>' used before it is defined"
+        // return std::unexpected(gr::Error(std::format("Mismatch in DataSet<{}>-\"{}\": found bad extents [{}]\n", gr::meta::type_name<T>(), dsName, gr::join(ds.extents, ", ")), location));
+        return handleFailure("found 0 or negative extent values [{}]", gr::join(ds.extents));
     }
 
     // check axis-related sizes: axisCount() == extents.size() == axis_units.size() == axis_values.size()