updates

Author: pavel-kirienko

libudpard/udpard.c

@@ -853,7 +853,6 @@ static rx_fragment_tree_update_result_t rx_fragment_tree_update(udpard_tree_t**
     // render smaller fragments that overlap with its edges redundant.
     // To check for that, we create a new virtual fragment that represents the new fragment together with those
     // that join it on either end, if any, and then look for fragments contained within.
-    // The search interval would be (v_left, v_right-1) to avoid matching the neighbors themselves.
     // Example:
     //                |--B--|
     //             |--X--|
@@ -876,13 +875,13 @@ static rx_fragment_tree_update_result_t rx_fragment_tree_update(udpard_tree_t**
     }
     frag = (udpard_fragment_t*)cavl2_predecessor(*root, &right, &rx_cavl_compare_fragment_offset);
     if (frag != NULL) {
-        v_right = larger(v_right, frag->offset + frag->view.size);
+        v_right = larger(v_right, larger(frag->offset + frag->view.size, 1U) - 1U); // Avoid matching the right neighbor
     }
     UDPARD_ASSERT((v_left <= left) && (right <= v_right));
 
     // Find the first victim. It has to be done early to decide if the new fragment is worth keeping at all.
     frag            = (udpard_fragment_t*)cavl2_lower_bound(*root, &v_left, &rx_cavl_compare_fragment_offset);
-    const bool need = ((frag != NULL) && ((frag->offset + frag->view.size) < v_right)) ||
+    const bool need = ((frag != NULL) && ((frag->offset + frag->view.size) <= v_right)) ||
                       rx_fragment_is_needed(*root, frame.offset, frame.payload.size, transfer_payload_size, extent);
     if (!need) {
         mem_free_payload(payload_deleter, frame.origin);
@@ -904,7 +903,7 @@ static rx_fragment_tree_update_result_t rx_fragment_tree_update(udpard_tree_t**
     mew->payload_deleter = payload_deleter;
 
     // Remove all redundant fragments before inserting the new one.
-    while ((frag != NULL) && ((frag->offset + frag->view.size) < v_right)) {
+    while ((frag != NULL) && ((frag->offset + frag->view.size) <= v_right)) {
         cavl2_remove(root, &frag->index_offset);
         mem_free_payload(frag->payload_deleter, frag->origin);
         mem_free(fragment_memory, sizeof(udpard_fragment_t), frag);

tests/src/helpers.h

@@ -2,12 +2,13 @@
 // Copyright (c) 2016 Cyphal Development Team.
 /// Copyright 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 
+// ReSharper disable CppRedundantInlineSpecifier
+// NOLINTBEGIN(*DeprecatedOrUnsafeBufferHandling,*err34-c)
 #pragma once
 
 #include <udpard.h> // Shall always be included first.
 #include <stdlib.h>
 #include <stdio.h>
-#include <limits.h>
 #include <time.h>
 
 #if !(defined(UDPARD_VERSION_MAJOR) && defined(UDPARD_VERSION_MINOR))
@@ -64,12 +65,16 @@ typedef struct
     /// The current state of the allocator.
     size_t allocated_fragments;
     size_t allocated_bytes;
+    /// Event counters.
+    uint64_t count_alloc;
+    uint64_t count_free;
 } instrumented_allocator_t;
 
 static inline void* instrumented_allocator_alloc(void* const user_reference, const size_t size)
 {
     instrumented_allocator_t* const self   = (instrumented_allocator_t*)user_reference;
     void*                           result = NULL;
+    self->count_alloc++;
     if ((size > 0U) &&                                           //
         ((self->allocated_bytes + size) <= self->limit_bytes) && //
         ((self->allocated_fragments + 1U) <= self->limit_fragments)) {
@@ -100,6 +105,7 @@ static inline void* instrumented_allocator_alloc(void* const user_reference, con
 static inline void instrumented_allocator_free(void* const user_reference, const size_t size, void* const pointer)
 {
     instrumented_allocator_t* const self = (instrumented_allocator_t*)user_reference;
+    self->count_free++;
     if (pointer != NULL) {
         uint_least8_t* p         = ((uint_least8_t*)pointer) - INSTRUMENTED_ALLOCATOR_CANARY_SIZE;
         void* const    origin    = p;
@@ -136,6 +142,8 @@ static inline void instrumented_allocator_new(instrumented_allocator_t* const se
     self->limit_bytes         = SIZE_MAX;
     self->allocated_fragments = 0U;
     self->allocated_bytes     = 0U;
+    self->count_alloc         = 0U;
+    self->count_free          = 0U;
 }
 
 static inline udpard_mem_resource_t instrumented_allocator_make_resource(const instrumented_allocator_t* const self)
@@ -164,3 +172,5 @@ static inline void seed_prng(void)
 #ifdef __cplusplus
 }
 #endif
+
+// NOLINTEND(*DeprecatedOrUnsafeBufferHandling,*err34-c)

tests/src/test_helpers.c

@@ -10,52 +10,74 @@ static void test_instrumented_allocator(void)
     instrumented_allocator_new(&al);
     TEST_ASSERT_EQUAL_size_t(0, al.allocated_fragments);
     TEST_ASSERT_EQUAL_size_t(SIZE_MAX, al.limit_bytes);
+    TEST_ASSERT_EQUAL_UINT64(0, al.count_alloc);
+    TEST_ASSERT_EQUAL_UINT64(0, al.count_free);
 
     const udpard_mem_resource_t resource = instrumented_allocator_make_resource(&al);
 
     void* a = resource.alloc(resource.user, 123);
     TEST_ASSERT_EQUAL_size_t(1, al.allocated_fragments);
     TEST_ASSERT_EQUAL_size_t(123, al.allocated_bytes);
+    TEST_ASSERT_EQUAL_UINT64(1, al.count_alloc);
+    TEST_ASSERT_EQUAL_UINT64(0, al.count_free);
 
     void* b = resource.alloc(resource.user, 456);
     TEST_ASSERT_EQUAL_size_t(2, al.allocated_fragments);
     TEST_ASSERT_EQUAL_size_t(579, al.allocated_bytes);
+    TEST_ASSERT_EQUAL_UINT64(2, al.count_alloc);
+    TEST_ASSERT_EQUAL_UINT64(0, al.count_free);
 
     al.limit_bytes     = 600;
     al.limit_fragments = 2;
 
     TEST_ASSERT_EQUAL_PTR(NULL, resource.alloc(resource.user, 100));
     TEST_ASSERT_EQUAL_size_t(2, al.allocated_fragments);
     TEST_ASSERT_EQUAL_size_t(579, al.allocated_bytes);
+    TEST_ASSERT_EQUAL_UINT64(3, al.count_alloc);
+    TEST_ASSERT_EQUAL_UINT64(0, al.count_free);
 
     TEST_ASSERT_EQUAL_PTR(NULL, resource.alloc(resource.user, 21));
     TEST_ASSERT_EQUAL_size_t(2, al.allocated_fragments);
     TEST_ASSERT_EQUAL_size_t(579, al.allocated_bytes);
+    TEST_ASSERT_EQUAL_UINT64(4, al.count_alloc);
+    TEST_ASSERT_EQUAL_UINT64(0, al.count_free);
     al.limit_fragments = 4;
 
     void* c = resource.alloc(resource.user, 21);
     TEST_ASSERT_EQUAL_size_t(3, al.allocated_fragments);
     TEST_ASSERT_EQUAL_size_t(600, al.allocated_bytes);
+    TEST_ASSERT_EQUAL_UINT64(5, al.count_alloc);
+    TEST_ASSERT_EQUAL_UINT64(0, al.count_free);
 
     resource.free(resource.user, 123, a);
     TEST_ASSERT_EQUAL_size_t(2, al.allocated_fragments);
     TEST_ASSERT_EQUAL_size_t(477, al.allocated_bytes);
+    TEST_ASSERT_EQUAL_UINT64(5, al.count_alloc);
+    TEST_ASSERT_EQUAL_UINT64(1, al.count_free);
 
     void* d = resource.alloc(resource.user, 100);
     TEST_ASSERT_EQUAL_size_t(3, al.allocated_fragments);
     TEST_ASSERT_EQUAL_size_t(577, al.allocated_bytes);
+    TEST_ASSERT_EQUAL_UINT64(6, al.count_alloc);
+    TEST_ASSERT_EQUAL_UINT64(1, al.count_free);
 
     resource.free(resource.user, 21, c);
     TEST_ASSERT_EQUAL_size_t(2, al.allocated_fragments);
     TEST_ASSERT_EQUAL_size_t(556, al.allocated_bytes);
+    TEST_ASSERT_EQUAL_UINT64(6, al.count_alloc);
+    TEST_ASSERT_EQUAL_UINT64(2, al.count_free);
 
     resource.free(resource.user, 100, d);
     TEST_ASSERT_EQUAL_size_t(1, al.allocated_fragments);
     TEST_ASSERT_EQUAL_size_t(456, al.allocated_bytes);
+    TEST_ASSERT_EQUAL_UINT64(6, al.count_alloc);
+    TEST_ASSERT_EQUAL_UINT64(3, al.count_free);
 
     resource.free(resource.user, 456, b);
     TEST_ASSERT_EQUAL_size_t(0, al.allocated_fragments);
     TEST_ASSERT_EQUAL_size_t(0, al.allocated_bytes);
+    TEST_ASSERT_EQUAL_UINT64(6, al.count_alloc);
+    TEST_ASSERT_EQUAL_UINT64(4, al.count_free);
 }
 
 void setUp(void) {}

tests/src/test_intrusive_rx.c

@@ -4,8 +4,38 @@
 /// SPDX-License-Identifier: MIT
 
 #include <udpard.c> // NOLINT(bugprone-suspicious-include)
+#include "helpers.h"
 #include <unity.h>
 
+typedef struct fragment_tree_match_item_t
+{
+    size_t      offset;
+    const char* data; ///< A null-terminated string; NULL at the end.
+} fragment_tree_match_item_t;
+
+static bool fragment_tree_match(udpard_fragment_t* const head, const fragment_tree_match_item_t items[])
+{
+    if (head == NULL) {
+        return (items[0].data == NULL);
+    }
+    const bool match = (head->offset == items[0].offset) &&
+                       (strlen((const char*)head->view.data) == strlen(items[0].data)) &&
+                       (memcmp(head->view.data, items[0].data, head->view.size) == 0);
+    return match && fragment_tree_match((udpard_fragment_t*)cavl2_next_greater(&head->index_offset), &items[1]);
+}
+
+static void test_rx_fragment_tree_update_a(void)
+{
+    instrumented_allocator_t alloc_frag = { 0 };
+    instrumented_allocator_new(&alloc_frag);
+    const udpard_mem_resource_t mem_frag = instrumented_allocator_make_resource(&alloc_frag);
+
+    instrumented_allocator_t alloc_payload = { 0 };
+    instrumented_allocator_new(&alloc_payload);
+    const udpard_mem_resource_t mem_payload = instrumented_allocator_make_resource(&alloc_payload);
+    const udpard_mem_deleter_t  del_payload = instrumented_allocator_make_deleter(&alloc_payload);
+}
+
 static void test_rx_transfer_id_forward_distance(void)
 {
     // Test 1: Same value (distance is 0)
@@ -288,6 +318,7 @@ void tearDown(void) {}
 int main(void)
 {
     UNITY_BEGIN();
+    RUN_TEST(test_rx_fragment_tree_update_a);
     RUN_TEST(test_rx_transfer_id_forward_distance);
     RUN_TEST(test_rx_transfer_id_window_slide);
     RUN_TEST(test_rx_transfer_id_window_manip);