cleanup

Author: pavel-kirienko

libudpard/udpard.c

@@ -588,11 +588,10 @@ typedef struct tx_transfer_t
     /// The transmission iface set is indicated by which head[] entries are non-NULL.
     tx_frame_t* head[UDPARD_IFACE_COUNT_MAX];
     tx_frame_t* cursor[UDPARD_IFACE_COUNT_MAX];
-    uint32_t    epoch : 8; ///< Does not overflow due to exponential backoff; e.g. 1us with epoch=48 => 9 years.
 
     /// Constant transfer properties supplied by the client.
-    uint32_t          priority : 3;
     void*             user;
+    udpard_prio_t     priority;
     udpard_us_t       deadline;
     udpard_udpip_ep_t endpoints[UDPARD_IFACE_COUNT_MAX];
 } tx_transfer_t;
@@ -786,13 +785,14 @@ static bool tx_push(udpard_tx_t* const             tx,
                     const udpard_us_t              now,
                     const udpard_us_t              deadline,
                     const meta_t                   meta,
-                    const uint16_t                 iface_bitmap,
                     const udpard_udpip_ep_t        endpoints[UDPARD_IFACE_COUNT_MAX],
                     const udpard_bytes_scattered_t payload,
                     void* const                    user)
 {
     UDPARD_ASSERT(now <= deadline);
     UDPARD_ASSERT(tx != NULL);
+
+    const uint16_t iface_bitmap = valid_ep_bitmap(endpoints);
     UDPARD_ASSERT((iface_bitmap & UDPARD_IFACE_BITMAP_ALL) != 0);
     UDPARD_ASSERT((iface_bitmap & UDPARD_IFACE_BITMAP_ALL) == iface_bitmap);
 
@@ -806,10 +806,9 @@ static bool tx_push(udpard_tx_t* const             tx,
         return false;
     }
     mem_zero(sizeof(*tr), tr);
-    tr->epoch    = 0;
-    tr->priority = ((byte_t)meta.priority) & UDPARD_PRIORITY_MASK;
-    tr->deadline = deadline;
     tr->user     = user;
+    tr->priority = meta.priority;
+    tr->deadline = deadline;
     for (size_t i = 0; i < UDPARD_IFACE_COUNT_MAX; i++) {
         tr->head[i] = tr->cursor[i] = NULL;
         tr->endpoints[i]            = endpoints[i];
@@ -907,7 +906,6 @@ bool udpard_tx_new(udpard_tx_t* const              self,
         self->p2p_transfer_id       = p2p_transfer_id_seed + local_uid; // extra entropy
         self->enqueued_frames_limit = enqueued_frames_limit;
         self->enqueued_frames_count = 0;
-        self->next_seq_no           = 0;
         self->memory                = memory;
         self->index_deadline        = NULL;
         self->agewise               = (udpard_list_t){ NULL, NULL };
@@ -929,18 +927,27 @@ bool udpard_tx_push(udpard_tx_t* const             self,
                     const uint16_t                 iface_bitmap,
                     const udpard_prio_t            priority,
                     const uint64_t                 transfer_id,
+                    const udpard_udpip_ep_t        endpoint,
                     const udpard_bytes_scattered_t payload,
                     void* const                    user)
 {
     bool ok = (self != NULL) && (deadline >= now) && (now >= 0) && (self->local_uid != 0) &&
               ((iface_bitmap & UDPARD_IFACE_BITMAP_ALL) != 0) && (priority < UDPARD_PRIORITY_COUNT) &&
-              ((payload.bytes.data != NULL) || (payload.bytes.size == 0U));
+              udpard_is_valid_endpoint(endpoint) && ((payload.bytes.data != NULL) || (payload.bytes.size == 0U));
     if (ok) {
-        const meta_t meta = { .priority              = priority,
-                              .transfer_payload_size = (uint32_t)bytes_scattered_size(payload),
-                              .transfer_id           = transfer_id,
-                              .sender_uid            = self->local_uid };
-        ok = tx_push(self, now, deadline, meta, iface_bitmap & UDPARD_IFACE_BITMAP_ALL, NULL, payload, user);
+        const meta_t meta = {
+            .priority              = priority,
+            .transfer_payload_size = (uint32_t)bytes_scattered_size(payload),
+            .transfer_id           = transfer_id,
+            .sender_uid            = self->local_uid,
+        };
+        udpard_udpip_ep_t eps[UDPARD_IFACE_COUNT_MAX] = { 0 };
+        for (size_t i = 0; i < UDPARD_IFACE_COUNT_MAX; i++) {
+            if ((iface_bitmap & (1U << i)) != 0) {
+                eps[i] = endpoint;
+            }
+        }
+        ok = tx_push(self, now, deadline, meta, eps, payload, user);
     }
     return ok;
 }
@@ -953,15 +960,17 @@ bool udpard_tx_push_p2p(udpard_tx_t* const             self,
                         const udpard_bytes_scattered_t payload,
                         void* const                    user)
 {
-    const uint16_t iface_bitmap = valid_ep_bitmap(endpoints);
-    bool ok = (self != NULL) && (deadline >= now) && (now >= 0) && (self->local_uid != 0) && (iface_bitmap != 0) &&
-              (priority < UDPARD_PRIORITY_COUNT) && ((payload.bytes.data != NULL) || (payload.bytes.size == 0U));
+    bool ok = (self != NULL) && (deadline >= now) && (now >= 0) && (self->local_uid != 0) &&
+              (valid_ep_bitmap(endpoints) != 0) && (priority < UDPARD_PRIORITY_COUNT) &&
+              ((payload.bytes.data != NULL) || (payload.bytes.size == 0U));
     if (ok) {
-        const meta_t meta = { .priority              = priority,
-                              .transfer_payload_size = (uint32_t)bytes_scattered_size(payload),
-                              .transfer_id           = self->p2p_transfer_id++,
-                              .sender_uid            = self->local_uid };
-        ok = tx_push(self, now, deadline, meta, iface_bitmap, endpoints, payload, user); // --------------
+        const meta_t meta = {
+            .priority              = priority,
+            .transfer_payload_size = (uint32_t)bytes_scattered_size(payload),
+            .transfer_id           = self->p2p_transfer_id++,
+            .sender_uid            = self->local_uid,
+        };
+        ok = tx_push(self, now, deadline, meta, endpoints, payload, user);
     }
     return ok;
 }
@@ -993,6 +1002,7 @@ static void tx_eject_pending_frames(udpard_tx_t* const self, const udpard_us_t n
         {
             udpard_tx_ejection_t ejection = { .now         = now,
                                               .deadline    = tr->deadline,
+                                              .destination = tr->endpoints[ifindex],
                                               .iface_index = ifindex,
                                               .dscp        = self->dscp_value_per_priority[tr->priority],
                                               .datagram    = tx_frame_view(frame),

libudpard/udpard.h

@@ -106,7 +106,6 @@ typedef enum udpard_prio_t
     udpard_prio_optional    = 7,
 } udpard_prio_t;
 #define UDPARD_PRIORITY_COUNT 8U
-#define UDPARD_PRIORITY_MASK  (UDPARD_PRIORITY_COUNT - 1U)
 
 typedef struct udpard_tree_t
 {
@@ -145,11 +144,6 @@ typedef struct udpard_bytes_mut_t
     void*  data;
 } udpard_bytes_mut_t;
 
-/// The size can be changed arbitrarily. This value is a compromise between copy size and footprint and utility.
-#ifndef UDPARD_USER_CONTEXT_PTR_COUNT
-#define UDPARD_USER_CONTEXT_PTR_COUNT 2
-#endif
-
 /// Zeros if invalid/unset/unavailable.
 typedef struct udpard_udpip_ep_t
 {
@@ -176,8 +170,7 @@ typedef struct udpard_remote_t
 bool udpard_is_valid_endpoint(const udpard_udpip_ep_t ep);
 
 /// Returns the destination multicast UDP/IP endpoint for the given subject-ID.
-/// The application should use this function when setting up subscription sockets or sending datagrams in
-/// udpard_tx_vtable_t::eject_subject().
+/// The application should use this function when setting up subscription sockets or sending datagrams.
 /// If the subject-ID exceeds UDPARD_IPv4_SUBJECT_ID_MAX, the excessive bits are masked out.
 /// For P2P use the unicast node address directly instead, as provided by the RX pipeline per received transfer.
 udpard_udpip_ep_t udpard_make_subject_endpoint(const uint32_t subject_id);
@@ -337,7 +330,7 @@ typedef struct udpard_tx_vtable_t
     /// Invoked from udpard_tx_poll() to push outgoing UDP datagrams into the socket/NIC driver.
     /// It is GUARANTEED that ONLY udpard_tx_poll() can invoke this function; in particular, pushing new transfers
     /// will not trigger ejection callbacks.
-    /// The callback must not mutate the TX pipeline (no udpard_tx_push/cancel/free).
+    /// The callback must not mutate the TX pipeline (no udpard_tx_push/free).
     bool (*eject)(udpard_tx_t*, udpard_tx_ejection_t*);
 } udpard_tx_vtable_t;
 
@@ -378,10 +371,6 @@ struct udpard_tx_t
     /// READ-ONLY!
     size_t enqueued_frames_count;
 
-    /// Starts at zero and increments with every enqueued transfer. Do not modify!
-    /// This is used internally as a tiebreaker in non-unique indexes.
-    uint64_t next_seq_no;
-
     udpard_tx_mem_resources_t memory;
 
     /// Error counters incremented automatically when the corresponding error condition occurs.
@@ -426,24 +415,23 @@ bool udpard_tx_new(udpard_tx_t* const              self,
 /// invalidated immediately after this function returns. When redundant interfaces are used, the library will attempt to
 /// minimize the number of copies by reusing frames across interfaces with identical MTU values and memory resources.
 ///
+/// The endpoint depends on the subject-ID and is computed using udpard_make_subject_endpoint().
+/// The endpoint must satisfy udpard_is_valid_endpoint().
+///
 /// The caller shall increment the transfer-ID counter after each successful invocation of this function per subject.
 /// The initial value shall be chosen randomly such that it is likely to be distinct per application startup
 /// (embedded systems can use noinit memory sections, hash uninitialized SRAM, use timers or ADC noise, etc).
 /// The random starting point will ensure global uniqueness across different subjects.
 /// Excess most significant bits are ignored.
 /// Related thread on random transfer-ID init: https://forum.opencyphal.org/t/improve-the-transfer-id-timeout/2375
 ///
-/// The user context value is carried through to the callbacks. It must contain enough context to allow subject-ID
-/// derivation inside udpard_tx_vtable_t::eject_subject(). For example, it may contain a pointer to the topic struct.
+/// The enqueued transfer will be emitted over all interfaces specified in the iface_bitmap.
+///
+/// The user context value is carried through to the callbacks.
 ///
 /// Returns true on success. Runtime failures increment the corresponding error counters,
 /// while invocations with invalid arguments just return zero without modifying the queue state.
 ///
-/// The enqueued transfer will be emitted over all interfaces specified in the iface_bitmap.
-/// The subject-ID is computed inside the udpard_tx_vtable::eject_subject() callback at the time of transmission.
-/// The subject-ID cannot be computed beforehand at the time of enqueuing because the topic->subject consensus protocol
-/// may find a different subject-ID allocation between the time of enqueuing and the time of (re)transmission.
-///
 /// On success, the function allocates a single transfer state instance and a number of payload fragments.
 /// The time complexity is O(p + log e), where p is the transfer payload size, and e is the number of
 /// transfers already enqueued in the transmission queue.
@@ -453,6 +441,7 @@ bool udpard_tx_push(udpard_tx_t* const             self,
                     const uint16_t                 iface_bitmap,
                     const udpard_prio_t            priority,
                     const uint64_t                 transfer_id,
+                    const udpard_udpip_ep_t        endpoint,
                     const udpard_bytes_scattered_t payload,
                     void* const                    user);