pass ejection by pointer

Author: pavel-kirienko

libudpard/udpard.c

@@ -1251,25 +1251,23 @@ static void tx_eject_pending_frames(udpard_tx_t* const self, const udpard_us_t n
         const tx_frame_t* const frame        = tr->cursor[ifindex];
         tx_frame_t* const       frame_next   = frame->next;
         const bool              last_attempt = !cavl2_is_inserted(self->index_staged, &tr->index_staged);
-        const bool              last_frame  = frame_next == NULL; // if not last attempt we will have to rewind to head.
-        const udpard_tx_ejection_t ejection = {
-            .now         = now,
-            .deadline    = tr->deadline,
-            .iface_index = ifindex,
-            .dscp        = self->dscp_value_per_priority[tr->priority],
-            .destination = tr->destination[ifindex],
-            .datagram    = tx_frame_view(frame),
-            .user        = tr->user,
-        };
-        if (!self->vtable->eject(self, ejection)) { // The easy case -- no progress was made at this time;
-            break;                                  // don't change anything, just try again later as-is
+        const bool              last_frame = frame_next == NULL; // if not last attempt we will have to rewind to head.
+        udpard_tx_ejection_t    ejection   = { .now         = now,
+                                               .deadline    = tr->deadline,
+                                               .iface_index = ifindex,
+                                               .dscp        = self->dscp_value_per_priority[tr->priority],
+                                               .destination = tr->destination[ifindex],
+                                               .datagram    = tx_frame_view(frame),
+                                               .user        = tr->user };
+        if (!self->vtable->eject(self, &ejection)) { // The easy case -- no progress was made at this time;
+            break;                                   // don't change anything, just try again later as-is
         }
 
         // Frame ejected successfully. Update the transfer state to get ready for the next frame.
         if (last_attempt) { // no need to keep frames that we will no longer use; free early to reduce pressure
             UDPARD_ASSERT(tr->head[ifindex] == tr->cursor[ifindex]);
             tr->head[ifindex] = frame_next;
-            udpard_tx_refcount_dec(ejection.datagram);
+            udpard_tx_refcount_dec(tx_frame_view(frame));
         }
         tr->cursor[ifindex] = frame_next;
 

libudpard/udpard.h

@@ -365,6 +365,7 @@ typedef struct udpard_tx_ejection_t
 
     /// Specifies when the frame should be considered expired and dropped if not yet transmitted by then;
     /// it is optional to use depending on the implementation of the NIC driver (most traditional drivers ignore it).
+    /// The library guarantees that now >= deadline at the time of ejection -- expired frames are purged beforehand.
     udpard_us_t deadline;
 
     uint_fast8_t      iface_index; ///< The interface index on which the datagram is to be transmitted.
@@ -385,7 +386,7 @@ typedef struct udpard_tx_vtable_t
 {
     /// Invoked from udpard_tx_poll() et al to push outgoing UDP datagrams into the socket/NIC driver.
     /// The callback must not mutate the TX pipeline (no udpard_tx_push/cancel/free).
-    bool (*eject)(udpard_tx_t*, udpard_tx_ejection_t);
+    bool (*eject)(udpard_tx_t*, udpard_tx_ejection_t*);
 } udpard_tx_vtable_t;
 
 /// The application must create a single instance of this struct to manage the TX pipeline.

tests/src/test_e2e_api.cpp

@@ -42,16 +42,16 @@ void tx_refcount_free(void* const user, const size_t size, void* const payload)
     udpard_tx_refcount_dec(udpard_bytes_t{ .size = size, .data = payload });
 }
 
-bool capture_tx_frame(udpard_tx_t* const tx, const udpard_tx_ejection_t ejection)
+bool capture_tx_frame(udpard_tx_t* const tx, udpard_tx_ejection_t* const ejection)
 {
     auto* frames = static_cast<std::vector<CapturedFrame>*>(tx->user);
     if (frames == nullptr) {
         return false;
     }
-    udpard_tx_refcount_inc(ejection.datagram);
-    void* const data = const_cast<void*>(ejection.datagram.data); // NOLINT(cppcoreguidelines-pro-type-const-cast)
-    frames->push_back(CapturedFrame{ .datagram    = { .size = ejection.datagram.size, .data = data },
-                                     .iface_index = ejection.iface_index });
+    udpard_tx_refcount_inc(ejection->datagram);
+    void* const data = const_cast<void*>(ejection->datagram.data); // NOLINT(cppcoreguidelines-pro-type-const-cast)
+    frames->push_back(CapturedFrame{ .datagram    = { .size = ejection->datagram.size, .data = data },
+                                     .iface_index = ejection->iface_index });
     return true;
 }
 

tests/src/test_e2e_edge.cpp

@@ -38,16 +38,16 @@ void tx_refcount_free(void* const user, const size_t size, void* const payload)
     udpard_tx_refcount_dec(udpard_bytes_t{ .size = size, .data = payload });
 }
 
-bool capture_tx_frame(udpard_tx_t* const tx, const udpard_tx_ejection_t ejection)
+bool capture_tx_frame(udpard_tx_t* const tx, udpard_tx_ejection_t* const ejection)
 {
     auto* frames = static_cast<std::vector<CapturedFrame>*>(tx->user);
     if (frames == nullptr) {
         return false;
     }
-    udpard_tx_refcount_inc(ejection.datagram);
-    void* const data = const_cast<void*>(ejection.datagram.data); // NOLINT(cppcoreguidelines-pro-type-const-cast)
-    frames->push_back(CapturedFrame{ .datagram    = { .size = ejection.datagram.size, .data = data },
-                                     .iface_index = ejection.iface_index });
+    udpard_tx_refcount_inc(ejection->datagram);
+    void* const data = const_cast<void*>(ejection->datagram.data); // NOLINT(cppcoreguidelines-pro-type-const-cast)
+    frames->push_back(CapturedFrame{ .datagram    = { .size = ejection->datagram.size, .data = data },
+                                     .iface_index = ejection->iface_index });
     return true;
 }
 

tests/src/test_e2e_random.cpp

@@ -90,16 +90,16 @@ void tx_refcount_free(void* const user, const size_t size, void* const payload)
     udpard_tx_refcount_dec(udpard_bytes_t{ .size = size, .data = payload });
 }
 
-bool capture_tx_frame(udpard_tx_t* const tx, const udpard_tx_ejection_t ejection)
+bool capture_tx_frame(udpard_tx_t* const tx, udpard_tx_ejection_t* const ejection)
 {
     auto* frames = static_cast<std::vector<CapturedFrame>*>(tx->user);
     if (frames == nullptr) {
         return false;
     }
-    udpard_tx_refcount_inc(ejection.datagram);
-    void* const data = const_cast<void*>(ejection.datagram.data); // NOLINT(cppcoreguidelines-pro-type-const-cast)
-    frames->push_back(CapturedFrame{ .datagram    = { .size = ejection.datagram.size, .data = data },
-                                     .iface_index = ejection.iface_index });
+    udpard_tx_refcount_inc(ejection->datagram);
+    void* const data = const_cast<void*>(ejection->datagram.data); // NOLINT(cppcoreguidelines-pro-type-const-cast)
+    frames->push_back(CapturedFrame{ .datagram    = { .size = ejection->datagram.size, .data = data },
+                                     .iface_index = ejection->iface_index });
     return true;
 }
 

tests/src/test_e2e_responses.cpp

@@ -28,16 +28,16 @@ void tx_refcount_free(void* const user, const size_t size, void* const payload)
     udpard_tx_refcount_dec(udpard_bytes_t{ .size = size, .data = payload });
 }
 
-bool capture_tx_frame(udpard_tx_t* const tx, const udpard_tx_ejection_t ejection)
+bool capture_tx_frame(udpard_tx_t* const tx, udpard_tx_ejection_t* const ejection)
 {
     auto* frames = static_cast<std::vector<CapturedFrame>*>(tx->user);
     if (frames == nullptr) {
         return false;
     }
-    udpard_tx_refcount_inc(ejection.datagram);
-    void* const data = const_cast<void*>(ejection.datagram.data); // NOLINT
-    frames->push_back(CapturedFrame{ .datagram    = { .size = ejection.datagram.size, .data = data },
-                                     .iface_index = ejection.iface_index });
+    udpard_tx_refcount_inc(ejection->datagram);
+    void* const data = const_cast<void*>(ejection->datagram.data); // NOLINT
+    frames->push_back(CapturedFrame{ .datagram    = { .size = ejection->datagram.size, .data = data },
+                                     .iface_index = ejection->iface_index });
     return true;
 }
 

tests/src/test_integration_sockets.cpp

@@ -99,17 +99,17 @@ struct CapturedFrame
 // Callbacks
 // =====================================================================================================================
 
-bool capture_frame(udpard_tx_t* const tx, const udpard_tx_ejection_t ejection)
+bool capture_frame(udpard_tx_t* const tx, udpard_tx_ejection_t* const ejection)
 {
     auto* frames = static_cast<std::vector<CapturedFrame>*>(tx->user);
     if (frames == nullptr) {
         return false;
     }
 
     CapturedFrame frame{};
-    frame.data.assign(static_cast<const uint8_t*>(ejection.datagram.data),
-                      static_cast<const uint8_t*>(ejection.datagram.data) + ejection.datagram.size);
-    frame.iface_index = ejection.iface_index;
+    frame.data.assign(static_cast<const uint8_t*>(ejection->datagram.data),
+                      static_cast<const uint8_t*>(ejection->datagram.data) + ejection->datagram.size);
+    frame.iface_index = ejection->iface_index;
     frames->push_back(frame);
 
     return true;

tests/src/test_intrusive_guards.c

@@ -32,7 +32,7 @@ static udpard_mem_resource_t make_mem(void* const tag)
     return out;
 }
 
-static bool eject_stub(udpard_tx_t* const tx, const udpard_tx_ejection_t ejection)
+static bool eject_stub(udpard_tx_t* const tx, udpard_tx_ejection_t* const ejection)
 {
     (void)tx;
     (void)ejection;

tests/src/test_intrusive_rx.c

@@ -1603,38 +1603,38 @@ typedef struct
     size_t                   captured_count;
 } tx_fixture_t;
 
-static bool tx_capture_ack(udpard_tx_t* const tx, const udpard_tx_ejection_t ejection)
+static bool tx_capture_ack(udpard_tx_t* const tx, udpard_tx_ejection_t* const ejection)
 {
     tx_fixture_t* const self = (tx_fixture_t*)tx->user;
     if ((self == NULL) || (self->captured_count >= (sizeof(self->captured) / sizeof(self->captured[0])))) {
         return false;
     }
-    udpard_tx_refcount_inc(ejection.datagram);
+    udpard_tx_refcount_inc(ejection->datagram);
     meta_t         meta         = { 0 };
     uint32_t       frame_index  = 0;
     uint32_t       frame_offset = 0;
     uint32_t       prefix_crc   = 0;
     udpard_bytes_t payload      = { 0 };
-    const bool     ok =
-      header_deserialize((udpard_bytes_mut_t){ .size = ejection.datagram.size, .data = (void*)ejection.datagram.data },
-                         &meta,
-                         &frame_index,
-                         &frame_offset,
-                         &prefix_crc,
-                         &payload);
+    const bool     ok           = header_deserialize(
+      (udpard_bytes_mut_t){ .size = ejection->datagram.size, .data = (void*)ejection->datagram.data },
+      &meta,
+      &frame_index,
+      &frame_offset,
+      &prefix_crc,
+      &payload);
     if (ok && (frame_index == 0U) && (frame_offset == 0U) && (payload.size == UDPARD_P2P_HEADER_BYTES)) {
         const byte_t* const pl = (const byte_t*)payload.data;
         if (pl[0] == P2P_KIND_ACK) {
             ack_tx_info_t* const info = &self->captured[self->captured_count++];
             info->priority            = meta.priority;
             info->transfer_id         = meta.transfer_id;
             info->topic_hash          = meta.topic_hash;
-            info->destination         = ejection.destination;
+            info->destination         = ejection->destination;
             (void)deserialize_u64(pl + 8U, &info->acked_topic_hash);
             (void)deserialize_u64(pl + 16U, &info->acked_transfer_id);
         }
     }
-    udpard_tx_refcount_dec(ejection.datagram);
+    udpard_tx_refcount_dec(ejection->datagram);
     return true;
 }
 

tests/src/test_intrusive_tx.c

@@ -33,7 +33,7 @@ static void noop_free(void* const user, const size_t size, void* const pointer)
 }
 
 // Ejects with a configurable outcome.
-static bool eject_with_flag(udpard_tx_t* const tx, const udpard_tx_ejection_t ejection)
+static bool eject_with_flag(udpard_tx_t* const tx, udpard_tx_ejection_t* const ejection)
 {
     (void)ejection;
     eject_state_t* const st = (eject_state_t*)tx->user;
@@ -45,11 +45,11 @@ static bool eject_with_flag(udpard_tx_t* const tx, const udpard_tx_ejection_t ej
 }
 
 // Records ejection timestamps for later inspection.
-static bool eject_with_log(udpard_tx_t* const tx, const udpard_tx_ejection_t ejection)
+static bool eject_with_log(udpard_tx_t* const tx, udpard_tx_ejection_t* const ejection)
 {
     eject_log_t* const st = (eject_log_t*)tx->user;
     if ((st != NULL) && (st->count < (sizeof(st->when) / sizeof(st->when[0])))) {
-        st->when[st->count++] = ejection.now;
+        st->when[st->count++] = ejection->now;
     }
     return true;
 }