From 60c4dca6dd9e7e905fe89ee8e11dd7a208f84060 Mon Sep 17 00:00:00 2001
From: Bernhard Manfred Gruber <bernhardmgruber@gmail.com>
Date: Sun, 7 Mar 2021 17:44:36 +0100
Subject: [PATCH] support sub arrays of dynamic size as field type

* allow dynamic field types in the record dimension
* add specializations to most of the core functions
* add llama::dynamic to signal a dynamic array member in a RecordCoord
* extend VirtualRecord to allow holding dynamic indices
* extend blobNrAndOffset to allow for additional dynamic indices
* add OffsetTable mapping
* add customization allowing to dump OffsetTable mappings
* add a few unit tests
---
 examples/bufferguard/bufferguard.cpp   |   4 +-
 include/llama/Core.hpp                 |  53 ++++
 include/llama/DumpMapping.hpp          |  20 ++
 include/llama/RecordCoord.hpp          |   3 +
 include/llama/View.hpp                 |  29 +-
 include/llama/VirtualRecord.hpp        |  95 ++++++-
 include/llama/llama.hpp                |   1 +
 include/llama/mapping/AoS.hpp          |   6 +-
 include/llama/mapping/AoSoA.hpp        |   6 +-
 include/llama/mapping/Heatmap.hpp      |   4 +-
 include/llama/mapping/OffsetTable.hpp  | 354 +++++++++++++++++++++++++
 include/llama/mapping/One.hpp          |   5 +-
 include/llama/mapping/SoA.hpp          |   6 +-
 include/llama/mapping/Split.hpp        |  19 +-
 include/llama/mapping/Trace.hpp        |   5 +-
 include/llama/mapping/tree/Mapping.hpp |   5 +-
 tests/computedprop.cpp                 |  15 +-
 tests/core.cpp                         |  30 ++-
 tests/recorddimension.cpp              | 214 +++++++++++++++
 19 files changed, 822 insertions(+), 52 deletions(-)
 create mode 100644 include/llama/mapping/OffsetTable.hpp

diff --git a/examples/bufferguard/bufferguard.cpp b/examples/bufferguard/bufferguard.cpp
index ebc10971ef..d80ff7172e 100644
--- a/examples/bufferguard/bufferguard.cpp
+++ b/examples/bufferguard/bufferguard.cpp
@@ -69,8 +69,8 @@ struct GuardMapping2D
         std::abort();
     }
 
-    template <std::size_t... RecordCoords>
-    constexpr auto blobNrAndOffset(ArrayDims coord) const -> llama::NrAndOffset
+    template <std::size_t... RecordCoords, std::size_t N = 0>
+    constexpr auto blobNrAndOffset(ArrayDims coord, llama::Array<std::size_t, N> = {}) const -> llama::NrAndOffset
     {
         // [0][0] is at left top
         const auto [row, col] = coord;
diff --git a/include/llama/Core.hpp b/include/llama/Core.hpp
index f7f14c0ff3..1fa5d0ecc9 100644
--- a/include/llama/Core.hpp
+++ b/include/llama/Core.hpp
@@ -58,6 +58,15 @@ namespace llama
     inline constexpr bool isAllowedFieldType
         = std::is_trivially_constructible_v<T>&& std::is_trivially_destructible_v<T>;
 
+    template <typename... Fields>
+    inline constexpr bool isAllowedFieldType<Record<Fields...>> = true;
+
+    template <typename T, std::size_t N>
+    inline constexpr bool isAllowedFieldType<T[N]> = isAllowedFieldType<T>;
+
+    template <typename T>
+    inline constexpr bool isAllowedFieldType<T[]> = isAllowedFieldType<T>;
+
     /// Record dimension tree node which may either be a leaf or refer to a child tree presented as another \ref
     /// Record.
     /// \tparam Tag Name of the node. May be any type (struct, class).
@@ -134,6 +143,14 @@ namespace llama
                 mp_push_front<typename GetTagsImpl<ChildTag, ChildType, RecordCoord<Coords...>>::type, CurrTag>;
         };
 
+        template <typename CurrTag, typename ChildType, std::size_t... Coords>
+        struct GetTagsImpl<CurrTag, ChildType[], RecordCoord<dynamic, Coords...>>
+        {
+            using ChildTag = RecordCoord<dynamic>;
+            using type = boost::mp11::
+                mp_push_front<typename GetTagsImpl<ChildTag, ChildType, RecordCoord<Coords...>>::type, CurrTag>;
+        };
+
         template <typename CurrTag, typename T>
         struct GetTagsImpl<CurrTag, T, RecordCoord<>>
         {
@@ -212,6 +229,16 @@ namespace llama
                 typename GetCoordFromTagsImpl<ChildType, RecordCoord<ResultCoords..., FirstTag::front>, Tags...>::type;
         };
 
+        template <typename ChildType, std::size_t... ResultCoords, typename FirstTag, typename... Tags>
+        struct GetCoordFromTagsImpl<ChildType[], RecordCoord<ResultCoords...>, FirstTag, Tags...>
+        {
+            static_assert(
+                std::is_same_v<FirstTag, RecordCoord<dynamic>>,
+                "Please use a RecordCoord<dynamic> to index into dynamic arrays");
+            using type =
+                typename GetCoordFromTagsImpl<ChildType, RecordCoord<ResultCoords..., FirstTag::front>, Tags...>::type;
+        };
+
         template <typename RecordDim, typename RecordCoord>
         struct GetCoordFromTagsImpl<RecordDim, RecordCoord>
         {
@@ -244,6 +271,13 @@ namespace llama
             using type = typename GetTypeImpl<ChildType, RecordCoord<TailCoords...>>::type;
         };
 
+        template <typename ChildType, std::size_t HeadCoord, std::size_t... TailCoords>
+        struct GetTypeImpl<ChildType[], RecordCoord<HeadCoord, TailCoords...>>
+        {
+            static_assert(HeadCoord == dynamic, "Record coord at a dynamic array must be llama::dynamic");
+            using type = typename GetTypeImpl<ChildType, RecordCoord<TailCoords...>>::type;
+        };
+
         template <typename T>
         struct GetTypeImpl<T, RecordCoord<>>
         {
@@ -309,6 +343,12 @@ namespace llama
             }
             using type = decltype(help(std::make_index_sequence<N>{}));
         };
+
+        template <typename Child, std::size_t... RCs>
+        struct LeafRecordCoordsImpl<Child[], RecordCoord<RCs...>>
+        {
+            using type = typename LeafRecordCoordsImpl<Child, RecordCoord<RCs..., dynamic>>::type;
+        };
     } // namespace internal
 
     /// Returns a flat type list containing all record coordinates to all leaves of the given record dimension.
@@ -553,5 +593,18 @@ namespace llama
         struct is_bounded_array<T[N]> : std::true_type
         {
         };
+
+        template <class T>
+        struct is_unbounded_array : std::false_type
+        {
+        };
+
+        template <class T>
+        struct is_unbounded_array<T[]> : std::true_type
+        {
+        };
+
+        template <typename T>
+        inline constexpr bool is_unbounded_array_v = is_unbounded_array<T>::value;
     } // namespace internal
 } // namespace llama
diff --git a/include/llama/DumpMapping.hpp b/include/llama/DumpMapping.hpp
index a4b3561481..e430405918 100644
--- a/include/llama/DumpMapping.hpp
+++ b/include/llama/DumpMapping.hpp
@@ -4,6 +4,7 @@
 
 #include "ArrayDimsIndexRange.hpp"
 #include "Core.hpp"
+#include "mapping/OffsetTable.hpp"
 
 #include <boost/functional/hash.hpp>
 #include <fmt/format.h>
@@ -138,6 +139,25 @@ namespace llama
             return infos;
         }
 
+        template <typename ArrayDims, typename RecordDim, typename SubMappings>
+        auto boxesFromMapping(const mapping::OffsetTable<ArrayDims, RecordDim, SubMappings>& mapping)
+            -> std::vector<FieldBox<ArrayDims::rank>>
+        {
+            std::size_t previousBlobs = 0;
+            std::vector<FieldBox<ArrayDims::rank>> infos;
+            boost::mp11::mp_for_each<boost::mp11::mp_iota<boost::mp11::mp_size<decltype(mapping.subMappings)>>>(
+                [&](auto ic)
+                {
+                    const auto& subMapping = get<decltype(ic)::value>(mapping.subMappings);
+                    auto subBoxes = boxesFromMapping(subMapping);
+                    for (auto& box : subBoxes)
+                        box.nrAndOffset.nr += previousBlobs;
+                    infos.insert(infos.end(), subBoxes.begin(), subBoxes.end());
+                    previousBlobs += std::decay_t<decltype(subMapping)>::blobCount;
+                });
+            return infos;
+        }
+
         template <std::size_t Dim>
         auto breakBoxes(std::vector<FieldBox<Dim>> boxes, std::size_t wrapByteCount) -> std::vector<FieldBox<Dim>>
         {
diff --git a/include/llama/RecordCoord.hpp b/include/llama/RecordCoord.hpp
index 635b7a7aee..b4a7cd0511 100644
--- a/include/llama/RecordCoord.hpp
+++ b/include/llama/RecordCoord.hpp
@@ -5,10 +5,13 @@
 
 #include <array>
 #include <boost/mp11.hpp>
+#include <limits>
 #include <type_traits>
 
 namespace llama
 {
+    inline constexpr auto dynamic = std::numeric_limits<std::size_t>::max();
+
     /// Represents a coordinate for a record inside the record dimension tree.
     /// \tparam Coords... the compile time coordinate.
     template <std::size_t... Coords>
diff --git a/include/llama/View.hpp b/include/llama/View.hpp
index 1f2213dc49..ac145c917f 100644
--- a/include/llama/View.hpp
+++ b/include/llama/View.hpp
@@ -265,12 +265,12 @@ namespace llama
             if constexpr (isRecord<RecordDim> || internal::is_bounded_array<RecordDim>::value)
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return VirtualRecordTypeConst{arrayDims, *this};
+                return VirtualRecordTypeConst{*this, arrayDims};
             }
             else
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return accessor(arrayDims, RecordCoord<>{});
+                return accessor(arrayDims, Array<size_t, 0>{}, RecordCoord<>{});
             }
         }
 
@@ -279,12 +279,12 @@ namespace llama
             if constexpr (isRecord<RecordDim> || internal::is_bounded_array<RecordDim>::value)
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return VirtualRecordType{arrayDims, *this};
+                return VirtualRecordType{*this, arrayDims};
             }
             else
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return accessor(arrayDims, RecordCoord<>{});
+                return accessor(arrayDims, Array<size_t, 0>{}, RecordCoord<>{});
             }
         }
 
@@ -375,29 +375,34 @@ namespace llama
         friend struct VirtualRecord;
 
         LLAMA_SUPPRESS_HOST_DEVICE_WARNING
-        template <std::size_t... Coords>
-        LLAMA_FN_HOST_ACC_INLINE auto accessor(ArrayDims arrayDims, RecordCoord<Coords...> dc = {}) const
-            -> decltype(auto)
+        template <std::size_t N, std::size_t... Coords>
+        LLAMA_FN_HOST_ACC_INLINE auto accessor(
+            ArrayDims arrayDims,
+            Array<size_t, N> dynamicArrayExtents,
+            RecordCoord<Coords...> dc = {}) const -> decltype(auto)
         {
             if constexpr (isComputed<Mapping, RecordCoord<Coords...>>)
                 return mapping.compute(arrayDims, dc, storageBlobs);
             else
             {
-                const auto [nr, offset] = mapping.template blobNrAndOffset<Coords...>(arrayDims);
+                const auto [nr, offset] = mapping.template blobNrAndOffset<Coords...>(arrayDims, dynamicArrayExtents);
                 using Type = GetType<RecordDim, RecordCoord<Coords...>>;
                 return reinterpret_cast<const Type&>(storageBlobs[nr][offset]);
             }
         }
 
         LLAMA_SUPPRESS_HOST_DEVICE_WARNING
-        template <std::size_t... Coords>
-        LLAMA_FN_HOST_ACC_INLINE auto accessor(ArrayDims arrayDims, RecordCoord<Coords...> dc = {}) -> decltype(auto)
+        template <std::size_t N, std::size_t... Coords>
+        LLAMA_FN_HOST_ACC_INLINE auto accessor(
+            ArrayDims arrayDims,
+            Array<size_t, N> dynamicArrayExtents,
+            RecordCoord<Coords...> dc = {}) -> decltype(auto)
         {
             if constexpr (isComputed<Mapping, RecordCoord<Coords...>>)
-                return mapping.compute(arrayDims, dc, storageBlobs);
+                return mapping.compute(arrayDims, dynamicArrayExtents, dc, storageBlobs);
             else
             {
-                const auto [nr, offset] = mapping.template blobNrAndOffset<Coords...>(arrayDims);
+                const auto [nr, offset] = mapping.template blobNrAndOffset<Coords...>(arrayDims, dynamicArrayExtents);
                 using Type = GetType<RecordDim, RecordCoord<Coords...>>;
                 return reinterpret_cast<Type&>(storageBlobs[nr][offset]);
             }
diff --git a/include/llama/VirtualRecord.hpp b/include/llama/VirtualRecord.hpp
index 2cb030cea7..97698944af 100644
--- a/include/llama/VirtualRecord.hpp
+++ b/include/llama/VirtualRecord.hpp
@@ -309,6 +309,21 @@ namespace llama
         template <typename T, template <typename...> typename Tuple, typename... Args>
         constexpr inline auto
             isDirectListInitializableFromTuple<T, Tuple<Args...>> = isDirectListInitializable<T, Args...>;
+
+        template <typename RecordDim, typename RecordCoord>
+        constexpr inline auto unboundArraysUntil = []() constexpr
+        {
+            std::size_t count = 0;
+            boost::mp11::mp_for_each<boost::mp11::mp_iota_c<RecordCoord::size>>(
+                [&](auto i) constexpr
+                {
+                    using RC = RecordCoordFromList<boost::mp11::mp_take_c<typename RecordCoord::List, i>>;
+                    using TypeAtRC = GetType<RecordDim, RC>;
+                    count += static_cast<std::size_t>(internal::is_unbounded_array_v<TypeAtRC>);
+                });
+            return count;
+        }
+        ();
     } // namespace internal
 
     /// Virtual record type returned by \ref View after resolving an array dimensions coordinate or partially resolving
@@ -324,9 +339,11 @@ namespace llama
     private:
         using ArrayDims = typename View::Mapping::ArrayDims;
         using RecordDim = typename View::Mapping::RecordDim;
+        using DynamicArrayExtentsArray = Array<std::size_t, internal::unboundArraysUntil<RecordDim, BoundRecordCoord>>;
 
-        [[no_unique_address]] const ArrayDims arrayDimsCoord;
         std::conditional_t<OwnView, View, View&> view;
+        [[no_unique_address]] const ArrayDims arrayDimsCoord;
+        [[no_unique_address]] const DynamicArrayExtentsArray dynamicArrayExtents;
 
     public:
         /// Subtree of the record dimension of View starting at BoundRecordCoord. If BoundRecordCoord is `RecordCoord<>`
@@ -337,15 +354,20 @@ namespace llama
         LLAMA_FN_HOST_ACC_INLINE VirtualRecord()
             /* requires(OwnView) */
             : arrayDimsCoord({})
+            , dynamicArrayExtents({})
             , view{allocViewStack<0, RecordDim>()}
         {
             static_assert(OwnView, "The default constructor of VirtualRecord is only available if it owns the view.");
         }
 
         LLAMA_FN_HOST_ACC_INLINE
-        VirtualRecord(ArrayDims arrayDimsCoord, std::conditional_t<OwnView, View&&, View&> view)
-            : arrayDimsCoord(arrayDimsCoord)
-            , view{static_cast<decltype(view)>(view)}
+        VirtualRecord(
+            std::conditional_t<OwnView, View&&, View&> view,
+            ArrayDims arrayDimsCoord,
+            DynamicArrayExtentsArray dynamicArrayExtents = {})
+            : view{static_cast<decltype(view)>(view)}
+            , arrayDimsCoord(arrayDimsCoord)
+            , dynamicArrayExtents{dynamicArrayExtents}
         {
         }
 
@@ -388,15 +410,21 @@ namespace llama
         {
             using AbsolutCoord = Cat<BoundRecordCoord, RecordCoord<Coord...>>;
             using AccessedType = GetType<RecordDim, AbsolutCoord>;
-            if constexpr (isRecord<AccessedType> || internal::is_bounded_array<AccessedType>::value)
+            if constexpr (
+                isRecord<AccessedType> || internal::is_bounded_array<AccessedType>::value
+                || internal::is_unbounded_array_v<AccessedType>)
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return VirtualRecord<const View, AbsolutCoord>{arrayDimsCoord, this->view};
+                return VirtualRecord<const View, AbsolutCoord>{
+                    this->view,
+                    arrayDimsCoord,
+                    dynamicArrayExtents,
+                };
             }
             else
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return this->view.accessor(arrayDimsCoord, AbsolutCoord{});
+                return this->view.accessor(arrayDimsCoord, dynamicArrayExtents, AbsolutCoord{});
             }
         }
 
@@ -406,22 +434,24 @@ namespace llama
         {
             using AbsolutCoord = Cat<BoundRecordCoord, RecordCoord<Coord...>>;
             using AccessedType = GetType<RecordDim, AbsolutCoord>;
-            if constexpr (isRecord<AccessedType> || internal::is_bounded_array<AccessedType>::value)
+            if constexpr (
+                isRecord<AccessedType> || internal::is_bounded_array<AccessedType>::value
+                || internal::is_unbounded_array_v<AccessedType>)
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return VirtualRecord<View, AbsolutCoord>{arrayDimsCoord, this->view};
+                return VirtualRecord<View, AbsolutCoord>{this->view, arrayDimsCoord, dynamicArrayExtents};
             }
             else
             {
                 LLAMA_FORCE_INLINE_RECURSIVE
-                return this->view.accessor(arrayDimsCoord, AbsolutCoord{});
+                return this->view.accessor(arrayDimsCoord, dynamicArrayExtents, AbsolutCoord{});
             }
         }
 
         /// Access a record in the record dimension underneath the current virtual record using a series of tags. If the
         /// access resolves to a leaf, a reference to a variable inside the \ref View storage is returned, otherwise
         /// another virtual record.
-        template <typename... Tags>
+        template <typename... Tags, std::enable_if_t<!std::disjunction_v<std::is_integral<Tags>...>, bool> = true>
         LLAMA_FN_HOST_ACC_INLINE auto operator()(Tags...) const -> decltype(auto)
         {
             using RecordCoord = GetCoordFromTagsRelative<RecordDim, BoundRecordCoord, Tags...>;
@@ -431,7 +461,7 @@ namespace llama
         }
 
         // FIXME(bgruber): remove redundancy
-        template <typename... Tags>
+        template <typename... Tags, std::enable_if_t<!std::disjunction_v<std::is_integral<Tags>...>, bool> = true>
         LLAMA_FN_HOST_ACC_INLINE auto operator()(Tags...) -> decltype(auto)
         {
             using RecordCoord = GetCoordFromTagsRelative<RecordDim, BoundRecordCoord, Tags...>;
@@ -440,6 +470,47 @@ namespace llama
             return operator()(RecordCoord{});
         }
 
+        template <
+            typename ADD = AccessibleRecordDim,
+            std::enable_if_t<internal::is_unbounded_array_v<ADD>, bool> = true>
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(std::size_t i) const -> decltype(auto)
+        {
+            using AbsolutCoord = Cat<BoundRecordCoord, RecordCoord<dynamic>>;
+            using ResolvedType = GetType<RecordDim, AbsolutCoord>;
+            auto newDynamicArrayExtents = push_back(dynamicArrayExtents, i);
+            if constexpr (isRecord<ResolvedType> || internal::is_unbounded_array_v<ResolvedType>)
+            {
+                LLAMA_FORCE_INLINE_RECURSIVE
+                return VirtualRecord<const View, AbsolutCoord>{this->view, arrayDimsCoord, newDynamicArrayExtents};
+            }
+            else
+            {
+                LLAMA_FORCE_INLINE_RECURSIVE
+                return this->view.accessor(arrayDimsCoord, newDynamicArrayExtents, AbsolutCoord{});
+            }
+        }
+
+        // FIXME(bgruber): remove redundancy
+        template <
+            typename ADD = AccessibleRecordDim,
+            std::enable_if_t<internal::is_unbounded_array_v<ADD>, bool> = true>
+        LLAMA_FN_HOST_ACC_INLINE auto operator()(std::size_t i) -> decltype(auto)
+        {
+            using AbsolutCoord = Cat<BoundRecordCoord, RecordCoord<dynamic>>;
+            using ResolvedType = GetType<RecordDim, AbsolutCoord>;
+            auto newDynamicArrayExtents = push_back(dynamicArrayExtents, i);
+            if constexpr (isRecord<ResolvedType> || internal::is_unbounded_array_v<ResolvedType>)
+            {
+                LLAMA_FORCE_INLINE_RECURSIVE
+                return VirtualRecord<View, AbsolutCoord>{this->view, arrayDimsCoord, newDynamicArrayExtents};
+            }
+            else
+            {
+                LLAMA_FORCE_INLINE_RECURSIVE
+                return this->view.accessor(arrayDimsCoord, newDynamicArrayExtents, AbsolutCoord{});
+            }
+        }
+
         // we need this one to disable the compiler generated copy assignment
         LLAMA_FN_HOST_ACC_INLINE auto operator=(const VirtualRecord& other) -> VirtualRecord&
         {
diff --git a/include/llama/llama.hpp b/include/llama/llama.hpp
index 600122ff8c..7e7ea63630 100644
--- a/include/llama/llama.hpp
+++ b/include/llama/llama.hpp
@@ -43,6 +43,7 @@
 #include "mapping/AoS.hpp"
 #include "mapping/AoSoA.hpp"
 #include "mapping/Heatmap.hpp"
+#include "mapping/OffsetTable.hpp"
 #include "mapping/One.hpp"
 #include "mapping/SoA.hpp"
 #include "mapping/Split.hpp"
diff --git a/include/llama/mapping/AoS.hpp b/include/llama/mapping/AoS.hpp
index 0ee4bc69d4..ae2826fa6f 100644
--- a/include/llama/mapping/AoS.hpp
+++ b/include/llama/mapping/AoS.hpp
@@ -45,8 +45,10 @@ namespace llama::mapping
                 * flatSizeOf<typename Flattener::FlatRecordDim, AlignAndPad>;
         }
 
-        template <std::size_t... RecordCoords>
-        LLAMA_FN_HOST_ACC_INLINE constexpr auto blobNrAndOffset(ArrayDims coord) const -> NrAndOffset
+        template <std::size_t... RecordCoords, std::size_t N = 0>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto blobNrAndOffset(
+            ArrayDims coord,
+            Array<std::size_t, N> dynamicArrayExtents = {}) const -> NrAndOffset
         {
             constexpr std::size_t flatIndex =
 #ifdef __NVCC__
diff --git a/include/llama/mapping/AoSoA.hpp b/include/llama/mapping/AoSoA.hpp
index d016fab549..529112e0c2 100644
--- a/include/llama/mapping/AoSoA.hpp
+++ b/include/llama/mapping/AoSoA.hpp
@@ -56,8 +56,10 @@ namespace llama::mapping
             return LinearizeArrayDimsFunctor{}.size(arrayDimsSize) * sizeOf<RecordDim>;
         }
 
-        template <std::size_t... RecordCoords>
-        LLAMA_FN_HOST_ACC_INLINE constexpr auto blobNrAndOffset(ArrayDims coord) const -> NrAndOffset
+        template <std::size_t... RecordCoords, std::size_t N = 0>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto blobNrAndOffset(
+            ArrayDims coord,
+            Array<std::size_t, N> dynamicArrayExtents = {}) const -> NrAndOffset
         {
             const auto flatArrayIndex = LinearizeArrayDimsFunctor{}(coord, arrayDimsSize);
             const auto blockIndex = flatArrayIndex / Lanes;
diff --git a/include/llama/mapping/Heatmap.hpp b/include/llama/mapping/Heatmap.hpp
index 34564dca48..92f016a0cc 100644
--- a/include/llama/mapping/Heatmap.hpp
+++ b/include/llama/mapping/Heatmap.hpp
@@ -44,8 +44,8 @@ namespace llama::mapping
             return mapping.blobSize(i);
         }
 
-        template <std::size_t... RecordCoords>
-        LLAMA_FN_HOST_ACC_INLINE auto blobNrAndOffset(ArrayDims coord) const -> NrAndOffset
+        template <std::size_t... RecordCoords, std::size_t N = 0>
+        LLAMA_FN_HOST_ACC_INLINE auto blobNrAndOffset(ArrayDims coord, Array<std::size_t, N> = {}) const -> NrAndOffset
         {
             const auto nao = mapping.template blobNrAndOffset<RecordCoords...>(coord);
             for (auto i = 0; i < sizeof(GetType<RecordDim, RecordCoord<RecordCoords...>>); i++)
diff --git a/include/llama/mapping/OffsetTable.hpp b/include/llama/mapping/OffsetTable.hpp
new file mode 100644
index 0000000000..dda80859d0
--- /dev/null
+++ b/include/llama/mapping/OffsetTable.hpp
@@ -0,0 +1,354 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "../Tuple.hpp"
+#include "AoS.hpp"
+#include "Common.hpp"
+
+namespace llama
+{
+    using EndOffsetType = std::size_t;
+    using SizeType = std::size_t;
+
+    template <typename Tag>
+    struct EndOffset
+    {
+    };
+    template <typename Tag>
+    struct Size
+    {
+    };
+} // namespace llama
+
+namespace llama::mapping
+{
+    namespace internal
+    {
+        using namespace boost::mp11;
+
+        template <typename T>
+        inline constexpr bool isEndOffsetField = false;
+
+        template <typename Tag>
+        inline constexpr bool isEndOffsetField<EndOffset<Tag>> = true;
+
+        template <typename T>
+        inline constexpr bool isSizeField = false;
+
+        template <typename Tag>
+        inline constexpr bool isSizeField<Size<Tag>> = true;
+
+        template <typename Field>
+        struct AddOffsetAndSizeFieldsImpl
+        {
+            using type = Record<Field>;
+        };
+
+        template <typename Tag, typename Type>
+        struct AddOffsetAndSizeFieldsImpl<Field<Tag, Type[]>>
+        {
+            using type = Record<Field<Tag, Type[]>, Field<EndOffset<Tag>, EndOffsetType>, Field<Size<Tag>, SizeType>>;
+        };
+
+        template <typename Field>
+        using AddOffsetAndSizeFields = typename AddOffsetAndSizeFieldsImpl<Field>::type;
+
+        template <typename T, typename RecordCoord>
+        struct ReplaceDynamicSubarrays
+        {
+            using Replaced = T;
+            using SubRecordDims = mp_list<>;
+            using SplitCoords = mp_list<>;
+            using Augmented = T;
+        };
+
+        template <typename T, std::size_t... RC>
+        struct ReplaceDynamicSubarrays<T[], RecordCoord<RC...>>
+        {
+            using Replaced = EndOffsetType; // offset table entry
+            using SubRecordDims = mp_list<typename ReplaceDynamicSubarrays<T, RecordCoord<RC..., dynamic>>::Replaced>;
+            using SplitCoords = mp_push_front<
+                typename ReplaceDynamicSubarrays<T, RecordCoord<RC..., dynamic>>::SplitCoords,
+                RecordCoord<RC...>>;
+            using Augmented = T[];
+        };
+
+        template <typename Rec, typename RC, typename IS>
+        struct ReplaceDynamicSubarraysHelp;
+
+        template <typename Rec, std::size_t... RC, std::size_t... Is>
+        struct ReplaceDynamicSubarraysHelp<Rec, RecordCoord<RC...>, std::index_sequence<Is...>>
+        {
+            using Replaced = Record<Field<
+                GetFieldTag<mp_at_c<Rec, Is>>,
+                typename ReplaceDynamicSubarrays<GetFieldType<mp_at_c<Rec, Is>>, RecordCoord<RC..., Is>>::Replaced>...>;
+            using SubRecordDims
+                = mp_append<typename ReplaceDynamicSubarrays<GetFieldType<mp_at_c<Rec, Is>>, RecordCoord<RC..., Is>>::
+                                SubRecordDims...>;
+            using SplitCoords
+                = mp_append<typename ReplaceDynamicSubarrays<GetFieldType<mp_at_c<Rec, Is>>, RecordCoord<RC..., Is>>::
+                                SplitCoords...>;
+
+            using Augmented = mp_flatten<mp_transform<AddOffsetAndSizeFields, Rec>>;
+        };
+
+        template <typename... Fields, std::size_t... RC>
+        struct ReplaceDynamicSubarrays<Record<Fields...>, RecordCoord<RC...>>
+            : ReplaceDynamicSubarraysHelp<
+                  Record<Fields...>,
+                  RecordCoord<RC...>,
+                  std::make_index_sequence<sizeof...(Fields)>>
+        {
+        };
+
+        template <typename RC>
+        using BeforeDynamic
+            = RecordCoordFromList<mp_take<typename RC::List, mp_find<typename RC::List, mp_size_t<dynamic>>>>;
+
+        template <typename RC>
+        using AfterDynamic = RecordCoordFromList<mp_drop<
+            typename RC::List,
+            mp_size_t<std::min(mp_find<typename RC::List, mp_size_t<dynamic>>::value + 1, RC::size)>>>;
+
+        template <typename RC, std::ptrdiff_t Offset>
+        using OffsetLastCoord = RecordCoordFromList<
+            mp_push_back<mp_take_c<typename RC::List, RC::size - 1>, mp_size_t<RC::back + Offset>>>;
+
+        template <typename RecordDim, typename RecordCoord>
+        struct ShiftRecordCoord;
+
+        template <typename RecordDim>
+        struct ShiftRecordCoord<RecordDim, RecordCoord<>>
+        {
+            using Coord = RecordCoord<>;
+        };
+
+        template <typename RecordDim, std::size_t First, std::size_t... Rest>
+        struct ShiftRecordCoord<RecordDim, RecordCoord<First, Rest...>>
+        {
+            template <typename Field>
+            using IsUnboundArrayField = llama::internal::is_unbounded_array<GetFieldType<Field>>;
+
+            using ShiftedFirst
+                = RecordCoord<First - 2 * mp_count_if<mp_take_c<RecordDim, First>, IsUnboundArrayField>::value>;
+            using ShiftedRest = typename ShiftRecordCoord<mp_at_c<RecordDim, First>, RecordCoord<Rest...>>::Coord;
+
+            using Coord = Cat<ShiftedFirst, ShiftedRest>;
+        };
+    } // namespace internal
+
+    /// A type list containing mappings.
+    template <template <typename, typename> typename... SubMappings>
+    struct MappingList;
+
+    namespace internal
+    {
+        template <typename SubRecordDims, typename Mappings>
+        struct MapSubRecordDims;
+
+        template <typename... SubRecordDims, template <typename, typename> typename... SubMappings>
+        struct MapSubRecordDims<boost::mp11::mp_list<SubRecordDims...>, MappingList<SubMappings...>>
+        {
+            static_assert(
+                sizeof...(SubRecordDims) == sizeof...(SubMappings),
+                "There must be as many mappings as sub record dimensions");
+            using List = boost::mp11::mp_list<SubMappings<ArrayDims<1>, SubRecordDims>...>;
+        };
+
+        template <typename... SubRecordDims, template <typename, typename> typename Mapping>
+        struct MapSubRecordDims<boost::mp11::mp_list<SubRecordDims...>, MappingList<Mapping>>
+        {
+        private:
+            template <typename SubRecordDim>
+            using MapRecordDim = Mapping<ArrayDims<1>, SubRecordDim>;
+
+        public:
+            using List = boost::mp11::mp_transform<MapRecordDim, boost::mp11::mp_list<SubRecordDims...>>;
+        };
+    } // namespace internal
+
+    /// Meta mapping splitting off sub branches of the given record dimension tree at each field which's type is a
+    /// dynamic array. Each dynamic array field is then replaced by an integral offset of type \ref EndOffsetType. This
+    /// offset is used to navigate from a virtual record into a dynamic sub array member using a dynamic index. Two
+    /// computed fields are added per dynamic array field, which are named \ref EndOffset and \ref Size, giving access
+    /// to the offset value and the size of a dynamic sub array. The list of sub record dimensions is then further
+    /// mapped using a list of sub mappings.
+    ///
+    /// @tparam T_RecordDim A record dimension, possibly including field types which are dynamic arrays.
+    /// @tparam SubMappings A \ref MappingList of mappings that will be used to map the sub record dimensions after
+    /// splitting T_RecordDim at each dynamic array field. If the mapping list contains a single mapping, this one will
+    /// be used to map all sub record dimensions. Otherwise, a mapping needs to be given for each sub record dimension.
+    template <typename T_ArrayDims, typename T_RecordDim, typename SubMappings = MappingList<PreconfiguredAoS<>::type>>
+    struct OffsetTable
+    {
+        using RDS = internal::ReplaceDynamicSubarrays<T_RecordDim, RecordCoord<>>;
+        using SubRecordDims = boost::mp11::mp_push_front<typename RDS::SubRecordDims, typename RDS::Replaced>;
+        using SplitCoords = typename RDS::SplitCoords;
+
+        using MappedSubRecordDims = typename internal::MapSubRecordDims<SubRecordDims, SubMappings>::List;
+
+        boost::mp11::mp_rename<MappedSubRecordDims, Tuple> subMappings;
+
+        using ArrayDims = T_ArrayDims;
+        using RecordDim = typename RDS::Augmented;
+        static constexpr std::size_t blobCount = []() constexpr
+        {
+            std::size_t count = 0;
+            boost::mp11::mp_for_each<boost::mp11::mp_transform<boost::mp11::mp_identity, MappedSubRecordDims>>(
+                [&](auto subMapping) { count += decltype(subMapping)::type::blobCount; });
+            return count;
+        }
+        ();
+
+        constexpr OffsetTable() = default;
+
+        template <typename... ArrayDims>
+        LLAMA_FN_HOST_ACC_INLINE constexpr OffsetTable(ArrayDims... sizes) : subMappings(sizes...)
+        {
+        }
+
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto arrayDims() const -> ArrayDims
+        {
+            return get<0>(subMappings).arrayDims();
+        }
+
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto blobSize(std::size_t i) const -> std::size_t
+        {
+            std::size_t result = 0;
+            boost::mp11::mp_for_each<boost::mp11::mp_iota<boost::mp11::mp_size<MappedSubRecordDims>>>(
+                [&](auto jc)
+                {
+                    constexpr auto j = decltype(jc)::value;
+                    constexpr auto subBlobs = boost::mp11::mp_at_c<MappedSubRecordDims, j>::blobCount;
+                    if (i < subBlobs)
+                        result = get<j>(subMappings).blobSize(i);
+                    i -= subBlobs;
+                });
+            return result;
+        }
+
+        template <std::size_t... RecordCoords>
+        LLAMA_FN_HOST_ACC_INLINE static constexpr auto isComputed(RecordCoord<RecordCoords...>)
+        {
+            return true;
+        }
+
+        template <std::size_t N, typename RecordCoord, typename Blob>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto compute(
+            ArrayDims coord,
+            Array<std::size_t, N> dynamicArrayExtents,
+            RecordCoord rc,
+            Array<Blob, blobCount>& blobs) const -> decltype(auto)
+        {
+            return computeRecursive<0>(llama::RecordCoord{}, rc, coord, dynamicArrayExtents, blobs);
+        }
+
+    private:
+        template <
+            std::size_t MappingIndex,
+            typename ResolvedRecordCoord,
+            typename UnresolvedRecordCoord,
+            std::size_t N,
+            typename Blob>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto computeRecursive(
+            ResolvedRecordCoord,
+            UnresolvedRecordCoord,
+            ArrayDims coord,
+            Array<std::size_t, N> dynamicArrayExtents,
+            Array<Blob, blobCount>& blobs) const -> decltype(auto)
+        {
+            static_assert(
+                ArrayDims::rank == 1,
+                "Not implemented"); // this would need a way to get the prev of coord, also ArrayDims can be a different
+                                    // type during recursive instantiation
+
+            using UnresolvedBeforeDynamic = internal::BeforeDynamic<UnresolvedRecordCoord>;
+            using UnresolvedAfterDynamic = internal::AfterDynamic<UnresolvedRecordCoord>;
+            using ResolvedSoFar = Cat<ResolvedRecordCoord, UnresolvedBeforeDynamic>;
+
+            auto loadBeginOffset = [&](auto unresolvedBeforeDynamic) -> EndOffsetType
+            {
+                if (coord == ArrayDims{}) [[unlikely]]
+                    return 0;
+                auto prevCoord = coord;
+                prevCoord[0]--;
+                return reinterpret_cast<const EndOffsetType&>(
+                    *mapToAddress<MappingIndex>(ResolvedRecordCoord{}, unresolvedBeforeDynamic, prevCoord, blobs));
+            };
+
+            using Tag = GetTag<RecordDim, ResolvedSoFar>;
+            if constexpr (internal::isEndOffsetField<Tag>)
+                // load offset from dynamic array member field at prev record coord
+                return reinterpret_cast<EndOffsetType&>(*mapToAddress<MappingIndex>(
+                    ResolvedRecordCoord{},
+                    internal::OffsetLastCoord<UnresolvedBeforeDynamic, -1>{},
+                    coord,
+                    blobs));
+            else if constexpr (internal::isSizeField<Tag>)
+            {
+                // compute size from end offset and prev end offset (or 0 for the first sub array)
+                const auto begin = loadBeginOffset(internal::OffsetLastCoord<UnresolvedBeforeDynamic, -2>{});
+                const auto end = reinterpret_cast<const EndOffsetType&>(*mapToAddress<MappingIndex>(
+                    ResolvedRecordCoord{},
+                    internal::OffsetLastCoord<UnresolvedBeforeDynamic, -2>{},
+                    coord,
+                    blobs));
+                return static_cast<SizeType>(end - begin);
+            }
+            else if constexpr (std::is_same_v<UnresolvedBeforeDynamic, UnresolvedRecordCoord>)
+            {
+                // no dynamic sub arrays anymore, proceed with access
+                static_assert(N == 0);
+                using Type = GetType<RecordDim, ResolvedSoFar>;
+                return reinterpret_cast<Type&>(
+                    *mapToAddress<MappingIndex>(ResolvedRecordCoord{}, UnresolvedBeforeDynamic{}, coord, blobs));
+            }
+            else
+            {
+                // continue resolving with next submapping
+                using ShiftedCoord = typename internal::ShiftRecordCoord<RecordDim, ResolvedSoFar>::Coord;
+                constexpr auto nextSubMappingIndex = boost::mp11::mp_find<SplitCoords, ShiftedCoord>::value + 1;
+                static_assert(nextSubMappingIndex < boost::mp11::mp_size<MappedSubRecordDims>::value);
+                const auto dynamicSubIndex = loadBeginOffset(UnresolvedBeforeDynamic{}) + dynamicArrayExtents[0];
+                return computeRecursive<nextSubMappingIndex>(
+                    Cat<ResolvedSoFar, RecordCoord<dynamic>>{},
+                    UnresolvedAfterDynamic{},
+                    llama::ArrayDims{dynamicSubIndex},
+                    pop_front(dynamicArrayExtents),
+                    blobs);
+            }
+        }
+
+        template <
+            std::size_t MappingIndex,
+            typename RecordCoordBeforeThisMapping,
+            typename RecordCoordForThisMapping,
+            typename Blob>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto mapToAddress(
+            RecordCoordBeforeThisMapping,
+            RecordCoordForThisMapping,
+            ArrayDims coord,
+            Array<Blob, blobCount>& blobs) const -> std::byte*
+        {
+            // we need to shift the record coord before mapping, because the user exposed RecordDim contains the
+            // artificial EndOffset and Size fields, which the RecordDim of the submappings don't have.
+            using ExposedSubRecordDim = GetType<RecordDim, RecordCoordBeforeThisMapping>;
+            using ShiftedCoord =
+                typename internal::ShiftRecordCoord<ExposedSubRecordDim, RecordCoordForThisMapping>::Coord;
+            auto [nr, offset] = blobNrAndOffset(get<MappingIndex>(subMappings), ShiftedCoord{}, coord);
+            boost::mp11::mp_for_each<boost::mp11::mp_iota_c<MappingIndex>>(
+                [nr = std::ref(nr)](auto i) { nr += boost::mp11::mp_at<MappedSubRecordDims, decltype(i)>::blobCount; });
+            return &blobs[nr][offset];
+        }
+
+        template <typename Mapping, std::size_t... RecordCoords>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto blobNrAndOffset(
+            const Mapping& mapping,
+            RecordCoord<RecordCoords...>,
+            ArrayDims coord) const -> NrAndOffset
+        {
+            return mapping.template blobNrAndOffset<RecordCoords...>(coord);
+        }
+    };
+} // namespace llama::mapping
diff --git a/include/llama/mapping/One.hpp b/include/llama/mapping/One.hpp
index 936078bdd8..0acfdea84e 100644
--- a/include/llama/mapping/One.hpp
+++ b/include/llama/mapping/One.hpp
@@ -38,8 +38,9 @@ namespace llama::mapping
             return sizeOf<RecordDim>;
         }
 
-        template <std::size_t... RecordCoords>
-        LLAMA_FN_HOST_ACC_INLINE constexpr auto blobNrAndOffset(ArrayDims) const -> NrAndOffset
+        template <std::size_t... RecordCoords, std::size_t N = 0>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto blobNrAndOffset(ArrayDims, Array<std::size_t, N> = {}) const
+            -> NrAndOffset
         {
             constexpr auto offset = offsetOf<RecordDim, RecordCoord<RecordCoords...>>;
             return {0, offset};
diff --git a/include/llama/mapping/SoA.hpp b/include/llama/mapping/SoA.hpp
index 73b0b71ff7..8754f80d2c 100644
--- a/include/llama/mapping/SoA.hpp
+++ b/include/llama/mapping/SoA.hpp
@@ -57,8 +57,10 @@ namespace llama::mapping
                 return LinearizeArrayDimsFunctor{}.size(arrayDimsSize) * sizeOf<RecordDim>;
         }
 
-        template <std::size_t... RecordCoords>
-        LLAMA_FN_HOST_ACC_INLINE constexpr auto blobNrAndOffset(ArrayDims coord) const -> NrAndOffset
+        template <std::size_t... RecordCoords, std::size_t N = 0>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto blobNrAndOffset(
+            ArrayDims coord,
+            Array<std::size_t, N> dynamicArrayExtents = {}) const -> NrAndOffset
         {
             if constexpr (SeparateBuffers)
             {
diff --git a/include/llama/mapping/Split.hpp b/include/llama/mapping/Split.hpp
index d6b187b893..49c77c4125 100644
--- a/include/llama/mapping/Split.hpp
+++ b/include/llama/mapping/Split.hpp
@@ -103,8 +103,10 @@ namespace llama::mapping
                 return mapping1.blobSize(0) + mapping2.blobSize(0);
         }
 
-        template <std::size_t... RecordCoords>
-        LLAMA_FN_HOST_ACC_INLINE constexpr auto blobNrAndOffset(ArrayDims coord) const -> NrAndOffset
+        template <std::size_t... RecordCoords, std::size_t N = 0>
+        LLAMA_FN_HOST_ACC_INLINE constexpr auto blobNrAndOffset(
+            ArrayDims coord,
+            Array<std::size_t, N> dynamicArrayExtents = {}) const -> NrAndOffset
         {
             if constexpr (RecordCoordCommonPrefixIsSame<RecordCoordForMapping1, RecordCoord<RecordCoords...>>)
             {
@@ -112,13 +114,17 @@ namespace llama::mapping
                 // zero all coordinate values that are part of RecordCoordForMapping1
                 using Prefix = mp_repeat_c<mp_list_c<std::size_t, 0>, RecordCoordForMapping1::size>;
                 using Suffix = mp_drop_c<mp_list_c<std::size_t, RecordCoords...>, RecordCoordForMapping1::size>;
-                return blobNrAndOffset(RecordCoordFromList<mp_append<Prefix, Suffix>>{}, coord, mapping1);
+                return blobNrAndOffset(
+                    RecordCoordFromList<mp_append<Prefix, Suffix>>{},
+                    coord,
+                    dynamicArrayExtents,
+                    mapping1);
             }
             else
             {
                 constexpr auto dstCoord
                     = internal::offsetCoord(RecordCoord<RecordCoords...>{}, RecordCoordForMapping1{});
-                auto nrAndOffset = blobNrAndOffset(dstCoord, coord, mapping2);
+                auto nrAndOffset = blobNrAndOffset(dstCoord, coord, dynamicArrayExtents, mapping2);
                 if constexpr (SeparateBlobs)
                     nrAndOffset.nr += Mapping1::blobCount;
                 else
@@ -131,13 +137,14 @@ namespace llama::mapping
         }
 
     private:
-        template <std::size_t... RecordCoords, typename Mapping>
+        template <std::size_t... RecordCoords, std::size_t N, typename Mapping>
         LLAMA_FN_HOST_ACC_INLINE constexpr auto blobNrAndOffset(
             RecordCoord<RecordCoords...>,
             ArrayDims coord,
+            Array<std::size_t, N> dynamicArrayExtents,
             const Mapping& mapping) const -> NrAndOffset
         {
-            return mapping.template blobNrAndOffset<RecordCoords...>(coord);
+            return mapping.template blobNrAndOffset<RecordCoords...>(coord, dynamicArrayExtents);
         }
 
     public:
diff --git a/include/llama/mapping/Trace.hpp b/include/llama/mapping/Trace.hpp
index a4492cf358..6f31daf4a9 100644
--- a/include/llama/mapping/Trace.hpp
+++ b/include/llama/mapping/Trace.hpp
@@ -75,8 +75,9 @@ namespace llama::mapping
             return mapping.blobSize(i);
         }
 
-        template <std::size_t... RecordCoords>
-        LLAMA_FN_HOST_ACC_INLINE auto blobNrAndOffset(ArrayDims coord) const -> NrAndOffset
+        template <std::size_t... RecordCoords, std::size_t N = 0>
+        LLAMA_FN_HOST_ACC_INLINE auto blobNrAndOffset(ArrayDims coord, Array<std::size_t, N> dynamicArrayExtents = {})
+            const -> NrAndOffset
         {
             const static auto name = internal::coordName<RecordDim>(RecordCoord<RecordCoords...>{});
             fieldHits.at(name)++;
diff --git a/include/llama/mapping/tree/Mapping.hpp b/include/llama/mapping/tree/Mapping.hpp
index 499e4883bc..1e6ca745a5 100644
--- a/include/llama/mapping/tree/Mapping.hpp
+++ b/include/llama/mapping/tree/Mapping.hpp
@@ -202,8 +202,9 @@ namespace llama::mapping::tree
             return internal::getTreeBlobSize(resultTree);
         }
 
-        template <std::size_t... RecordCoords>
-        LLAMA_FN_HOST_ACC_INLINE auto blobNrAndOffset(ArrayDims coord) const -> NrAndOffset
+        template <std::size_t... RecordCoords, std::size_t N = 0>
+        LLAMA_FN_HOST_ACC_INLINE auto blobNrAndOffset(ArrayDims coord, Array<std::size_t, N> dynamicArrayExtents = {})
+            const -> NrAndOffset
         {
             auto const basicTreeCoord = createTreeCoord<RecordCoord<RecordCoords...>>(coord);
             auto const resultTreeCoord = mergedFunctors.basicCoordToResultCoord(basicTreeCoord, basicTree);
diff --git a/tests/computedprop.cpp b/tests/computedprop.cpp
index a7aa0b97a4..edb374f4aa 100644
--- a/tests/computedprop.cpp
+++ b/tests/computedprop.cpp
@@ -23,9 +23,10 @@ namespace
             return llama::RecordCoordCommonPrefixIsSame<llama::RecordCoord<RecordCoords...>, llama::RecordCoord<3>>;
         }
 
-        template <std::size_t... RecordCoords, typename Blob>
+        template <std::size_t... RecordCoords, std::size_t N, typename Blob>
         constexpr auto compute(
             ArrayDims coord,
+            llama::Array<std::size_t, N> dynamicArrayExtents,
             llama::RecordCoord<RecordCoords...>,
             llama::Array<Blob, Base::blobCount>& storageBlobs) const
         {
@@ -128,9 +129,12 @@ namespace
             return true;
         }
 
-        template <std::size_t... RecordCoords, typename Blob>
-        constexpr auto compute(ArrayDims coord, llama::RecordCoord<RecordCoords...>, llama::Array<Blob, blobCount>&)
-            const -> std::size_t
+        template <std::size_t... RecordCoords, std::size_t N, typename Blob>
+        constexpr auto compute(
+            ArrayDims coord,
+            llama::Array<std::size_t, N> dynamicArrayExtents,
+            llama::RecordCoord<RecordCoords...>,
+            llama::Array<Blob, blobCount>&) const -> std::size_t
         {
             return std::reduce(std::begin(coord), std::end(coord), std::size_t{1}, std::multiplies<>{});
         }
@@ -202,9 +206,10 @@ namespace
             return true;
         }
 
-        template <std::size_t... RecordCoords, typename Blob>
+        template <std::size_t... RecordCoords, std::size_t N, typename Blob>
         constexpr auto compute(
             ArrayDims coord,
+            llama::Array<std::size_t, N> dynamicArrayExtents,
             llama::RecordCoord<RecordCoords...>,
             llama::Array<Blob, blobCount>& blobs) const -> BoolRef
         {
diff --git a/tests/core.cpp b/tests/core.cpp
index c17bc660f2..e8507c793e 100644
--- a/tests/core.cpp
+++ b/tests/core.cpp
@@ -277,4 +277,32 @@ TEST_CASE("flatRecordCoord")
     STATIC_REQUIRE(llama::flatRecordCoord<Particle, llama::RecordCoord<3, 1>> == 8);
     STATIC_REQUIRE(llama::flatRecordCoord<Particle, llama::RecordCoord<3, 2>> == 9);
     STATIC_REQUIRE(llama::flatRecordCoord<Particle, llama::RecordCoord<3, 3>> == 10);
-}
\ No newline at end of file
+}
+
+TEST_CASE("unboundArrays")
+{
+    struct Tag
+    {
+    };
+
+    using Int0 = int;
+    using Int1 = int[];
+    using Int2 = llama::Record<llama::Field<Tag, int[]>>[];
+    using Int3 = llama::Record<llama::Field<Tag, llama::Record<llama::Field<Tag, int[]>>[]>>[];
+
+    using llama::internal::unboundArraysUntil;
+    STATIC_REQUIRE(unboundArraysUntil<Int0, llama::RecordCoord<>> == 0);
+    STATIC_REQUIRE(unboundArraysUntil<Int1, llama::RecordCoord<>> == 0);
+    STATIC_REQUIRE(unboundArraysUntil<Int1, llama::RecordCoord<llama::dynamic>> == 1);
+    STATIC_REQUIRE(unboundArraysUntil<Int2, llama::RecordCoord<>> == 0);
+    STATIC_REQUIRE(unboundArraysUntil<Int2, llama::RecordCoord<llama::dynamic>> == 1);
+    STATIC_REQUIRE(unboundArraysUntil<Int2, llama::RecordCoord<llama::dynamic, 0>> == 1);
+    STATIC_REQUIRE(unboundArraysUntil<Int2, llama::RecordCoord<llama::dynamic, 0, llama::dynamic>> == 2);
+    STATIC_REQUIRE(unboundArraysUntil<Int3, llama::RecordCoord<>> == 0);
+    STATIC_REQUIRE(unboundArraysUntil<Int3, llama::RecordCoord<llama::dynamic>> == 1);
+    STATIC_REQUIRE(unboundArraysUntil<Int3, llama::RecordCoord<llama::dynamic, llama::dynamic>> == 1);
+    STATIC_REQUIRE(unboundArraysUntil<Int3, llama::RecordCoord<llama::dynamic, 0, llama::dynamic>> == 2);
+    STATIC_REQUIRE(unboundArraysUntil<Int3, llama::RecordCoord<llama::dynamic, 0, llama::dynamic, 0>> == 2);
+    STATIC_REQUIRE(
+        unboundArraysUntil<Int3, llama::RecordCoord<llama::dynamic, 0, llama::dynamic, 0, llama::dynamic>> == 3);
+}
diff --git a/tests/recorddimension.cpp b/tests/recorddimension.cpp
index 374090591f..cd4543acff 100644
--- a/tests/recorddimension.cpp
+++ b/tests/recorddimension.cpp
@@ -4,6 +4,8 @@
 #include <atomic>
 #include <catch2/catch.hpp>
 #include <complex>
+#include <fstream>
+#include <llama/DumpMapping.hpp>
 #include <llama/llama.hpp>
 #include <vector>
 
@@ -267,3 +269,215 @@ TEST_CASE("recorddim.record_with_arrays")
     view(0u)(A3{}, 1_RC, 0_RC);
     view(0u)(A3{}, 1_RC, 1_RC);
 }
+
+TEST_CASE("dynamic array")
+{
+    struct Tag
+    {
+    };
+    using RecordDim = llama::Record<llama::Field<Tag, int[]>>;
+    auto mapping
+        = llama::mapping::OffsetTable<llama::ArrayDims<1>, RecordDim>{llama::ArrayDims{2}, llama::ArrayDims{5}};
+    auto view = allocView(mapping);
+
+    view(0)(llama::EndOffset<Tag>{}) = 3;
+    view(1)(llama::EndOffset<Tag>{}) = 5;
+
+    CHECK(view(0)(llama::Size<Tag>{}) == 3);
+    int& e0 = view(0)(Tag{})(0);
+    int& e1 = view(0)(Tag{})(1);
+    int& e2 = view(0)(Tag{})(2);
+    CHECK(view(1)(llama::Size<Tag>{}) == 2);
+    int& e3 = view(1)(Tag{})(0);
+    int& e4 = view(1)(Tag{})(1);
+
+    e0 = 1;
+    e1 = 2;
+    e2 = 3;
+    e3 = 4;
+    e4 = 5;
+    CHECK(e0 == 1);
+    CHECK(e1 == 2);
+    CHECK(e2 == 3);
+    CHECK(e3 == 4);
+    CHECK(e4 == 5);
+}
+
+namespace
+{
+    // clang-format off
+    struct run {};
+    struct luminosityBlock {};
+    struct Electrons {};
+    struct Muons {};
+    struct Eta{};
+    struct Mass{};
+    struct Phi{};
+
+    using Electron = llama::Record<
+        llama::Field<Eta, float>,
+        llama::Field<Mass, float>,
+        llama::Field<Phi, float>
+    >;
+    using Muon = llama::Record<
+        llama::Field<Eta, float>,
+        llama::Field<Mass, float>,
+        llama::Field<Phi, float>
+    >;
+    using Event = llama::Record<
+        llama::Field<run, std::int32_t>,
+        llama::Field<luminosityBlock, std::int32_t>,
+        llama::Field<Electrons, Electron[]>,
+        llama::Field<Muons, Muon[]>
+    >;
+    // clang-format on
+} // namespace
+
+TEST_CASE("edm")
+{
+    // 3 events with 5 electrons and 4 muons
+    auto mapping = llama::mapping::OffsetTable<llama::ArrayDims<1>, Event>{
+        llama::ArrayDims{3},
+        llama::ArrayDims{5},
+        llama::ArrayDims{4}};
+    auto view = llama::allocView(mapping);
+
+    // setup offset table
+    view(0)(llama::EndOffset<Electrons>{}) = 3;
+    view(1)(llama::EndOffset<Electrons>{}) = 3;
+    view(2)(llama::EndOffset<Electrons>{}) = 5;
+
+    view(0)(llama::EndOffset<Muons>{}) = 0;
+    view(1)(llama::EndOffset<Muons>{}) = 3;
+    view(2)(llama::EndOffset<Muons>{}) = 4;
+
+    // fill with values
+    int value = 1;
+    for (auto i = 0; i < 3; i++)
+    {
+        auto event = view(i);
+        event(run{}) = value++;
+        event(luminosityBlock{}) = value++;
+        for (auto j = 0; j < event(llama::Size<Electrons>{}); j++)
+        {
+            auto electron = event(Electrons{})(j);
+            electron(Eta{}) = value++;
+            electron(Mass{}) = value++;
+            electron(Phi{}) = value++;
+        }
+        for (auto j = 0; j < event(llama::Size<Muons>{}); j++)
+        {
+            auto muon = event(Muons{})(j);
+            muon(Eta{}) = value++;
+            muon(Mass{}) = value++;
+            muon(Phi{}) = value++;
+        }
+    }
+
+    // check all values
+    value = 1;
+    CHECK(view(0)(run{}) == value++);
+    CHECK(view(0)(luminosityBlock{}) == value++);
+    CHECK(view(0)(llama::EndOffset<Electrons>{}) == 3);
+    CHECK(view(0)(llama::Size<Electrons>{}) == 3);
+    CHECK(view(0)(Electrons{})(0) (Eta{}) == value++);
+    CHECK(view(0)(Electrons{})(0) (Mass{}) == value++);
+    CHECK(view(0)(Electrons{})(0) (Phi{}) == value++);
+    CHECK(view(0)(Electrons{})(1) (Eta{}) == value++);
+    CHECK(view(0)(Electrons{})(1) (Mass{}) == value++);
+    CHECK(view(0)(Electrons{})(1) (Phi{}) == value++);
+    CHECK(view(0)(Electrons{})(2) (Eta{}) == value++);
+    CHECK(view(0)(Electrons{})(2) (Mass{}) == value++);
+    CHECK(view(0)(Electrons{})(2) (Phi{}) == value++);
+    CHECK(view(0)(llama::EndOffset<Muons>{}) == 0);
+    CHECK(view(0)(llama::Size<Muons>{}) == 0);
+
+    CHECK(view(1)(run{}) == value++);
+    CHECK(view(1)(luminosityBlock{}) == value++);
+    CHECK(view(1)(llama::EndOffset<Electrons>{}) == 3);
+    CHECK(view(1)(llama::Size<Electrons>{}) == 0);
+    CHECK(view(1)(llama::EndOffset<Muons>{}) == 3);
+    CHECK(view(1)(llama::Size<Muons>{}) == 3);
+    CHECK(view(1)(Muons{})(0) (Eta{}) == value++);
+    CHECK(view(1)(Muons{})(0) (Mass{}) == value++);
+    CHECK(view(1)(Muons{})(0) (Phi{}) == value++);
+    CHECK(view(1)(Muons{})(1) (Eta{}) == value++);
+    CHECK(view(1)(Muons{})(1) (Mass{}) == value++);
+    CHECK(view(1)(Muons{})(1) (Phi{}) == value++);
+    CHECK(view(1)(Muons{})(2) (Eta{}) == value++);
+    CHECK(view(1)(Muons{})(2) (Mass{}) == value++);
+    CHECK(view(1)(Muons{})(2) (Phi{}) == value++);
+
+    CHECK(view(2)(run{}) == value++);
+    CHECK(view(2)(luminosityBlock{}) == value++);
+    CHECK(view(2)(llama::EndOffset<Electrons>{}) == 5);
+    CHECK(view(2)(llama::Size<Electrons>{}) == 2);
+    CHECK(view(2)(Electrons{})(0) (Eta{}) == value++);
+    CHECK(view(2)(Electrons{})(0) (Mass{}) == value++);
+    CHECK(view(2)(Electrons{})(0) (Phi{}) == value++);
+    CHECK(view(2)(Electrons{})(1) (Eta{}) == value++);
+    CHECK(view(2)(Electrons{})(1) (Mass{}) == value++);
+    CHECK(view(2)(Electrons{})(1) (Phi{}) == value++);
+    CHECK(view(2)(llama::EndOffset<Muons>{}) == 4);
+    CHECK(view(2)(llama::Size<Muons>{}) == 1);
+    CHECK(view(2)(Muons{})(0) (Eta{}) == value++);
+    CHECK(view(2)(Muons{})(0) (Mass{}) == value++);
+    CHECK(view(2)(Muons{})(0) (Phi{}) == value++);
+}
+
+TEST_CASE("dump.edm.AlignedAoS")
+{
+    auto mapping = llama::mapping::OffsetTable<llama::ArrayDims<1>, Event>{
+        llama::ArrayDims{30},
+        llama::ArrayDims{50},
+        llama::ArrayDims{40}};
+    std::ofstream{"dump.edm.AlignedAoS.svg"} << llama::toSvg(mapping);
+    std::ofstream{"dump.edm.AlignedAoS.html"} << llama::toHtml(mapping);
+}
+
+TEST_CASE("dump.edm.MultiBlobSoA")
+{
+    auto mapping = llama::mapping::
+        OffsetTable<llama::ArrayDims<1>, Event, llama::mapping::MappingList<llama::mapping::PreconfiguredSoA<>::type>>{
+            llama::ArrayDims{30},
+            llama::ArrayDims{50},
+            llama::ArrayDims{40}};
+    std::ofstream{"dump.edm.MultiBlobSoA.svg"} << llama::toSvg(mapping);
+    std::ofstream{"dump.edm.MultiBlobSoA.html"} << llama::toHtml(mapping);
+}
+
+TEST_CASE("dump.edm.AlignedAoS_MultiBlobSoA")
+{
+    auto mapping = llama::mapping::OffsetTable<
+        llama::ArrayDims<1>,
+        Event,
+        llama::mapping::MappingList<
+            llama::mapping::PreconfiguredAoS<>::type,
+            llama::mapping::PreconfiguredSoA<>::type,
+            llama::mapping::PreconfiguredSoA<>::type>>{
+        llama::ArrayDims{30},
+        llama::ArrayDims{50},
+        llama::ArrayDims{40}};
+    std::ofstream{"dump.edm.AlignedAoS_MultiBlobSoA.svg"} << llama::toSvg(mapping);
+    std::ofstream{"dump.edm.AlignedAoS_MultiBlobSoA.html"} << llama::toHtml(mapping);
+}
+
+TEST_CASE("dump.edm.Split_AlignedAoS_MultiBlobSoA")
+{
+    auto mapping = llama::mapping::OffsetTable<
+        llama::ArrayDims<1>,
+        Event,
+        llama::mapping::MappingList<
+            llama::mapping::PreconfiguredSplit<
+                llama::RecordCoord<2>,
+                llama::mapping::PreconfiguredAoS<>::type,
+                llama::mapping::PreconfiguredAoS<>::type,
+                true>::type,
+            llama::mapping::PreconfiguredSoA<>::type,
+            llama::mapping::PreconfiguredSoA<>::type>>{
+        llama::ArrayDims{30},
+        llama::ArrayDims{50},
+        llama::ArrayDims{40}};
+    std::ofstream{"dump.edm.Split_AlignedAoS_MultiBlobSoA.svg"} << llama::toSvg(mapping);
+    std::ofstream{"dump.edm.Split_AlignedAoS_MultiBlobSoA.html"} << llama::toHtml(mapping);
+}