vlc | branch: master | Rémi Denis-Courmont <[email protected]> | 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; _______________________________________________ vlc-commits mailing list [email protected] https://mailman.videolan.org/listinfo/vlc-commits
