Allocating input buffers from arena

Author: jatinchowdhury18

modules/CMakeLists.txt

@@ -74,6 +74,7 @@ target_compile_definitions(juce_plugin_modules
         JucePlugin_VersionString="${CMAKE_PROJECT_VERSION}"
         JucePlugin_Name="${CMAKE_PROJECT_NAME}"
         JUCE_MODAL_LOOPS_PERMITTED=1
+        CHOWDSP_BUFFER_MAX_NUM_CHANNELS=2
     INTERFACE
         $<TARGET_PROPERTY:juce_plugin_modules,COMPILE_DEFINITIONS>
 )

modules/chowdsp_utils

@@ -36,8 +36,8 @@ struct CubicBezier
         using namespace chowdsp::Polynomials;
 
         /* calculate the curve point at parameter value t */
-        auto xVal = estrin<3> ({ ax, bx, cx, p1x }, t);
-        auto yVal = estrin<3> ({ ay, by, cy, p1y }, t);
+        auto xVal = estrin<3> (chowdsp::Polynomial<float, 3> { { ax, bx, cx, p1x } }, t);
+        auto yVal = estrin<3> (chowdsp::Polynomial<float, 3> { { ay, by, cy, p1y } }, t);
 
         return juce::Point { xVal, yVal };
     }

src/gui/pedalboard/cables/CubicBezier.h

@@ -47,12 +47,6 @@ void BaseProcessor::prepareProcessing (double sampleRate, int numSamples)
 {
     prepare (sampleRate, numSamples);
 
-    for (auto& b : inputBuffers)
-    {
-        b.setSize (2, numSamples);
-        b.clear();
-    }
-
     for (auto& mag : portMagnitudes)
     {
         mag.smoother.prepare ({ sampleRate, (uint32) numSamples, 1 });
@@ -64,21 +58,18 @@ void BaseProcessor::prepareProcessing (double sampleRate, int numSamples)
 void BaseProcessor::freeInternalMemory()
 {
     releaseMemory();
-    for (auto& b : inputBuffers)
-        b.setSize (0, 0);
 }
 
 void BaseProcessor::processAudioBlock (AudioBuffer<float>& buffer)
 {
-    auto updateBufferMag = [&] (const AudioBuffer<float>& inBuffer, int inputIndex)
+    auto updateBufferMag = [&] (const chowdsp::BufferView<const float>& inBuffer, int inputIndex)
     {
         const auto inBufferNumChannels = inBuffer.getNumChannels();
         const auto inBufferNumSamples = inBuffer.getNumSamples();
 
         auto rmsAvg = 0.0f;
         for (int ch = 0; ch < inBufferNumChannels; ++ch)
-            rmsAvg += Decibels::gainToDecibels (inBuffer.getRMSLevel (ch, 0, inBufferNumSamples)); // @TODO: not sure if getRMSLevel is optimized enough...
-
+            rmsAvg += Decibels::gainToDecibels (chowdsp::BufferMath::getRMSLevel (inBuffer, ch));
         rmsAvg /= (float) inBufferNumChannels;
 
         auto& portMag = portMagnitudes[(size_t) inputIndex];
@@ -97,7 +88,12 @@ void BaseProcessor::processAudioBlock (AudioBuffer<float>& buffer)
         else if (numInputs > 1)
         {
             for (int i = 0; i < numInputs; ++i)
-                updateBufferMag (getInputBuffer (i), i);
+            {
+                if (inputBuffers.getReference (i).getNumSamples() > 0)
+                    updateBufferMag (inputBuffers[i], i);
+                else if (inputsConnected.contains (i))
+                    updateBufferMag (buffer, i);
+            }
         }
     }
 
@@ -232,7 +228,6 @@ void BaseProcessor::removeConnection (const ConnectionInfo& info)
         {
             connections.remove (cIdx);
             info.endProc->inputsConnected.removeFirstMatchingValue (info.endPort);
-            info.endProc->inputBuffers[info.endPort].clear();
             info.endProc->inputConnectionChanged (info.endPort, false);
             break;
         }

src/processors/BaseProcessor.cpp

@@ -67,6 +67,19 @@ static PortTypesVector initialisePortTypes (PortMapper mapper)
 }
 } // namespace base_processor_detail
 
+struct DSPArena : chowdsp::ArenaAllocator<std::span<std::byte>>
+{
+    chowdsp::BufferView<float> alloc_buffer (int num_channels, int num_samples)
+    {
+        return chowdsp::make_temp_buffer<float> (*this, num_channels, num_samples);
+    }
+
+    chowdsp::BufferView<float> alloc_buffer (const chowdsp::BufferView<const float>& buffer)
+    {
+        return alloc_buffer (buffer.getNumChannels(), buffer.getNumSamples());
+    }
+};
+
 class BaseProcessor : private JuceProcWrapper
 {
 public:
@@ -160,8 +173,9 @@ class BaseProcessor : private JuceProcWrapper
     /** Returns the netlist circuit quantities, or nullptr if the processor has no circuit quantities. */
     auto* getNetlistCircuitQuantities() { return netlistCircuitQuantities.get(); }
 
-    const AudioBuffer<float>& getInputBuffer (int idx = 0) const { return inputBuffers.getReference (idx); }
-    AudioBuffer<float>& getInputBufferNonConst (int idx = 0) { return inputBuffers.getReference (idx); } // Most derived classes should never use this!
+    chowdsp::BufferView<float>& getInputBufferView (int idx = 0) { return inputBuffers.getReference (idx); }
+    AudioBuffer<float> getInputBuffer (int idx = 0) const { return inputBuffers.getReference (idx).toAudioBuffer(); }
+    AudioBuffer<float> getInputBufferNonConst (int idx = 0) { return inputBuffers.getReference (idx).toAudioBuffer(); } // Most derived classes should never use this!
     AudioBuffer<float>* getOutputBuffer (int idx = 0) { return outputBuffers[idx]; }
     const ConnectionInfo& getOutputConnection (int portIdx, int connectionIdx) const { return outputConnections[(size_t) portIdx].getReference (connectionIdx); }
 
@@ -283,7 +297,7 @@ class BaseProcessor : private JuceProcWrapper
     const int numOutputs {};
 
     std::vector<Array<ConnectionInfo>> outputConnections;
-    Array<AudioBuffer<float>> inputBuffers;
+    Array<chowdsp::BufferView<float>> inputBuffers;
     int numInputsReady = 0;
 
     juce::Point<float> editorPosition;

src/processors/BaseProcessor.h

@@ -71,6 +71,9 @@ void ProcessorChain::initializeProcessors()
         if (auto* proc = procs[i])
             proc->prepareProcessing (osSampleRate, osSamplesPerBlock);
     }
+
+    deallocArena (arena.get_memory_resource());
+    arena.get_memory_resource() = allocArena (getRequiredArenaSizeBytes());
 }
 
 void ProcessorChain::prepare (double sampleRate, int samplesPerBlock)
@@ -142,14 +145,18 @@ void ProcessorChain::runProcessor (BaseProcessor* proc, AudioBuffer<float>& buff
         }
         else if (nextNumProcs > 1 && nextNumInputs == 1)
         {
-            auto& copyNextBuffer = nextProc->getInputBufferNonConst();
-            copyNextBuffer.makeCopyOf (nextBuffer, true);
+            auto bufferView = arena.alloc_buffer (nextBuffer);
+            chowdsp::BufferMath::copyBufferData (nextBuffer, bufferView);
+            nextProc->getInputBufferView() = bufferView;
+            auto copyNextBuffer = bufferView.toAudioBuffer();
             runProcessor (nextProc, copyNextBuffer, outProcessed);
         }
         else
         {
-            auto& copyNextBuffer = nextProc->getInputBufferNonConst (inputIndex);
-            copyNextBuffer.makeCopyOf (nextBuffer, true);
+            auto bufferView = arena.alloc_buffer (nextBuffer);
+            chowdsp::BufferMath::copyBufferData (nextBuffer, bufferView);
+            nextProc->getInputBufferView (inputIndex) = bufferView;
+            auto copyNextBuffer = bufferView.toAudioBuffer();
 
             nextProc->incrementNumInputsReady();
             if (nextProc->getNumInputsReady() < nextProc->getNumInputConnections())
@@ -242,6 +249,8 @@ void ProcessorChain::processAudio (AudioBuffer<float>& buffer, const MidiBuffer&
         else
             jassertfalse; // output buffer is null after output was processed?
     }
+
+    arena.clear();
 }
 
 void ProcessorChain::parameterChanged (const juce::String& /*parameterID*/, float /*newValue*/)
@@ -254,3 +263,52 @@ void ProcessorChain::parameterChanged (const juce::String& /*parameterID*/, floa
                                    presetManager->setIsDirty (true); },
                            true);
 }
+
+size_t ProcessorChain::getRequiredArenaSizeBytes()
+{
+    const auto osFactor = ioProcessor.getOversamplingFactor();
+    const int osSamplesPerBlock = mySamplesPerBlock * osFactor;
+    const auto osSamplesPerBlockPadded = chowdsp::Math::round_to_next_multiple (osSamplesPerBlock, 4);
+    const auto bufferSizeBytes = osSamplesPerBlockPadded * 2 * sizeof (float);
+
+    const auto numIOBuffers = chowdsp::Math::round_to_next_multiple (connectionsCount + 1, 10);
+    const auto ioBufferBytes = numIOBuffers * bufferSizeBytes;
+
+    static constexpr size_t blockSize = 8192;
+    const auto totalNumBytes = chowdsp::Math::round_to_next_multiple (ioBufferBytes, blockSize);
+
+    return totalNumBytes;
+}
+
+bool ProcessorChain::needsNewArena (size_t requiredBytes) const
+{
+    const auto currentArenaBytes = arena.get_memory_resource().size();
+
+    // If the current arena is too small then we need a new one
+    if (currentArenaBytes < requiredBytes)
+        return true;
+
+    // If the current arena if way too big (more than 20%), then we need a new one
+    if (currentArenaBytes * 4 / 5 > requiredBytes)
+        return true;
+
+    return false;
+}
+
+std::span<std::byte> ProcessorChain::allocArena (size_t bytes)
+{
+    juce::Logger::writeToLog ("Allocating arena of size: " + juce::String { bytes });
+    return {
+        (std::byte*) chowdsp::aligned_alloc (16, bytes),
+        bytes,
+    };
+}
+
+void ProcessorChain::deallocArena (std::span<std::byte> bytes)
+{
+    if (bytes.empty())
+        return;
+
+    juce::Logger::writeToLog ("De-allocating arena of size: " + juce::String { bytes.size() });
+    chowdsp::aligned_free (bytes.data());
+}

src/processors/chain/ProcessorChain.cpp

@@ -83,5 +83,12 @@ class ProcessorChain : private AudioProcessorValueTreeState::Listener
     MidiBuffer internalMidiBuffer;
     PlayheadHelpers playheadHelper;
 
+    size_t getRequiredArenaSizeBytes();
+    bool needsNewArena (size_t requiredBytes) const;
+    static std::span<std::byte> allocArena (size_t bytes);
+    static void deallocArena (std::span<std::byte> bytes);
+    int connectionsCount {};
+    DSPArena arena {};
+
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ProcessorChain)
 };

src/processors/chain/ProcessorChain.h

@@ -71,10 +71,20 @@ class ProcChainActions
                             + String (info.startPort) + " to " + info.endProc->getName() + " port #"
                             + String (info.endPort));
 
+        chain.connectionsCount++;
+        const auto arenaBytes = chain.getRequiredArenaSizeBytes();
+        const auto needsNewArena = chain.needsNewArena (arenaBytes);
+        std::span<std::byte> arenaData {};
+        if (needsNewArena)
+            arenaData = chain.allocArena (arenaBytes);
+
         {
             SpinLock::ScopedLockType scopedProcessingLock { chain.processingLock };
             info.startProc->addConnection (ConnectionInfo (info));
+            if (needsNewArena)
+                std::swap (arenaData, chain.arena.get_memory_resource());
         }
+        chain.deallocArena (arenaData);
         chain.connectionAddedBroadcaster (info);
     }
 
@@ -84,10 +94,20 @@ class ProcChainActions
                             + String (info.startPort) + " to " + info.endProc->getName() + " port #"
                             + String (info.endPort));
 
+        chain.connectionsCount--;
+        const auto arenaBytes = chain.getRequiredArenaSizeBytes();
+        const auto needsNewArena = chain.needsNewArena (arenaBytes);
+        std::span<std::byte> arenaData {};
+        if (needsNewArena)
+            arenaData = chain.allocArena (arenaBytes);
+
         {
             SpinLock::ScopedLockType scopedProcessingLock { chain.processingLock };
             info.startProc->removeConnection (info);
+            if (needsNewArena)
+                std::swap (arenaData, chain.arena.get_memory_resource());
         }
+        chain.deallocArena (arenaData);
         chain.connectionRemovedBroadcaster (info);
     }
 

src/processors/chain/ProcessorChainActions.cpp

@@ -45,8 +45,8 @@ inline std::pair<float, float> newton_raphson (float x, float y1, float b, float
  */
 constexpr float calcQ (float gainDB)
 {
-    constexpr float adaptiveQCoeffs[] = { -7.75358366e-09f, 5.21182270e-23f, 2.70080663e-06f, -3.04753193e-20f, -3.29851878e-04f, 1.89860352e-18f, 2.59076683e-02f, -4.77485061e-17f, 3.78416236e-01f };
-    return chowdsp::Polynomials::estrin<8> (adaptiveQCoeffs, gainDB);
+    constexpr std::array<float, 9> adaptiveQCoeffs { -7.75358366e-09f, 5.21182270e-23f, 2.70080663e-06f, -3.04753193e-20f, -3.29851878e-04f, 1.89860352e-18f, 2.59076683e-02f, -4.77485061e-17f, 3.78416236e-01f };
+    return chowdsp::Polynomials::estrin<8> (chowdsp::Polynomial<float, 8> { adaptiveQCoeffs }, gainDB);
 }
 } // namespace WarpFuncs
 

src/processors/drive/Warp.cpp

@@ -115,7 +115,7 @@ inline Vec4 Asym (QuadFilterWaveshaperState* __restrict, Vec4 in, Vec4 drive)
     auto x = in * drive + Vec4 (0.5f);
     auto isPos = x >= Vec4 (0.0f);
     auto pos = xsimd::tanh (x);
-    auto neg = chowdsp::Polynomials::horner<3> ({ Vec4 (0.07f), Vec4 (0.0054f), Vec4 (1.0f), Vec4 (0.0f) }, x);
+    auto neg = chowdsp::Polynomials::horner<3> (chowdsp::Polynomial<Vec4, 3> { { 0.07f, 0.0054f, 1.0f, 0.0f } }, x);
     neg = xsimd::max (neg, Vec4 (-10.0f));
 
     return xsimd::select (isPos, pos, neg) - tanh0p5;