[vlc-commits] fifo: use the queue API

Rémi Denis-Courmont git at videolan.org
Mon Apr 13 13:05:20 CEST 2020


vlc | branch: master | Rémi Denis-Courmont <remi at remlab.net> | Sat Apr 11 21:39:57 2020 +0300| [165f3b55d59b876e02b368b5b677c47c143f098c] | committer: Rémi Denis-Courmont

fifo: use the queue API

> http://git.videolan.org/gitweb.cgi/vlc.git/?a=commit;h=165f3b55d59b876e02b368b5b677c47c143f098c
---

 include/vlc_block.h | 45 +++++++++++++++++--------
 src/misc/fifo.c     | 95 ++++++++++++-----------------------------------------
 2 files changed, 53 insertions(+), 87 deletions(-)

diff --git a/include/vlc_block.h b/include/vlc_block.h
index 2c98499db0..b57b4698cb 100644
--- a/include/vlc_block.h
+++ b/include/vlc_block.h
@@ -438,6 +438,8 @@ static inline block_t *block_ChainGather( block_t *p_list )
  * @{
  */
 
+#include <vlc_queue.h>
+
 /**
  * Creates a thread-safe FIFO queue of blocks.
  *
@@ -480,6 +482,11 @@ VLC_API block_t *block_FifoShow(block_fifo_t *);
 
 typedef struct block_fifo_t vlc_fifo_t;
 
+static inline vlc_queue_t *vlc_fifo_queue(const vlc_fifo_t *fifo)
+{
+    return (vlc_queue_t *)fifo;
+}
+
 /**
  * Locks a block FIFO.
  *
@@ -493,7 +500,10 @@ typedef struct block_fifo_t vlc_fifo_t;
  * @warning Recursively locking a single FIFO is undefined. Locking more than
  * one FIFO at a time may lead to lock inversion; mind the locking order.
  */
-VLC_API void vlc_fifo_Lock(vlc_fifo_t *);
+static inline void vlc_fifo_Lock(vlc_fifo_t *fifo)
+{
+    vlc_queue_Lock(vlc_fifo_queue(fifo));
+}
 
 /**
  * Unlocks a block FIFO.
@@ -503,7 +513,10 @@ VLC_API void vlc_fifo_Lock(vlc_fifo_t *);
  *
  * @note This function is not a cancellation point.
  */
-VLC_API void vlc_fifo_Unlock(vlc_fifo_t *);
+static inline void vlc_fifo_Unlock(vlc_fifo_t *fifo)
+{
+    vlc_queue_Unlock(vlc_fifo_queue(fifo));
+}
 
 /**
  * Wakes up one thread waiting on the FIFO, if any.
@@ -513,7 +526,10 @@ VLC_API void vlc_fifo_Unlock(vlc_fifo_t *);
  * @warning For race-free operations, the FIFO should be locked by the calling
  * thread. The function can be called on a unlocked FIFO however.
  */
-VLC_API void vlc_fifo_Signal(vlc_fifo_t *);
+static inline void vlc_fifo_Signal(vlc_fifo_t *fifo)
+{
+    vlc_queue_Signal(vlc_fifo_queue(fifo));
+}
 
 /**
  * Waits on the FIFO.
@@ -526,9 +542,17 @@ VLC_API void vlc_fifo_Signal(vlc_fifo_t *);
  * @note This function is a cancellation point. In case of cancellation, the
  * the FIFO will be locked before cancellation cleanup handlers are processed.
  */
-VLC_API void vlc_fifo_Wait(vlc_fifo_t *);
+static inline void vlc_fifo_Wait(vlc_fifo_t *fifo)
+{
+    vlc_queue_Wait(vlc_fifo_queue(fifo));
+}
 
-VLC_API void vlc_fifo_WaitCond(vlc_fifo_t *, vlc_cond_t *);
+static inline void vlc_fifo_WaitCond(vlc_fifo_t *fifo, vlc_cond_t *condvar)
+{
+    vlc_queue_t *q = vlc_fifo_queue(fifo);
+
+    vlc_cond_wait(condvar, &q->lock);
+}
 
 /**
  * Queues a linked-list of blocks into a locked FIFO.
@@ -541,7 +565,7 @@ VLC_API void vlc_fifo_WaitCond(vlc_fifo_t *, vlc_cond_t *);
  * @warning The FIFO must be locked by the calling thread using
  * vlc_fifo_Lock(). Otherwise behaviour is undefined.
  */
-VLC_API void vlc_fifo_QueueUnlocked(vlc_fifo_t *, block_t *);
+VLC_API void vlc_fifo_QueueUnlocked(vlc_fifo_t *fifo, block_t *);
 
 /**
  * Dequeues the first block from a locked FIFO, if any.
@@ -604,7 +628,7 @@ VLC_API size_t vlc_fifo_GetBytes(const vlc_fifo_t *) VLC_USED;
 
 VLC_USED static inline bool vlc_fifo_IsEmpty(const vlc_fifo_t *fifo)
 {
-    return vlc_fifo_GetCount(fifo) == 0;
+    return vlc_queue_IsEmpty(vlc_fifo_queue(fifo));
 }
 
 static inline void vlc_fifo_Cleanup(void *fifo)
@@ -618,12 +642,7 @@ static inline void vlc_fifo_Cleanup(void *fifo)
  */
 static inline void block_FifoEmpty(block_fifo_t *fifo)
 {
-    block_t *block;
-
-    vlc_fifo_Lock(fifo);
-    block = vlc_fifo_DequeueAllUnlocked(fifo);
-    vlc_fifo_Unlock(fifo);
-    block_ChainRelease(block);
+    block_ChainRelease((block_t *)vlc_queue_DequeueAll(vlc_fifo_queue(fifo)));
 }
 
 /**
diff --git a/src/misc/fifo.c b/src/misc/fifo.c
index 522d52d167..ddfff586e6 100644
--- a/src/misc/fifo.c
+++ b/src/misc/fifo.c
@@ -37,118 +37,65 @@
  */
 struct block_fifo_t
 {
-    vlc_mutex_t         lock;                         /* fifo data lock */
-    vlc_cond_t          wait;      /**< Wait for data */
-
-    block_t             *p_first;
-    block_t             **pp_last;
+    vlc_queue_t         q;
     size_t              i_depth;
     size_t              i_size;
 };
 
-void vlc_fifo_Lock(vlc_fifo_t *fifo)
-{
-    vlc_mutex_lock(&fifo->lock);
-}
-
-void vlc_fifo_Unlock(vlc_fifo_t *fifo)
-{
-    vlc_mutex_unlock(&fifo->lock);
-}
-
-void vlc_fifo_Signal(vlc_fifo_t *fifo)
-{
-    vlc_cond_signal(&fifo->wait);
-}
-
-void vlc_fifo_Wait(vlc_fifo_t *fifo)
-{
-    vlc_fifo_WaitCond(fifo, &fifo->wait);
-}
-
-void vlc_fifo_WaitCond(vlc_fifo_t *fifo, vlc_cond_t *condvar)
-{
-    vlc_cond_wait(condvar, &fifo->lock);
-}
+static_assert (offsetof (block_fifo_t, q) == 0, "Problems in <vlc_block.h>");
 
 size_t vlc_fifo_GetCount(const vlc_fifo_t *fifo)
 {
-    vlc_mutex_assert(&fifo->lock);
+    vlc_mutex_assert(&fifo->q.lock);
     return fifo->i_depth;
 }
 
 size_t vlc_fifo_GetBytes(const vlc_fifo_t *fifo)
 {
-    vlc_mutex_assert(&fifo->lock);
+    vlc_mutex_assert(&fifo->q.lock);
     return fifo->i_size;
 }
 
 void vlc_fifo_QueueUnlocked(block_fifo_t *fifo, block_t *block)
 {
-    vlc_mutex_assert(&fifo->lock);
-    assert(*(fifo->pp_last) == NULL);
-
-    *(fifo->pp_last) = block;
-
-    while (block != NULL)
-    {
-        fifo->pp_last = &block->p_next;
+    for (block_t *b = block; b != NULL; b = b->p_next) {
         fifo->i_depth++;
         fifo->i_size += block->i_buffer;
-
-        block = block->p_next;
     }
 
-    vlc_fifo_Signal(fifo);
+    vlc_queue_EnqueueUnlocked(&fifo->q, block);
 }
 
 block_t *vlc_fifo_DequeueUnlocked(block_fifo_t *fifo)
 {
-    vlc_mutex_assert(&fifo->lock);
-
-    block_t *block = fifo->p_first;
-
-    if (block == NULL)
-        return NULL; /* Nothing to do */
+    block_t *block = vlc_queue_DequeueUnlocked(&fifo->q);
 
-    fifo->p_first = block->p_next;
-    if (block->p_next == NULL)
-        fifo->pp_last = &fifo->p_first;
-    block->p_next = NULL;
-
-    assert(fifo->i_depth > 0);
-    fifo->i_depth--;
-    assert(fifo->i_size >= block->i_buffer);
-    fifo->i_size -= block->i_buffer;
+    if (block != NULL) {
+        assert(fifo->i_depth > 0);
+        assert(fifo->i_size >= block->i_buffer);
+        fifo->i_depth--;
+        fifo->i_size -= block->i_buffer;
+    }
 
     return block;
 }
 
 block_t *vlc_fifo_DequeueAllUnlocked(block_fifo_t *fifo)
 {
-    vlc_mutex_assert(&fifo->lock);
-
-    block_t *block = fifo->p_first;
-
-    fifo->p_first = NULL;
-    fifo->pp_last = &fifo->p_first;
     fifo->i_depth = 0;
     fifo->i_size = 0;
-
-    return block;
+    return vlc_queue_DequeueAllUnlocked(&fifo->q);
 }
 
 block_fifo_t *block_FifoNew( void )
 {
     block_fifo_t *p_fifo = malloc( sizeof( block_fifo_t ) );
-    if( !p_fifo )
-        return NULL;
 
-    vlc_mutex_init( &p_fifo->lock );
-    vlc_cond_init( &p_fifo->wait );
-    p_fifo->p_first = NULL;
-    p_fifo->pp_last = &p_fifo->p_first;
-    p_fifo->i_depth = p_fifo->i_size = 0;
+    if (likely(p_fifo != NULL)) {
+        vlc_queue_Init(&p_fifo->q, offsetof (block_t, p_next));
+        p_fifo->i_depth = 0;
+        p_fifo->i_size = 0;
+    }
 
     return p_fifo;
 }
@@ -183,8 +130,8 @@ block_t *block_FifoShow( block_fifo_t *p_fifo )
     block_t *b;
 
     vlc_fifo_Lock(p_fifo);
-    assert(p_fifo->p_first != NULL);
-    b = p_fifo->p_first;
+    assert(p_fifo->q.first != NULL);
+    b = (block_t *)p_fifo->q.first;
     vlc_fifo_Unlock(p_fifo);
 
     return b;



More information about the vlc-commits mailing list