Add copy trackers in tests

.github/workflows/linux.yml

@@ -153,7 +153,8 @@ jobs:
           -DFETCH_DEPENDENCIES_WITH_CMAKE=MISSING \
           -DSPARROW_BUILD_SHARED=${{matrix.shared}} \
           -DCMAKE_EXE_LINKER_FLAGS="-fuse-ld=mold" \
-          -DCMAKE_SHARED_LINKER_FLAGS="-fuse-ld=mold"
+          -DCMAKE_SHARED_LINKER_FLAGS="-fuse-ld=mold" \
+          -DTRACK_COPIES=ON
 
     - name: Build library
       working-directory: build

.github/workflows/manylinux.yml

@@ -78,7 +78,8 @@ jobs:
           -DBUILD_EXAMPLES=ON \
           -DFETCH_DEPENDENCIES_WITH_CMAKE=MISSING \
           -DSPARROW_BUILD_SHARED=ON \
-          -DCREATE_JSON_READER_TARGET=ON
+          -DCREATE_JSON_READER_TARGET=ON \
+          -DTRACK_COPIES=ON
 
     - name: Build library
       working-directory: sparrow/build

.github/workflows/osx.yml

@@ -70,7 +70,8 @@ jobs:
           -DUSE_DATE_POLYFILL=ON \
           -DCMAKE_C_COMPILER_LAUNCHER=ccache \
           -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-          -DFETCH_DEPENDENCIES_WITH_CMAKE=MISSING
+          -DFETCH_DEPENDENCIES_WITH_CMAKE=MISSING \
+          -DTRACK_COPIES=ON
 
       - name: Build
         working-directory: build

.github/workflows/qemu.yaml

@@ -79,6 +79,7 @@ jobs:
           -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
           -DCMAKE_C_COMPILER_LAUNCHER=ccache
           -DSPARROW_CONTRACTS_THROW_ON_FAILURE=ON
+          -DTRACK_COPIES=ON
           -B build
 
         shell: alpine.sh {0}

include/sparrow/arrow_interface/arrow_array.hpp

@@ -14,7 +14,6 @@
 
 #pragma once
 
-#include <cstddef>
 #include <cstdint>
 #include <ranges>
 #include <type_traits>
@@ -26,10 +25,20 @@
 #include "sparrow/arrow_interface/arrow_array/private_data.hpp"
 #include "sparrow/c_interface.hpp"
 #include "sparrow/config/config.hpp"
+#include "sparrow/debug/copy_tracker.hpp"
 #include "sparrow/utils/repeat_container.hpp"
 
 namespace sparrow
 {
+    namespace copy_tracker
+    {
+        template <>
+        inline std::string key<ArrowArray>()
+        {
+            return "ArrowArray";
+        }
+    }
+
     /**
      * Creates an `ArrowArray`.
      *

include/sparrow/arrow_interface/arrow_schema.hpp

@@ -30,11 +30,21 @@
 #include "sparrow/arrow_interface/arrow_schema/private_data.hpp"
 #include "sparrow/c_interface.hpp"
 #include "sparrow/config/config.hpp"
+#include "sparrow/debug/copy_tracker.hpp"
 #include "sparrow/utils/contracts.hpp"
 #include "sparrow/utils/metadata.hpp"
 
 namespace sparrow
 {
+    namespace copy_tracker
+    {
+        template <>
+        inline std::string key<ArrowSchema>()
+        {
+            return "ArrowSchema";
+        }
+    }
+
     /**
      * Creates an `ArrowSchema` owned by a `unique_ptr` and holding the provided data.
      *

include/sparrow/buffer/buffer.hpp

@@ -24,6 +24,7 @@
 #include <type_traits>
 
 #include "sparrow/buffer/allocator.hpp"
+#include "sparrow/debug/copy_tracker.hpp"
 #include "sparrow/details/3rdparty/xsimd_aligned_allocator.hpp"
 #include "sparrow/utils/contracts.hpp"
 #include "sparrow/utils/iterator.hpp"
@@ -35,6 +36,15 @@
 
 namespace sparrow
 {
+    namespace copy_tracker
+    {
+        template <typename T>
+        std::string key_buffer()
+        {
+            return "buffer<" + std::string(typeid(T).name()) + ">";
+        }
+    }
+
     template <typename T>
     concept is_buffer_view = requires(T t) { typename T::is_buffer_view; };
 
@@ -490,6 +500,7 @@ namespace sparrow
             this->create_storage(rhs.size());
             get_data().p_end = copy_initialize(rhs.begin(), rhs.end(), get_data().p_begin, get_allocator());
         }
+        copy_tracker::increase(copy_tracker::key_buffer<T>());
     }
 
     template <class T>
@@ -502,6 +513,7 @@ namespace sparrow
             this->create_storage(rhs.size());
             get_data().p_end = copy_initialize(rhs.begin(), rhs.end(), get_data().p_begin, get_allocator());
         }
+        copy_tracker::increase(copy_tracker::key_buffer<T>());
     }
 
     template <class T>

include/sparrow/buffer/buffer_view.hpp

@@ -15,10 +15,20 @@
 #pragma once
 
 #include "sparrow/buffer/buffer.hpp"
+#include "sparrow/debug/copy_tracker.hpp"
 #include "sparrow/utils/contracts.hpp"
 
 namespace sparrow
 {
+    namespace copy_tracker
+    {
+        template <class T>
+        std::string key_buffer_view()
+        {
+            return "buffer_view<" + std::string(typeid(T).name()) + ">";
+        }
+    }
+
     /*
      * Non-owning view of a contiguous sequence of objects of type T.
      *
@@ -48,6 +58,10 @@ namespace sparrow
         using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
         constexpr buffer_view() = default;
+        constexpr buffer_view(const buffer_view&);
+        constexpr buffer_view(buffer_view&&) noexcept = default;
+        constexpr buffer_view& operator=(const buffer_view&) = default;
+        constexpr buffer_view& operator=(buffer_view&&) noexcept = default;
         constexpr explicit buffer_view(buffer<T>& buffer)
             requires(!std::is_const_v<T>);
         template <class U>
@@ -116,6 +130,14 @@ namespace sparrow
      * buffer_view implementation *
      ******************************/
 
+    template <class T>
+    constexpr buffer_view<T>::buffer_view(const buffer_view& other)
+        : p_data(other.p_data)
+        , m_size(other.m_size)
+    {
+        copy_tracker::increase(copy_tracker::key_buffer_view<T>());
+    }
+
     template <class T>
     constexpr buffer_view<T>::buffer_view(buffer<T>& buffer)
         requires(!std::is_const_v<T>)

include/sparrow/decimal_array.hpp

@@ -20,6 +20,7 @@
 #include "sparrow/arrow_interface/arrow_array_schema_proxy.hpp"
 #include "sparrow/arrow_interface/arrow_schema.hpp"
 #include "sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp"
+#include "sparrow/debug/copy_tracker.hpp"
 #include "sparrow/layout/array_bitmap_base.hpp"
 #include "sparrow/layout/decimal_reference.hpp"
 #include "sparrow/layout/layout_utils.hpp"
@@ -41,6 +42,16 @@ namespace sparrow
     template <decimal_type T>
     class decimal_array;
 
+    namespace copy_tracker
+    {
+        template <typename T>
+            requires mpl::is_type_instance_of_v<T, decimal_array>
+        std::string key()
+        {
+            return "decimal_array";
+        }
+    }
+
     /** Type alias for 32-bit decimal array. */
     using decimal_32_array = decimal_array<decimal<int32_t>>;
     /** Type alias for 64-bit decimal array. */
@@ -192,6 +203,36 @@ namespace sparrow
          */
         explicit decimal_array(arrow_proxy proxy);
 
+        /**
+         * Copy constructor.
+         *
+         * @param rhs The decimal array to copy from.
+         */
+        decimal_array(const decimal_array& rhs);
+
+        /**
+         * Copy assignment operator.
+         *
+         * @param rhs The decimal array to assign from.
+         * @return Reference to this array.
+         */
+        decimal_array& operator=(const decimal_array& rhs) = default;
+
+        /**
+         * Move constructor.
+         *
+         * @param rhs The decimal array to move from.
+         */
+        decimal_array(decimal_array&& rhs) noexcept = default;
+
+        /**
+         * Move assignment operator.
+         *
+         * @param rhs The decimal array to move assign from.
+         * @return Reference to this array.
+         */
+        decimal_array& operator=(decimal_array&& rhs) noexcept = default;
+
         /**
          * Constructs a decimal array with the given arguments.
          *
@@ -536,6 +577,15 @@ namespace sparrow
         }
     }
 
+    template <decimal_type T>
+    decimal_array<T>::decimal_array(const decimal_array& rhs)
+        : base_type(rhs)
+        , m_precision(rhs.m_precision)
+        , m_scale(rhs.m_scale)
+    {
+        copy_tracker::increase(copy_tracker::key<decimal_array<T>>());
+    }
+
     template <decimal_type T>
     template <std::ranges::input_range VALUE_RANGE, validity_bitmap_input VALIDITY_RANGE, input_metadata_container METADATA_RANGE>
         requires std::convertible_to<std::ranges::range_value_t<VALUE_RANGE>, typename T::integer_type>

include/sparrow/dictionary_encoded_array.hpp

@@ -20,6 +20,7 @@
 #include "sparrow/arrow_interface/arrow_array_schema_proxy.hpp"
 #include "sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp"
 #include "sparrow/c_interface.hpp"
+#include "sparrow/debug/copy_tracker.hpp"
 #include "sparrow/layout/array_access.hpp"
 #include "sparrow/layout/array_factory.hpp"
 #include "sparrow/layout/array_helper.hpp"
@@ -91,6 +92,16 @@ namespace sparrow
     template <std::integral IT>
     class dictionary_encoded_array;
 
+    namespace copy_tracker
+    {
+        template <typename T>
+            requires mpl::is_type_instance_of_v<T, dictionary_encoded_array>
+        std::string key()
+        {
+            return "dictionary_encoded_array";
+        }
+    }
+
     namespace detail
     {
         template <std::integral IT>
@@ -591,6 +602,7 @@ namespace sparrow
         , m_keys_layout(create_keys_layout(m_proxy))
         , p_values_layout(create_values_layout(m_proxy))
     {
+        copy_tracker::increase(copy_tracker::key<self_type>());
     }
 
     template <std::integral IT>

include/sparrow/fixed_width_binary_array.hpp

@@ -28,6 +28,7 @@
 #include "sparrow/arrow_interface/arrow_schema.hpp"
 #include "sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp"
 #include "sparrow/c_interface.hpp"
+#include "sparrow/debug/copy_tracker.hpp"
 #include "sparrow/layout/array_bitmap_base.hpp"
 #include "sparrow/layout/fixed_width_binary_array_utils.hpp"
 #include "sparrow/layout/fixed_width_binary_reference.hpp"
@@ -79,6 +80,15 @@ namespace sparrow
         fixed_width_binary_traits::value_type,
         fixed_width_binary_traits::const_reference>;
 
+    namespace copy_tracker
+    {
+        template <>
+        inline std::string key<fixed_width_binary_array>()
+        {
+            return "fixed_width_binary_array";
+        }
+    }
+
     template <std::ranges::sized_range T, typename CR, typename Ext>
     struct array_inner_types<fixed_width_binary_array_impl<T, CR, Ext>> : array_inner_types_base
     {
@@ -179,6 +189,14 @@ namespace sparrow
          */
         explicit fixed_width_binary_array_impl(arrow_proxy);
 
+        fixed_width_binary_array_impl(const self_type&);
+
+        /** Move constructor */
+        fixed_width_binary_array_impl(self_type&&) noexcept = default;
+
+        self_type& operator=(const self_type&) = default;
+        self_type& operator=(self_type&&) noexcept = default;
+
         /**
          * @brief Generic constructor for creating fixed-width binary array.
          *
@@ -655,6 +673,16 @@ namespace sparrow
         SPARROW_ASSERT_TRUE(this->get_arrow_proxy().data_type() == data_type::FIXED_WIDTH_BINARY);
     }
 
+    template <std::ranges::sized_range T, typename CR, typename Ext>
+    fixed_width_binary_array_impl<T, CR, Ext>::fixed_width_binary_array_impl(const self_type& rhs)
+        : base_type(rhs)
+        , m_element_size(rhs.m_element_size)
+    {
+        copy_tracker::increase(copy_tracker::key<self_type>());
+    }
+
+    // Move constructor and assignment are defaulted in the class definition
+
     template <std::ranges::sized_range T, typename CR, typename Ext>
     template <mpl::char_like C, validity_bitmap_input VB, input_metadata_container METADATA_RANGE>
     arrow_proxy fixed_width_binary_array_impl<T, CR, Ext>::create_proxy(

include/sparrow/layout/primitive_array_impl.hpp

@@ -18,6 +18,7 @@
 #include "sparrow/arrow_interface/arrow_array.hpp"
 #include "sparrow/arrow_interface/arrow_schema.hpp"
 #include "sparrow/buffer/dynamic_bitset/dynamic_bitset.hpp"
+#include "sparrow/debug/copy_tracker.hpp"
 #include "sparrow/layout/array_bitmap_base.hpp"
 #include "sparrow/layout/array_wrapper.hpp"
 #include "sparrow/layout/primitive_data_access.hpp"
@@ -31,6 +32,16 @@ namespace sparrow
     template <trivial_copyable_type T, typename Ext = empty_extension, trivial_copyable_type T2 = T>
     class primitive_array_impl;
 
+    namespace copy_tracker
+    {
+        template <typename T>
+            requires mpl::is_type_instance_of_v<T, primitive_array_impl>
+        std::string key()
+        {
+            return "primitive_array";
+        }
+    }
+
     template <trivial_copyable_type T, typename Ext, trivial_copyable_type T2>
     struct array_inner_types<primitive_array_impl<T, Ext, T2>> : array_inner_types_base
     {
@@ -482,6 +493,7 @@ namespace sparrow
         : base_type(rhs)
         , access_class_type(this->get_arrow_proxy(), DATA_BUFFER_INDEX)
     {
+        copy_tracker::increase(copy_tracker::key<self_type>());
     }
 
     template <trivial_copyable_type T, typename Ext, trivial_copyable_type T2>