st20 tests pass

Signed-off-by: Kasiewicz, Marek <marek.kasiewicz@intel.com>

Author: Sakoram

lib/src/meson.build

@@ -20,9 +20,6 @@ sources = files(
   'mt_instance.c',
   'mt_log.c',
   'mt_pcap.c',
-  'mt_session.c',
-  'mt_session_buffer.c',
-  'mt_session_event.c',
 )
 
 if is_windows
@@ -36,4 +33,5 @@ subdir('datapath')
 subdir('dev')
 subdir('st2110')
 subdir('deprecated/udp')
+subdir('new_api')
 

lib/src/new_api/meson.build

@@ -0,0 +1,13 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# Copyright 2022 Intel Corporation
+
+sources += files(
+  'mt_session.c',
+  'mt_session.h',
+  'mt_session_buffer.c',
+  'mt_session_event.c',
+  'mt_session_video_common.c',
+  'mt_session_video_common.h',
+  'mt_session_video_tx.c',
+  'mt_session_video_rx.c',
+)

lib/src/mt_session.c lib/src/new_api/mt_session.clib/src/mt_session.c renamed to lib/src/new_api/mt_session.c

@@ -14,8 +14,8 @@
 
 #include <errno.h>
 
-#include "mt_log.h"
-#include "mt_mem.h"
+#include "../mt_log.h"
+#include "../mt_mem.h"
 
 /*************************************************************************
  * Session Allocation / Deallocation
@@ -32,11 +32,9 @@ struct mtl_session_impl* mtl_session_alloc(struct mtl_main_impl* impl, int socke
 
   s->parent = impl;
   s->socket_id = socket_id;
-  s->state = MTL_SESSION_STATE_CREATED;
-  s->stopped = false;
+  __atomic_store_n(&s->state, MTL_SESSION_STATE_CREATED, __ATOMIC_RELAXED);
+  __atomic_store_n(&s->stopped, 0, __ATOMIC_RELAXED);
   s->event_fd = -1;
-  rte_spinlock_init(&s->state_lock);
-  rte_spinlock_init(&s->stats_lock);
 
   return s;
 }
@@ -164,17 +162,12 @@ int mtl_session_start(mtl_session_t* session) {
     return -EINVAL;
   }
 
-  rte_spinlock_lock(&s->state_lock);
-
-  if (s->state == MTL_SESSION_STATE_STARTED) {
-    rte_spinlock_unlock(&s->state_lock);
+  if (__atomic_load_n(&s->state, __ATOMIC_ACQUIRE) == MTL_SESSION_STATE_STARTED) {
     return 0; /* Already started */
   }
 
   mtl_session_clear_stopped(s);
 
-  rte_spinlock_unlock(&s->state_lock);
-
   int ret = 0;
   if (s->vt && s->vt->start) {
     ret = s->vt->start(s);
@@ -408,10 +401,17 @@ int mtl_session_stats_get(mtl_session_t* session, mtl_session_stats_t* stats) {
     return s->vt->stats_get(s, stats);
   }
 
-  /* Default: return cached stats */
-  rte_spinlock_lock(&s->stats_lock);
-  *stats = s->stats;
-  rte_spinlock_unlock(&s->stats_lock);
+  /* Default: return cached stats (atomic reads, relaxed ordering) */
+  stats->buffers_processed =
+      __atomic_load_n(&s->stats.buffers_processed, __ATOMIC_RELAXED);
+  stats->bytes_processed =
+      __atomic_load_n(&s->stats.bytes_processed, __ATOMIC_RELAXED);
+  stats->buffers_dropped =
+      __atomic_load_n(&s->stats.buffers_dropped, __ATOMIC_RELAXED);
+  stats->epochs_missed =
+      __atomic_load_n(&s->stats.epochs_missed, __ATOMIC_RELAXED);
+  stats->buffers_free = 0;
+  stats->buffers_in_use = 0;
   return 0;
 }
 
@@ -426,9 +426,10 @@ int mtl_session_stats_reset(mtl_session_t* session) {
     return s->vt->stats_reset(s);
   }
 
-  rte_spinlock_lock(&s->stats_lock);
-  memset(&s->stats, 0, sizeof(s->stats));
-  rte_spinlock_unlock(&s->stats_lock);
+  __atomic_store_n(&s->stats.buffers_processed, 0, __ATOMIC_RELAXED);
+  __atomic_store_n(&s->stats.bytes_processed, 0, __ATOMIC_RELAXED);
+  __atomic_store_n(&s->stats.buffers_dropped, 0, __ATOMIC_RELAXED);
+  __atomic_store_n(&s->stats.epochs_missed, 0, __ATOMIC_RELAXED);
   return 0;
 }
 

lib/src/mt_session.h lib/src/new_api/mt_session.hlib/src/mt_session.h renamed to lib/src/new_api/mt_session.h

@@ -24,12 +24,11 @@
 #include "mtl_session_api.h"
 
 /* Internal MTL headers */
-#include "mt_main.h"
-#include "st2110/st_header.h"
+#include "../mt_main.h"
+#include "../st2110/st_header.h"
 
 #include <rte_atomic.h>
 #include <rte_ring.h>
-#include <rte_spinlock.h>
 
 #if defined(__cplusplus)
 extern "C" {
@@ -159,12 +158,23 @@ struct mtl_session_impl {
   int idx;                      /**< Session index (for logging) */
   int socket_id;                /**< NUMA socket */
 
-  /* State */
+  /*
+   * Session state — accessed with C11 __atomic builtins.
+   * No lock needed; state transitions pair with the stopped flag.
+   */
   mtl_session_state_t state;
-  rte_spinlock_t state_lock;
 
-  /* Set by stop(), checked by buffer_get/event_poll to return -EAGAIN */
-  volatile bool stopped;
+  /**
+   * Atomic stopped flag — the primary cross-thread signal.
+   * Set by stop(), checked by buffer_get/event_poll to return -EAGAIN.
+   *
+   * Memory ordering rationale:
+   *   store (__ATOMIC_RELEASE): all prior stores (state, data) are visible
+   *                             before stopped is observed by other threads.
+   *   load  (__ATOMIC_ACQUIRE): subsequent reads in the checking thread see
+   *                             all stores that happened before the set.
+   */
+  int stopped;
 
   /* Configuration (copied from create) */
   char name[ST_MAX_NAME_LEN];
@@ -194,6 +204,13 @@ struct mtl_session_impl {
    * Frame buffer management.
    * For library-owned mode, we manage mtl_buffer_impl wrappers.
    * The actual frame memory is in inner->st20_frames (st_frame_trans array).
+   *
+   * Thread safety: completely lock-free.
+   * - TX: atomic CAS on per-frame state (enum tx_frame_state) provides
+   *   mutual exclusion — only the CAS winner owns a given frame.
+   * - RX: multi-consumer rte_ring ensures safe concurrent dequeue.
+   * Buffer wrapper assignment is race-free because each frame_idx maps
+   * 1:1 to a unique buffer_impl slot (buffer_count >= frame_count).
    */
   uint32_t buffer_count;
   struct mtl_buffer_impl* buffers; /**< Buffer wrapper pool */
@@ -202,9 +219,14 @@ struct mtl_session_impl {
   struct rte_ring* event_ring; /**< Pending events */
   int event_fd;                /**< For epoll integration */
 
-  /* Statistics - aggregated view of inner session stats */
+  /*
+   * Statistics — aggregated view of inner session stats.
+   * Thread safety: individual counter fields are accessed with __atomic builtins.
+   * Increments use __ATOMIC_RELAXED (no ordering needed for counters).
+   * Reads/resets also use __ATOMIC_RELAXED (approximate snapshot is fine).
+   * No lock needed — each field is independently atomic.
+   */
   mtl_session_stats_t stats;
-  rte_spinlock_t stats_lock;
 
   /* Callbacks (optional, for low-latency notification) */
   int (*notify_buffer_ready)(void* priv);
@@ -353,27 +375,31 @@ void mtl_session_put_frame_trans(struct st_frame_trans* ft);
  *************************************************************************/
 
 /**
- * Check if session is stopped.
+ * Check if session is stopped (thread-safe, acquire semantics).
  * Call this at the start of any blocking operation.
  */
 static inline bool mtl_session_check_stopped(struct mtl_session_impl* s) {
-  return s->stopped;
+  return __atomic_load_n(&s->stopped, __ATOMIC_ACQUIRE) != 0;
 }
 
 /**
- * Set stopped flag. Called by mtl_session_stop().
+ * Set stopped flag (thread-safe). Called by mtl_session_stop().
+ * Uses release semantics so all prior stores are visible.
  */
 static inline void mtl_session_set_stopped(struct mtl_session_impl* s) {
-  s->stopped = true;
-  s->state = MTL_SESSION_STATE_STOPPED;
+  /* Store state first (relaxed), then stopped with release.
+   * The release on stopped ensures that the state store is visible
+   * to any thread that observes stopped == 1 via acquire load. */
+  __atomic_store_n(&s->state, MTL_SESSION_STATE_STOPPED, __ATOMIC_RELAXED);
+  __atomic_store_n(&s->stopped, 1, __ATOMIC_RELEASE);
 }
 
 /**
- * Clear stopped flag. Called by mtl_session_start().
+ * Clear stopped flag (thread-safe). Called by mtl_session_start().
  */
 static inline void mtl_session_clear_stopped(struct mtl_session_impl* s) {
-  s->stopped = false;
-  s->state = MTL_SESSION_STATE_STARTED;
+  __atomic_store_n(&s->state, MTL_SESSION_STATE_STARTED, __ATOMIC_RELAXED);
+  __atomic_store_n(&s->stopped, 0, __ATOMIC_RELEASE);
 }
 
 /*************************************************************************

lib/src/mt_session_buffer.c lib/src/new_api/mt_session_buffer.clib/src/mt_session_buffer.c renamed to lib/src/new_api/mt_session_buffer.c

@@ -13,8 +13,8 @@
 
 #include <errno.h>
 
-#include "mt_log.h"
-#include "mt_mem.h"
+#include "../mt_log.h"
+#include "../mt_mem.h"
 
 /*************************************************************************
  * Buffer Pool Management

lib/src/mt_session_event.c lib/src/new_api/mt_session_event.clib/src/mt_session_event.c renamed to lib/src/new_api/mt_session_event.c

@@ -15,8 +15,8 @@
 #include <sys/eventfd.h>
 #include <unistd.h>
 
-#include "mt_log.h"
-#include "mt_mem.h"
+#include "../mt_log.h"
+#include "../mt_mem.h"
 
 #define MTL_EVENT_RING_SIZE 64 /* Must be power of 2 */
 
@@ -30,7 +30,7 @@ int mtl_session_events_init(struct mtl_session_impl* s) {
   snprintf(ring_name, sizeof(ring_name), "mtl_ev_%p", s);
 
   s->event_ring =
-      rte_ring_create(ring_name, MTL_EVENT_RING_SIZE, s->socket_id, RING_F_SC_DEQ);
+      rte_ring_create(ring_name, MTL_EVENT_RING_SIZE, s->socket_id, 0);
   if (!s->event_ring) {
     err("%s(%s), failed to create event ring\n", __func__, s->name);
     return -ENOMEM;