From 6f6e6c5b944a9d9f252a8ad6a8731a05bfbfa74f Mon Sep 17 00:00:00 2001 From: Robbert van der Helm Date: Thu, 29 Apr 2021 01:07:14 +0200 Subject: [PATCH] Reword caching to prefetching Since that makes it much clearer what we're actually doing. With old `cache_time_info` was actually caching the response, but now we're querying it before the plugin has even requested the information. --- CHANGELOG.md | 24 +++++++++++++----------- src/common/serialization/vst2.h | 10 +++++----- src/plugin/bridges/vst2.cpp | 4 ++-- src/wine-host/bridges/vst2.cpp | 6 +++--- src/wine-host/bridges/vst2.h | 6 +++--- 5 files changed, 26 insertions(+), 24 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9fa7c002..3417fc20 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,17 +10,19 @@ Versioning](https://semver.org/spec/v2.0.0.html). ### Added -- During VST2 audio processing calls, yabridge will now immediately send the - current transport information along with the audio buffers. This lets us cache - this information during the processing call, which significantly reduce the - overhead of bridging VST2 plugins by avoiding one otherwise mandatory back and - forth function call between yabridge's plugin and the Wine plugin host. This - has an even greater impact on plugins like _SWAM Cello_ that request this - information repeatedly for every sample they process. Previously yabridge had - a `cache_time_info` compatibility option to mitigate the performance hit for - those plugins, but this new caching behaviour supercedes that. -- Similarly, yabridge will also cache the current process level during audio - processing to reduce bridging overhead for plugins that use this. +- During VST2 audio processing calls, yabridge will now prefetch the current + transport information and send that to the Wine plugin host along with the + audio buffers. This lets us cache this information during the processing call, + which significantly reduces the overhead of bridging VST2 plugins by avoiding + one otherwise mandatory back and forth function call between yabridge's plugin + and the Wine plugin host. This has an even greater impact on plugins like + _SWAM Cello_ that request this information repeatedly over the course of a + single audio processing cycle. Previously yabridge had a `cache_time_info` + compatibility option to mitigate the performance hit for those plugins, but + this new caching behaviour supercedes that. +- Similarly, yabridge will also prefetch the current process level during audio + processing to reduce bridging overhead for plugins that use this, like the + _Meldaproduction_ plugins. - We now always force the CPU's flush-to-zero flag to be set when processing audio. Most plugins will already do this themselves, but plugins like _Kush Audio REDDI_ and _Expressive E Noisy_ that don't will otherwise suffer from diff --git a/src/common/serialization/vst2.h b/src/common/serialization/vst2.h index f13acb1b..4cbbad80 100644 --- a/src/common/serialization/vst2.h +++ b/src/common/serialization/vst2.h @@ -556,16 +556,16 @@ struct AudioBuffers { int sample_frames; /** - * We'll send the current transport information as part of an audio - * processing call. This lets us a void an unnecessary callback (or in some - * cases, more than one) during every processing cycle. + * We'll prefetch the current transport information as part of handling an + * audio processing call. This lets us a void an unnecessary callback (or in + * some cases, more than one) during every processing cycle. */ std::optional current_time_info; /** * Some plugins will also ask for the current process level during audio - * processing. To prevent unnecessary expensive callbacks, we'll send this - * information along with the processing call. + * processing. To prevent unnecessary expensive callbacks there, we'll + * prefetch this information as well. */ int current_process_level; diff --git a/src/plugin/bridges/vst2.cpp b/src/plugin/bridges/vst2.cpp index a2ee1e26..67e12c1d 100644 --- a/src/plugin/bridges/vst2.cpp +++ b/src/plugin/bridges/vst2.cpp @@ -568,8 +568,8 @@ void Vst2PluginBridge::do_process(T** inputs, T** outputs, int sample_frames) { current_time_info = *returned_time_info; } - // Some plugisn also ask for the current process level, so we'll cache that - // information as well + // Some plugisn also ask for the current process level, so we'll prefetch + // that information as well const int current_process_level = static_cast(host_callback_function( &plugin, audioMasterGetCurrentProcessLevel, 0, 0, nullptr, 0.0)); if (returned_time_info) { diff --git a/src/wine-host/bridges/vst2.cpp b/src/wine-host/bridges/vst2.cpp index 6044a5e8..a9bb547e 100644 --- a/src/wine-host/bridges/vst2.cpp +++ b/src/wine-host/bridges/vst2.cpp @@ -188,7 +188,7 @@ Vst2Bridge::Vst2Bridge(MainContext& main_context, [&](AudioBuffers request, std::vector& buffer) { // Since the value cannot change during this processing cycle, // we'll send the current transport information as part of the - // request so we cache it to avoid unnecessary callbacks from + // request so we prefetch it to avoid unnecessary callbacks from // the audio thread std::optional time_info_cache_guard = @@ -197,8 +197,8 @@ Vst2Bridge::Vst2Bridge(MainContext& main_context, *request.current_time_info)) : std::nullopt; - // We'll also cache the process level, since some plugins will - // ask for this during every processing cycle + // We'll also prefetch the process level, since some plugins + // will ask for this during every processing cycle decltype(process_level_cache)::Guard process_level_cache_guard = process_level_cache.set(request.current_process_level); diff --git a/src/wine-host/bridges/vst2.h b/src/wine-host/bridges/vst2.h index a9eac078..c317eb4f 100644 --- a/src/wine-host/bridges/vst2.h +++ b/src/wine-host/bridges/vst2.h @@ -114,8 +114,8 @@ class Vst2Bridge : public HostBridge { * We'll store the last transport information obtained from the host as a * result of `audioMasterGetTime()` here so we can return a pointer to it if * the request was successful. To prevent unnecessary back and forth - * communication, we'll send a copy of the current transport information to - * the plugin as part of the audio processing call. + * communication, we'll prefetch the current transport information in the + * plugin as part of the audio processing call. * * @see cached_time_info */ @@ -131,7 +131,7 @@ class Vst2Bridge : public HostBridge { /** * Some plugins will also ask for the current process level during audio - * processing, so we'll also cache that to prevent expensive callbacks. + * processing, so we'll also prefetch that to prevent expensive callbacks. */ ScopedValueCache process_level_cache;