#include <vppinfra/cache.h>
#include <svm/queue.h>
#include <vppinfra/time.h>
-#include <signal.h>
+#include <vppinfra/lock.h>
-/*
- * svm_queue_init
- *
- * nels = number of elements on the queue
- * elsize = element size, presumably 4 and cacheline-size will
- * be popular choices.
- * pid = consumer pid
- *
- * The idea is to call this function in the queue consumer,
- * and e-mail the queue pointer to the producer(s).
- *
- * The vpp process / main thread allocates one of these
- * at startup; its main input queue. The vpp main input queue
- * has a pointer to it in the shared memory segment header.
- *
- * You probably want to be on an svm data heap before calling this
- * function.
- */
svm_queue_t *
-svm_queue_init (int nels,
- int elsize, int consumer_pid, int signal_when_queue_non_empty)
+svm_queue_init (void *base, int nels, int elsize)
{
svm_queue_t *q;
pthread_mutexattr_t attr;
pthread_condattr_t cattr;
- q = clib_mem_alloc_aligned (sizeof (svm_queue_t)
- + nels * elsize, CLIB_CACHE_LINE_BYTES);
+ q = (svm_queue_t *) base;
memset (q, 0, sizeof (*q));
q->elsize = elsize;
q->maxsize = nels;
- q->consumer_pid = consumer_pid;
- q->signal_when_queue_non_empty = signal_when_queue_non_empty;
+ q->producer_evtfd = -1;
+ q->consumer_evtfd = -1;
memset (&attr, 0, sizeof (attr));
memset (&cattr, 0, sizeof (cattr));
return (q);
}
+svm_queue_t *
+svm_queue_alloc_and_init (int nels, int elsize, int consumer_pid)
+{
+ svm_queue_t *q;
+
+ q = clib_mem_alloc_aligned (sizeof (svm_queue_t)
+ + nels * elsize, CLIB_CACHE_LINE_BYTES);
+ memset (q, 0, sizeof (*q));
+ q = svm_queue_init (q, nels, elsize);
+ q->consumer_pid = consumer_pid;
+
+ return q;
+}
+
/*
* svm_queue_free
*/
return q->cursize == q->maxsize;
}
+static inline void
+svm_queue_send_signal (svm_queue_t * q, u8 is_prod)
+{
+ if (q->producer_evtfd == -1)
+ {
+ (void) pthread_cond_broadcast (&q->condvar);
+ }
+ else
+ {
+ int __clib_unused rv, fd;
+ u64 data = 1;
+ ASSERT (q->consumer_evtfd > 0 && q->producer_evtfd > 0);
+ fd = is_prod ? q->producer_evtfd : q->consumer_evtfd;
+ rv = write (fd, &data, sizeof (data));
+ }
+}
+
+static inline void
+svm_queue_wait_inline (svm_queue_t * q)
+{
+ if (q->producer_evtfd == -1)
+ {
+ pthread_cond_wait (&q->condvar, &q->mutex);
+ }
+ else
+ {
+ /* Fake a wait for event. We could use epoll but that would mean
+ * using yet another fd. Should do for now */
+ u32 cursize = q->cursize;
+ pthread_mutex_unlock (&q->mutex);
+ while (q->cursize == cursize)
+ CLIB_PAUSE ();
+ pthread_mutex_lock (&q->mutex);
+ }
+}
+
+void
+svm_queue_wait (svm_queue_t * q)
+{
+ svm_queue_wait_inline (q);
+}
+
+static inline int
+svm_queue_timedwait_inline (svm_queue_t * q, double timeout)
+{
+ struct timespec ts;
+ ts.tv_sec = unix_time_now () + (u32) timeout;
+ ts.tv_nsec = (timeout - (u32) timeout) * 1e9;
+
+ if (q->producer_evtfd == -1)
+ {
+ return pthread_cond_timedwait (&q->condvar, &q->mutex, &ts);
+ }
+ else
+ {
+ double max_time = unix_time_now () + timeout;
+ u32 cursize = q->cursize;
+ int rv;
+
+ pthread_mutex_unlock (&q->mutex);
+ while (q->cursize == cursize && unix_time_now () < max_time)
+ CLIB_PAUSE ();
+ rv = unix_time_now () < max_time ? 0 : ETIMEDOUT;
+ pthread_mutex_lock (&q->mutex);
+ return rv;
+ }
+}
+
+int
+svm_queue_timedwait (svm_queue_t * q, double timeout)
+{
+ return svm_queue_timedwait_inline (q, timeout);
+}
+
/*
* svm_queue_add_nolock
*/
if (PREDICT_FALSE (q->cursize == q->maxsize))
{
while (q->cursize == q->maxsize)
- {
- (void) pthread_cond_wait (&q->condvar, &q->mutex);
- }
+ svm_queue_wait_inline (q);
}
tailp = (i8 *) (&q->data[0] + q->elsize * q->tail);
q->tail = 0;
if (need_broadcast)
- {
- (void) pthread_cond_broadcast (&q->condvar);
- if (q->signal_when_queue_non_empty)
- kill (q->consumer_pid, q->signal_when_queue_non_empty);
- }
+ svm_queue_send_signal (q, 1);
return 0;
}
q->tail = (q->tail + 1) % q->maxsize;
q->cursize++;
+
+ if (q->cursize == 1)
+ svm_queue_send_signal (q, 1);
}
return (-2);
}
while (q->cursize == q->maxsize)
- {
- (void) pthread_cond_wait (&q->condvar, &q->mutex);
- }
+ svm_queue_wait_inline (q);
}
tailp = (i8 *) (&q->data[0] + q->elsize * q->tail);
q->tail = 0;
if (need_broadcast)
- {
- (void) pthread_cond_broadcast (&q->condvar);
- if (q->signal_when_queue_non_empty)
- kill (q->consumer_pid, q->signal_when_queue_non_empty);
- }
+ svm_queue_send_signal (q, 1);
+
pthread_mutex_unlock (&q->mutex);
return 0;
return (-2);
}
while (q->cursize + 1 == q->maxsize)
- {
- (void) pthread_cond_wait (&q->condvar, &q->mutex);
- }
+ svm_queue_wait_inline (q);
}
tailp = (i8 *) (&q->data[0] + q->elsize * q->tail);
q->tail = 0;
if (need_broadcast)
- {
- (void) pthread_cond_broadcast (&q->condvar);
- if (q->signal_when_queue_non_empty)
- kill (q->consumer_pid, q->signal_when_queue_non_empty);
- }
+ svm_queue_send_signal (q, 1);
+
pthread_mutex_unlock (&q->mutex);
return 0;
}
else if (cond == SVM_Q_TIMEDWAIT)
{
- struct timespec ts;
- ts.tv_sec = unix_time_now () + time;
- ts.tv_nsec = 0;
while (q->cursize == 0 && rc == 0)
- {
- rc = pthread_cond_timedwait (&q->condvar, &q->mutex, &ts);
- }
+ rc = svm_queue_timedwait_inline (q, time);
+
if (rc == ETIMEDOUT)
{
pthread_mutex_unlock (&q->mutex);
else
{
while (q->cursize == 0)
- {
- (void) pthread_cond_wait (&q->condvar, &q->mutex);
- }
+ svm_queue_wait_inline (q);
}
}
q->head = 0;
if (need_broadcast)
- (void) pthread_cond_broadcast (&q->condvar);
+ svm_queue_send_signal (q, 0);
pthread_mutex_unlock (&q->mutex);
pthread_mutex_unlock (&q->mutex);
if (need_broadcast)
- (void) pthread_cond_broadcast (&q->condvar);
+ svm_queue_send_signal (q, 0);
return 0;
}
return 0;
}
+void
+svm_queue_set_producer_event_fd (svm_queue_t * q, int fd)
+{
+ q->producer_evtfd = fd;
+}
+
+void
+svm_queue_set_consumer_event_fd (svm_queue_t * q, int fd)
+{
+ q->consumer_evtfd = fd;
+}
+
/*
* fd.io coding-style-patch-verification: ON
*
Code Review / vpp.git / blobdiff