Added rtcheck options with disabled/enable/relaxed modes

Author: drowaudio

CMakeLists.txt

@@ -10,6 +10,8 @@ if (APPLE)
     # Uncomment to produce a universal binary
     # set(CMAKE_OSX_ARCHITECTURES arm64 x86_64)
     set(PLUGINVAL_ENABLE_RTCHECK ON)
+elseif (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    set(PLUGINVAL_ENABLE_RTCHECK ON)
 endif()
 
 # sanitizer options, from https://github.com/sudara/cmake-includes/blob/main/Sanitizers.cmake
@@ -42,19 +44,21 @@ endif ()
 set_property(GLOBAL PROPERTY USE_FOLDERS YES)
 option(JUCE_ENABLE_MODULE_SOURCE_GROUPS "Enable Module Source Groups" ON)
 
+Include(FetchContent)
+
 if(PLUGINVAL_ENABLE_RTCHECK)
-    Include(FetchContent)
     FetchContent_Declare(rtcheck
-            GIT_REPOSITORY https://github.com/Tracktion/rtcheck.git
+            GIT_REPOSITORY git@github.com:Tracktion/rtcheck.git
             GIT_TAG origin/main
             SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/rtcheck)
     FetchContent_MakeAvailable(rtcheck)
-
-#    execute_process(COMMAND cmake --build ${CMAKE_CURRENT_BINARY_DIR}/rtcheck-build)
-#    execute_process(COMMAND cmake -B ${CMAKE_CURRENT_BINARY_DIR}/rtcheck/build -S ${CMAKE_CURRENT_BINARY_DIR}/rtcheck)
-#    execute_process(COMMAND cmake --build ${CMAKE_CURRENT_BINARY_DIR}/rtcheck)
 endif()
 
+FetchContent_Declare(magic_enum
+    GIT_REPOSITORY [email protected]:Neargye/magic_enum.git)
+FetchContent_MakeAvailable(magic_enum)
+
+
 option(PLUGINVAL_FETCH_JUCE "Fetch JUCE along with pluginval" ON)
 
 if(PLUGINVAL_FETCH_JUCE)
@@ -77,7 +81,7 @@ juce_add_gui_app(pluginval
 
 juce_generate_juce_header(pluginval)
 
-target_compile_features(pluginval PRIVATE cxx_std_17)
+target_compile_features(pluginval PRIVATE cxx_std_20)
 
 set_target_properties(pluginval PROPERTIES
     C_VISIBILITY_PRESET hidden
@@ -131,7 +135,8 @@ target_link_libraries(pluginval PRIVATE
     juce::juce_audio_devices
     juce::juce_audio_processors
     juce::juce_audio_utils
-    juce::juce_recommended_warning_flags)
+    juce::juce_recommended_warning_flags
+    magic_enum)
 
 if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
     target_link_libraries(pluginval PRIVATE

Source/CommandLine.cpp

@@ -22,6 +22,7 @@
  #include <unistd.h>
 #endif
 
+#include <magic_enum/magic_enum.hpp>
 
 //==============================================================================
 static void exitWithError (const juce::String& error)
@@ -285,6 +286,7 @@ static Option possibleOptions[] =
     { "--sample-rates",         true    },
     { "--block-sizes",          true    },
     { "--vst3validator",        true    },
+    { "--rtcheck",              false   },
 };
 
 static juce::StringArray mergeEnvironmentVariables (juce::StringArray args, std::function<juce::String (const juce::String& name, const juce::String& defaultValue)> environmentVariableProvider = [] (const juce::String& name, const juce::String& defaultValue) { return juce::SystemStats::getEnvironmentVariable (name, defaultValue); })
@@ -362,6 +364,10 @@ static juce::String getHelpMessage()
          << "    Sets a timout which will stop validation with an error if no output from any" << newLine
          << "    test has happened for this number of ms." << newLine
          << "    By default this is 30s but can be set to \"-1\" (must be quoted) to never timeout." << newLine
+         << "  --rtcheck [empty, disabled, enabled or relaxed]" << newLine
+         << "    Turns on real-time saftey checks using rtcheck (macOS and Linux only)." << newLine
+         << "    relaxed mode doesn't run the checks for the first processing block as a lot of plugins" << newLine
+         << "    use this to allocate or initialise thread-locals (which can allocate)" << newLine
          << newLine
          // repeating tests
          << "  --repeat [num repeats]" << newLine
@@ -552,6 +558,8 @@ std::pair<juce::String, PluginTests::Options> parseCommandLine (const juce::Argu
     options.sampleRates         = getSampleRates (args);
     options.blockSizes          = getBlockSizes (args);
     options.vst3Validator       = getOptionValue (args, "--vst3validator", "", "Expected a path for the --vst3validator option");
+    options.realtimeCheck       = magic_enum::enum_cast<RealtimeCheck> (getOptionValue (args, "--rtcheck", "", "Expected one of [disabled, enabled, relaxed]").toString().toStdString())
+                                    .value_or (RealtimeCheck::disabled);
 
     return { fileOrID, options };
 }
@@ -622,6 +630,12 @@ juce::StringArray createCommandLine (juce::String fileOrID, PluginTests::Options
     if (options.vst3Validator != juce::File())
         args.addArray ({ "--vst3validator", options.vst3Validator.getFullPathName().quoted() });
 
+    if (auto rtCheckMode = options.realtimeCheck;
+        rtCheckMode != RealtimeCheck::disabled)
+    {
+        args.addArray ({ "--rtcheck", std::string (magic_enum::enum_name (rtCheckMode)) });
+    }
+
     args.addArray ({ "--validate", fileOrID });
 
     return args;

Source/MainComponent.cpp

@@ -13,6 +13,9 @@
  ==============================================================================*/
 
 #include "MainComponent.h"
+
+#include <magic_enum/magic_enum.hpp>
+
 #include "PluginTests.h"
 
 //==============================================================================
@@ -114,6 +117,18 @@ namespace
         return getAppPreferences().getValue ("vst3validator", juce::String());
     }
 
+    void setRealtimeCheckMode (RealtimeCheck rt)
+    {
+        getAppPreferences().setValue ("realtimeCheckMode", juce::String (std::string (magic_enum::enum_name (rt))));
+    }
+
+    RealtimeCheck getRealtimeCheckMode()
+    {
+        auto modeString = getAppPreferences().getValue ("realtimeCheckMode", juce::String());
+        return magic_enum::enum_cast<RealtimeCheck> (modeString.toStdString())
+                .value_or (RealtimeCheck::disabled);
+    }
+
     PluginTests::Options getTestOptions()
     {
         PluginTests::Options options;
@@ -127,6 +142,7 @@ namespace
         options.sampleRates = getSampleRates();
         options.blockSizes = getBlockSizes();
         options.vst3Validator = getVST3Validator();
+        options.realtimeCheck = getRealtimeCheckMode();
 
         return options;
     }
@@ -336,10 +352,25 @@ MainComponent::MainComponent (Validator& v)
                 randomise,
                 chooseOutputDir,
                 showVST3Validator,
-                showSettingsDir
+                showSettingsDir,
+                rtCheck
             };
 
             juce::PopupMenu m;
+
+            {
+                juce::PopupMenu rtCheckMenu;
+
+                for (auto currentMode = getRealtimeCheckMode();
+                     auto mode : magic_enum::enum_values<RealtimeCheck>())
+                {
+                    rtCheckMenu.addItem (getDisplayString (mode), true, mode == currentMode,
+                                         [newMode = mode] { setRealtimeCheckMode (newMode); });
+                }
+
+                m.addSubMenu ("Realtime check mode", rtCheckMenu);
+            }
+
             m.addItem (validateInProcess, TRANS("Validate in process"), true, getValidateInProcess());
             m.addItem (showRandomSeed, TRANS("Set random seed (123)").replace ("123", "0x" + juce::String::toHexString (getRandomSeed()) + "/" + juce::String (getRandomSeed())));
             m.addItem (showTimeout, TRANS("Set timeout (123ms)").replace ("123",juce::String (getTimeoutMs())));

Source/PluginTests.cpp

@@ -16,6 +16,18 @@
 #include "TestUtilities.h"
 #include <random>
 
+juce::String getDisplayString (RealtimeCheck rtc)
+{
+    if (rtc == RealtimeCheck::disabled)
+        return "Disabled (don't check for real-time safety)";
+
+    if (rtc == RealtimeCheck::enabled)
+        return "Enabled (check for real-time safety in all process calls)";
+
+    if (rtc == RealtimeCheck::relaxed)
+        return "Relaxed (check for real-time safety in all but the first process call)";
+}
+
 namespace
 {
     /** Deletes a plugin asyncronously on the message thread */

Source/PluginTests.h

@@ -16,6 +16,17 @@
 
 #include "juce_audio_processors/juce_audio_processors.h"
 
+/** Determines the type of real-time checking to perform. */
+enum class RealtimeCheck
+{
+    disabled,   ///< Doesn't check for realtime safety
+    enabled,    ///< Checks for realtime safety
+    relaxed     ///< Checks for realtime safety after the first audio callback (to allow initialisation)
+};
+
+juce::String getDisplayString (RealtimeCheck);
+
+
 //==============================================================================
 /**
     The juce::UnitTest which will create the plugins and run each of the registered tests on them.
@@ -26,20 +37,21 @@ struct PluginTests : public juce::UnitTest
     /** A set of options to use when running tests. */
     struct Options
     {
-        int strictnessLevel = 5;            /**< Max test level to run. */
-        juce::int64 randomSeed = 0;               /**< The seed to use for the tests, 0 signifies a randomly generated seed. */
-        juce::int64 timeoutMs = 30000;            /**< Timeout after which to kill the test. */
-        bool verbose = false;               /**< Whether or not to log additional information. */
-        int numRepeats = 1;                 /**< The number of times to repeat the tests. */
-        bool randomiseTestOrder = false;    /**< Whether to randomise the order of the tests in each repeat. */
-        bool withGUI = true;                /**< Whether or not avoid tests that instantiate a gui. */
-        juce::File dataFile;                      /**< juce::File which tests can use to run user provided data. */
-        juce::File outputDir;                     /**< Directory in which to write the log files for each test run. */
-        juce::String outputFilename;        /**< Filename to write logs into */
-        juce::StringArray disabledTests;          /**< List of disabled tests. */
-        std::vector<double> sampleRates;    /**< List of sample rates. */
-        std::vector<int> blockSizes;        /**< List of block sizes. */
-        juce::File vst3Validator;                 /**< juce::File to use as the VST3 validator app. */
+        int strictnessLevel = 5;                                /**< Max test level to run. */
+        juce::int64 randomSeed = 0;                             /**< The seed to use for the tests, 0 signifies a randomly generated seed. */
+        juce::int64 timeoutMs = 30000;                          /**< Timeout after which to kill the test. */
+        bool verbose = false;                                   /**< Whether or not to log additional information. */
+        int numRepeats = 1;                                     /**< The number of times to repeat the tests. */
+        bool randomiseTestOrder = false;                        /**< Whether to randomise the order of the tests in each repeat. */
+        bool withGUI = true;                                    /**< Whether or not avoid tests that instantiate a gui. */
+        juce::File dataFile;                                    /**< juce::File which tests can use to run user provided data. */
+        juce::File outputDir;                                   /**< Directory in which to write the log files for each test run. */
+        juce::String outputFilename;                            /**< Filename to write logs into */
+        juce::StringArray disabledTests;                        /**< List of disabled tests. */
+        std::vector<double> sampleRates;                        /**< List of sample rates. */
+        std::vector<int> blockSizes;                            /**< List of block sizes. */
+        juce::File vst3Validator;                               /**< juce::File to use as the VST3 validator app. */
+        RealtimeCheck realtimeCheck = RealtimeCheck::disabled;  /**< The type of real-time safety checking to perform. */
     };
 
     /** Creates a set of tests for a fileOrIdentifier. */

Source/RTCheck.h

@@ -28,6 +28,18 @@
                                           | static_cast<uint64_t>(rtc::check_flags::pthread_mutex_unlock)); \
       }
 
+    #define RTC_REALTIME_CONTEXT_IF_ENABLED(realtimeCheckMode, blockNum)                                        \
+      std::optional<rtc::realtime_context> rc;                                                                  \
+                                                                                                                \
+      if (realtimeCheckMode != RealtimeCheck::disabled)                                                         \
+      {                                                                                                         \
+          if (realtimeCheckMode != RealtimeCheck::relaxed || blockNum > 0)                                      \
+          {                                                                                                     \
+              rc.emplace();                                                                                     \
+              rtc::disable_checks_for_thread (static_cast<uint64_t>(rtc::check_flags::pthread_mutex_lock)       \
+                                              | static_cast<uint64_t>(rtc::check_flags::pthread_mutex_unlock)); \
+          }                                                                                                     \
+      }
 #else
     #define RTC_REALTIME_CONTEXT
 #endif

Source/tests/BasicTests.cpp

@@ -157,16 +157,19 @@ struct EditorWhilstProcessingTest   : public PluginTest
             auto processThread = std::async (std::launch::async,
                                              [&]
                                              {
+                                                 int blockNum = 0;
+
                                                  while (shouldProcess)
                                                  {
                                                      fillNoise (ab);
 
                                                      {
-                                                         RTC_REALTIME_CONTEXT_IF_LEVEL_10(ut.getOptions().strictnessLevel)
+                                                         RTC_REALTIME_CONTEXT_IF_ENABLED(ut.getOptions().realtimeCheck, blockNum)
                                                          instance.processBlock (ab, mb);
                                                      }
 
                                                      mb.clear();
+                                                     ++blockNum;
 
                                                      threadStartedEvent.signal();
                                                  }
@@ -241,7 +244,7 @@ struct AudioProcessingTest  : public PluginTest
                     fillNoise (ab);
 
                     {
-                      RTC_REALTIME_CONTEXT_IF_LEVEL_10(ut.getOptions().strictnessLevel)
+                      RTC_REALTIME_CONTEXT_IF_ENABLED(ut.getOptions().realtimeCheck, i)
                       instance.processBlock (ab, mb);
                     }
 
@@ -403,7 +406,7 @@ struct AutomationTest  : public PluginTest
                 if (isPluginInstrument)
                     addNoteOn (mb, noteChannel, noteNumber, juce::jmin (10, subBlockSize));
 
-                for (;;)
+                for (int blockNum = 0;; ++blockNum)
                 {
                     // Set random parameter values
                     {
@@ -430,7 +433,7 @@ struct AutomationTest  : public PluginTest
                     fillNoise (subBuffer);
 
                     {
-                        RTC_REALTIME_CONTEXT_IF_LEVEL_10(ut.getOptions().strictnessLevel)
+                        RTC_REALTIME_CONTEXT_IF_ENABLED(ut.getOptions().realtimeCheck, blockNum)
                         instance.processBlock (subBuffer, mb);
                     }
 
@@ -682,7 +685,7 @@ struct ParameterThreadSafetyTest    : public PluginTest
             fillNoise (ab);
 
             {
-                RTC_REALTIME_CONTEXT_IF_LEVEL_10(ut.getOptions().strictnessLevel)
+                RTC_REALTIME_CONTEXT_IF_ENABLED(ut.getOptions().realtimeCheck, i)
                 instance.processBlock (ab, mb);
             }
 

Source/tests/ExtremeTests.cpp

@@ -67,7 +67,7 @@ struct AllocationsInRealTimeThreadTest  : public PluginTest
                     fillNoise (ab);
 
                     {
-                        RTC_REALTIME_CONTEXT_IF_LEVEL_10(ut.getOptions().strictnessLevel)
+                        RTC_REALTIME_CONTEXT_IF_ENABLED(ut.getOptions().realtimeCheck, i)
                         ScopedAllocationDisabler sad;
                         instance.processBlock (ab, mb);
                     }