Add Shared Memory for incoming data.

benchmark/CMakeLists.txt

@@ -20,6 +20,7 @@ add_executable(quicr_benchmark
     time_queue.cpp
     uintvar.cpp
     hash.cpp
+    shared_memory.cpp
 )
 
 target_link_libraries(quicr_benchmark PRIVATE quicr benchmark::benchmark_main)

benchmark/shared_memory.cpp

@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Cisco Systems
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <quicr/shared_memory.h>
+#include <quicr/detail/uintvar.h>
+
+#include <benchmark/benchmark.h>
+
+static void
+SharedMemory_Construct(benchmark::State& state)
+{
+    for ([[maybe_unused]] const auto& _ : state) {
+        auto buffer = quicr::SharedMemory::Create();
+        benchmark::DoNotOptimize(buffer);
+        benchmark::ClobberMemory();
+    }
+}
+
+static void
+SharedMemory_Push(benchmark::State& state)
+{
+    auto buffer = quicr::SharedMemory::Create();
+    uint64_t value = 0;
+    auto bytes = quicr::AsBytes(value);
+
+    for ([[maybe_unused]] const auto& _ : state) {
+        buffer->Push(bytes);
+    }
+}
+
+BENCHMARK(SharedMemory_Construct);
+BENCHMARK(SharedMemory_Push);

include/quicr/shared_memory.h

@@ -0,0 +1,108 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Cisco Systems
+// SPDX-License-Identifier: BSD-2-Clause
+
+#pragma once
+
+#include "detail/span.h"
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <vector>
+
+namespace quicr {
+    template<class T, std::enable_if_t<std::is_standard_layout_v<T>, bool> = true>
+    inline Span<const uint8_t> AsBytes(const T& value)
+    {
+        return Span{ reinterpret_cast<const std::uint8_t*>(&value), sizeof(T) };
+    }
+
+    class SharedMemory
+    {
+        template<class T>
+        struct IsRange
+        {
+            static constexpr bool kValue = noexcept(std::declval<T>().begin()) && noexcept(std::declval<T>().end());
+        };
+
+        template<class It, class SpanIt>
+        class IteratorImpl
+        {
+          public:
+            constexpr IteratorImpl() noexcept = default;
+            constexpr IteratorImpl(const It& it, const It& end_it) noexcept
+              : it_(it)
+              , end_it_(end_it)
+              , span_it_(it == end_it_ ? std::nullopt : std::optional<SpanIt>{ (*it_)->begin() })
+            {
+            }
+
+            constexpr IteratorImpl(const IteratorImpl&) = default;
+
+            IteratorImpl& operator=(const IteratorImpl&) = default;
+
+            constexpr const std::uint8_t& operator*() const noexcept { return **span_it_; }
+            constexpr const std::uint8_t* operator->() const noexcept { return span_it_->operator->(); }
+
+            constexpr IteratorImpl& operator++() noexcept
+            {
+                if (++*span_it_ == (*it_)->end()) {
+                    span_it_ = ++it_ == end_it_ ? std::nullopt : std::optional<SpanIt>{ (*it_)->begin() };
+                }
+
+                return *this;
+            }
+
+            friend constexpr bool operator==(const IteratorImpl& lhs, const IteratorImpl& rhs)
+            {
+                return lhs.it_ == rhs.it_ && lhs.span_it_ == rhs.span_it_;
+            }
+
+            friend constexpr bool operator!=(const IteratorImpl& lhs, const IteratorImpl& rhs) { return !(lhs == rhs); }
+
+          private:
+            It it_;
+            It end_it_;
+            std::optional<SpanIt> span_it_;
+        };
+
+        using MemoryType = std::shared_ptr<std::vector<uint8_t>>;
+        using BufferType = std::vector<MemoryType>;
+
+        SharedMemory() = default;
+
+      public:
+        static std::shared_ptr<SharedMemory> Create() noexcept
+        {
+            return std::shared_ptr<SharedMemory>(new SharedMemory());
+        }
+
+        void Push(Span<const uint8_t> bytes)
+        {
+            auto memory = std::make_shared<std::vector<uint8_t>>();
+            memory->assign(bytes.begin(), bytes.end());
+
+            buffer_.push_back(std::move(memory));
+        }
+
+        friend SharedMemory& operator<<(SharedMemory& buffer, Span<const uint8_t> value)
+        {
+            buffer.Push(value);
+            return buffer;
+        }
+
+        // NOLINTBEGIN(readability-identifier-naming)
+        using iterator = IteratorImpl<BufferType::iterator, std::vector<uint8_t>::iterator>;
+        using const_iterator = IteratorImpl<BufferType::const_iterator, std::vector<uint8_t>::iterator>;
+
+        iterator begin() noexcept { return iterator(buffer_.begin(), buffer_.end()); }
+        iterator end() noexcept { return iterator(buffer_.end(), buffer_.end()); }
+        const_iterator begin() const noexcept { return const_iterator(buffer_.begin(), buffer_.end()); }
+        const_iterator end() const noexcept { return const_iterator(buffer_.end(), buffer_.end()); }
+        // NOLINTEND(readability-identifier-naming)
+
+      private:
+        BufferType buffer_;
+    };
+}
+

test/CMakeLists.txt

@@ -10,6 +10,7 @@ add_executable(quicr_test
     client.cpp
     tick_service.cpp
     track_namespace.cpp
+    shared_memory.cpp
 )
 target_include_directories(quicr_test PRIVATE ${PROJECT_SOURCE_DIR}/src)
 

test/shared_memory.cpp

@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Cisco Systems
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <doctest/doctest.h>
+
+#include "quicr/shared_memory.h"
+
+TEST_CASE("SharedMemory Construct")
+{
+    CHECK_NOTHROW(quicr::SharedMemory::Create());
+}
+
+TEST_CASE("SharedMemory Push")
+{
+    auto buffer = quicr::SharedMemory::Create();
+
+    uint64_t value = 0;
+    auto bytes = quicr::AsBytes(value);
+    CHECK_NOTHROW(buffer->Push(bytes));
+}
+
+TEST_CASE("SharedMemory Read")
+{
+    auto buffer = quicr::SharedMemory::Create();
+
+    uint64_t value = 0x0102030405060708;
+    auto bytes = quicr::AsBytes(value);
+    CHECK_NOTHROW(buffer->Push(bytes));
+
+    std::vector<uint8_t> v;
+    for (auto value : *buffer)
+    {
+        v.push_back(value);
+    }
+
+    CHECK_EQ(v.size(), 8);
+    CHECK_EQ(v, std::vector<uint8_t>{0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01});
+}