Merging block events; trivially copyable block event subtypes; wasm nudge

Author: nick-thompson

js/packages/offline-renderer/__tests__/block-events.test.js

@@ -12,7 +12,7 @@ test("block events", async function () {
   });
 
   // Graph
-  core.render(...unpack(createNode("midinotein", {}, []), 2));
+  core.render(...unpack(createNode("midinoteunpack", {}, []), 2));
 
   // Ten blocks of data
   let inps = [];

js/packages/offline-renderer/elementary-wasm.cjs

@@ -21,10 +21,6 @@ struct MidiEvent {
     MidiEvent(uint8_t byte0, uint8_t byte1, uint8_t byte2)
         : message(byte0, byte1, byte2)
     {}
-
-    MidiEvent(MidiEvent const& other)
-        : message(other.message)
-    {}
 };
 
 // Type-erased event structure that can hold any event type within a certain
@@ -35,7 +31,6 @@ struct BlockEvent {
     static constexpr size_t kMaxObjectSize = 64;
     alignas(std::max_align_t) char data[kMaxObjectSize];
     std::type_index typeIndex;
-    void(*destructor)(void*) = nullptr;
 
     template <typename T>
     BlockEvent(size_t t, T&& d)
@@ -44,15 +39,9 @@ struct BlockEvent {
     {
         static_assert(sizeof(T) <= kMaxObjectSize, "Type too large for BlockEvent buffer");
         static_assert(alignof(T) <= alignof(std::max_align_t), "Type alignment too strict");
+        static_assert(std::is_trivially_copyable_v<T>, "Type must be trivially copyable");
 
         new(data) T(std::forward<T>(d));
-        destructor = [](void* ptr) { static_cast<T*>(ptr)->~T(); };
-    }
-
-    ~BlockEvent() {
-        if (destructor) {
-            destructor(data);
-        }
     }
 
     template <typename T>
@@ -72,6 +61,10 @@ struct BlockEvent {
 
         return nullptr;
     }
+
+    bool operator>(const BlockEvent& other) const {
+        return time > other.time;
+    }
 };
 
 // A buffer of realtime BlockEvent instances
@@ -103,6 +96,26 @@ struct BlockEvents {
     inline void clear() {
         storage.clear();
     }
+
+    // Sort events by time
+    inline void sort() {
+        auto size = storage.size();
+
+        for (size_t i = 1; i < size; ++i) {
+            auto key = storage[i];  // Element to be inserted
+            int j = i - 1;   // Start comparing with the element before
+
+            // Move elements of storage[0..i-1] that are greater than key
+            // one position ahead of their current position
+            while (j >= 0 && storage[j] > key) {
+                storage[j + 1] = storage[j];  // Shift element to the right
+                j--;                   // Move to the next element on the left
+            }
+
+            // Insert the key at its correct position
+            storage[j + 1] = key;
+        }
+    }
 };
 
 } // namespace elem

js/packages/web-renderer/raw/elementary-wasm.js

@@ -8,6 +8,8 @@
 #include <utility>
 
 #include "BlockEvents.h"
+#include "third-party/choc/choc/containers/choc_SmallVector.h"
+#include "third-party/choc/choc/memory/choc_ObjectPointer.h"
 #include "third-party/choc/choc/memory/choc_PoolAllocator.h"
 #include "third-party/choc/choc/platform/choc_Assert.h"
 #include "Types.h"
@@ -59,7 +61,7 @@ class BlockEventsBufferPool {
     //
     // If more than one inlet produces block events, this will provision a new
     // struct from the pool, merge the events into one, and return that.
-    BlockEvents& consume(std::vector<InletConnection> const& inlets);
+    choc::SmallVector<choc::ObjectPointer<BlockEvents>, 16> consume(std::vector<InletConnection> const& inlets);
 
     // Reset internal state
     void clear();
@@ -94,17 +96,16 @@ inline BlockEvents& BlockEventsBufferPool::produce(int32_t nodeId, std::vector<O
     return buffer;
 }
 
-inline BlockEvents& BlockEventsBufferPool::consume(std::vector<InletConnection> const& inlets)
+inline choc::SmallVector<choc::ObjectPointer<BlockEvents>, 16> BlockEventsBufferPool::consume(std::vector<InletConnection> const& inlets)
 {
     auto childIds = detail::getDistinctNodeIds(inlets);
+    auto out = choc::SmallVector<choc::ObjectPointer<BlockEvents>, 16>();
 
     // We shouldn't be trying to consume from the pool if the node has no children, instead
     // the rendering algorithm should pick the host events
     CHOC_ASSERT(childIds.size() > 0);
 
-    // If there's just one child we can just pluck its buffer from the map
-    if (childIds.size() == 1) {
-        auto childId = *childIds.begin();
+    for (auto const& childId : childIds) {
         CHOC_ASSERT(m_assignments.count(childId) > 0);
 
         auto& value = m_assignments.at(childId);
@@ -116,18 +117,10 @@ inline BlockEvents& BlockEventsBufferPool::consume(std::vector<InletConnection>
             m_assignments.erase(childId);
         }
 
-        return buffer;
+        out.emplace_back(buffer);
     }
 
-    // Else, we take a new temporary block and sum into it
-    //
-    // We can just put the buffer immediately back in the free list
-    // because this node is the only consumer of this temporary block
-    auto& buffer = getEventsBuffer();
-    m_freeList.push(buffer);
-
-    // TODO: Consume each child id and sum into `buffer` before returning
-    return buffer;
+    return out;
 }
 
 inline void BlockEventsBufferPool::clear()

runtime/elem/BlockEvents.h

@@ -152,11 +152,22 @@ namespace elem
             // for input and output events, which would get cleared at the beginning of the op
             // below.
             auto& outputEvents = m_eventsBufferPool.produce(node->getId(), outlets);
-            auto& inputEvents = m_eventsBufferPool.consume(inlets);
+            auto inputEvents = m_eventsBufferPool.consume(inlets);
 
-            renderOps.push_back([node, &inputEvents, &outputEvents, outputChannels = std::move(outputChannels), inputChannels = std::move(inputChannels)](BlockContext<FloatType> const& rootCtx) mutable {
+            renderOps.push_back([node, &outputEvents, inputEvents = std::move(inputEvents), outputChannels = std::move(outputChannels), inputChannels = std::move(inputChannels)](BlockContext<FloatType> const& rootCtx) mutable {
+                BlockEvents aggregateInputEvents;
                 outputEvents.clear();
 
+                // Aggregate
+                for (auto& evts : inputEvents) {
+                    for (auto& e : evts->storage) {
+                        aggregateInputEvents.storage.push_back(e);
+                    }
+                }
+
+                // Sort
+                aggregateInputEvents.sort();
+
                 node->process(BlockContext<FloatType> {
                     const_cast<const FloatType**>(inputChannels.data()),
                     inputChannels.size(),
@@ -165,7 +176,7 @@ namespace elem
                     rootCtx.numSamples,
                     rootCtx.userData,
                     rootCtx.active,
-                    inputEvents,
+                    aggregateInputEvents,
                     outputEvents,
                 });
             });