* limitations under the License.
*/
-#include "svm_fifo.h"
+#include <svm/svm_fifo.h>
+
+#define offset_lt(_a, _b) ((i32)((_a)-(_b)) < 0)
+#define offset_leq(_a, _b) ((i32)((_a)-(_b)) <= 0)
+
+u8 *
+format_ooo_segment (u8 * s, va_list * args)
+{
+ ooo_segment_t *seg = va_arg (*args, ooo_segment_t *);
+
+ s = format (s, "pos %u, len %u, next %d, prev %d",
+ seg->start, seg->length, seg->next, seg->prev);
+ return s;
+}
+
+u8 *
+format_ooo_list (u8 * s, va_list * args)
+{
+ svm_fifo_t *f = va_arg (*args, svm_fifo_t *);
+ u32 ooo_segment_index = f->ooos_list_head;
+ ooo_segment_t *seg;
+
+ while (ooo_segment_index != OOO_SEGMENT_INVALID_INDEX)
+ {
+ seg = pool_elt_at_index (f->ooo_segments, ooo_segment_index);
+ s = format (s, " %U\n", format_ooo_segment, seg);
+ ooo_segment_index = seg->next;
+ }
+ return s;
+}
+
+u8 *
+format_svm_fifo (u8 * s, va_list * args)
+{
+ svm_fifo_t *f = va_arg (*args, svm_fifo_t *);
+ int verbose = va_arg (*args, int);
+
+ s = format (s, "cursize %u nitems %u has_event %d\n",
+ f->cursize, f->nitems, f->has_event);
+ s = format (s, "head %d tail %d\n", f->head, f->tail);
+
+ if (verbose > 1)
+ s = format
+ (s, "server session %d thread %d client session %d thread %d\n",
+ f->master_session_index, f->master_thread_index,
+ f->client_session_index, f->client_thread_index);
+
+ if (verbose)
+ {
+ s = format (s, "ooo pool %d active elts\n",
+ pool_elts (f->ooo_segments));
+ s = format (s, "%U", format_ooo_list, f);
+ }
+ return s;
+}
/** create an svm fifo, in the current heap. Fails vs blow up the process */
svm_fifo_t *
svm_fifo_create (u32 data_size_in_bytes)
{
svm_fifo_t *f;
- pthread_mutexattr_t attr;
- pthread_condattr_t cattr;
f = clib_mem_alloc_aligned_or_null (sizeof (*f) + data_size_in_bytes,
CLIB_CACHE_LINE_BYTES);
f->nitems = data_size_in_bytes;
f->ooos_list_head = OOO_SEGMENT_INVALID_INDEX;
- memset (&attr, 0, sizeof (attr));
- memset (&cattr, 0, sizeof (cattr));
-
- if (pthread_mutexattr_init (&attr))
- clib_unix_warning ("mutexattr_init");
- if (pthread_mutexattr_setpshared (&attr, PTHREAD_PROCESS_SHARED))
- clib_unix_warning ("pthread_mutexattr_setpshared");
- if (pthread_mutex_init (&f->mutex, &attr))
- clib_unix_warning ("mutex_init");
- if (pthread_mutexattr_destroy (&attr))
- clib_unix_warning ("mutexattr_destroy");
- if (pthread_condattr_init (&cattr))
- clib_unix_warning ("condattr_init");
- if (pthread_condattr_setpshared (&cattr, PTHREAD_PROCESS_SHARED))
- clib_unix_warning ("condattr_setpshared");
- if (pthread_cond_init (&f->condvar, &cattr))
- clib_unix_warning ("cond_init1");
- if (pthread_condattr_destroy (&cattr))
- clib_unix_warning ("cond_init2");
-
return (f);
}
+void
+svm_fifo_free (svm_fifo_t * f)
+{
+ pool_free (f->ooo_segments);
+ clib_mem_free (f);
+}
+
always_inline ooo_segment_t *
ooo_segment_new (svm_fifo_t * f, u32 start, u32 length)
{
pool_get (f->ooo_segments, s);
- s->fifo_position = start;
+ s->start = start;
s->length = length;
s->prev = s->next = OOO_SEGMENT_INVALID_INDEX;
ooo_segment_add (svm_fifo_t * f, u32 offset, u32 length)
{
ooo_segment_t *s, *new_s, *prev, *next, *it;
- u32 new_index, position, end_offset, s_sof, s_eof, s_index;
+ u32 new_index, end_offset, s_sof, s_eof, s_index;
- position = (f->tail + offset) % f->nitems;
end_offset = offset + length;
if (f->ooos_list_head == OOO_SEGMENT_INVALID_INDEX)
{
- s = ooo_segment_new (f, position, length);
+ s = ooo_segment_new (f, offset, length);
f->ooos_list_head = s - f->ooo_segments;
f->ooos_newest = f->ooos_list_head;
return;
/* Find first segment that starts after new segment */
s = pool_elt_at_index (f->ooo_segments, f->ooos_list_head);
while (s->next != OOO_SEGMENT_INVALID_INDEX
- && ooo_segment_offset (f, s) <= offset)
+ && offset_leq (ooo_segment_offset (f, s), offset))
s = pool_elt_at_index (f->ooo_segments, s->next);
s_index = s - f->ooo_segments;
s_sof = ooo_segment_offset (f, s);
s_eof = ooo_segment_end_offset (f, s);
+ prev = ooo_segment_get_prev (f, s);
/* No overlap, add before current segment */
- if (end_offset < s_sof)
+ if (offset_lt (end_offset, s_sof)
+ && (!prev || offset_lt (prev->start + prev->length, offset)))
{
- new_s = ooo_segment_new (f, position, length);
+ new_s = ooo_segment_new (f, offset, length);
new_index = new_s - f->ooo_segments;
/* Pool might've moved, get segment again */
s = pool_elt_at_index (f->ooo_segments, s_index);
-
if (s->prev != OOO_SEGMENT_INVALID_INDEX)
{
new_s->prev = s->prev;
-
prev = pool_elt_at_index (f->ooo_segments, new_s->prev);
prev->next = new_index;
}
return;
}
/* No overlap, add after current segment */
- else if (s_eof < offset)
+ else if (offset_lt (s_eof, offset))
{
- new_s = ooo_segment_new (f, position, length);
+ new_s = ooo_segment_new (f, offset, length);
new_index = new_s - f->ooo_segments;
/* Pool might've moved, get segment again */
if (s->next != OOO_SEGMENT_INVALID_INDEX)
{
new_s->next = s->next;
-
next = pool_elt_at_index (f->ooo_segments, new_s->next);
next->prev = new_index;
}
*/
/* Merge at head */
- if (offset <= s_sof)
+ if (offset_leq (offset, s_sof))
{
/* If we have a previous, check if we overlap */
if (s->prev != OOO_SEGMENT_INVALID_INDEX)
/* New segment merges prev and current. Remove previous and
* update position of current. */
- if (ooo_segment_end_offset (f, prev) >= offset)
+ if (offset_leq (offset, ooo_segment_end_offset (f, prev)))
{
- s->fifo_position = prev->fifo_position;
+ s->start = prev->start;
s->length = s_eof - ooo_segment_offset (f, prev);
ooo_segment_del (f, s->prev);
}
+ else
+ {
+ s->start = offset;
+ s->length = s_eof - ooo_segment_offset (f, s);
+ }
}
else
{
- s->fifo_position = position;
+ s->start = offset;
s->length = s_eof - ooo_segment_offset (f, s);
}
/* The new segment's tail may cover multiple smaller ones */
- if (s_eof < end_offset)
+ if (offset_lt (s_eof, end_offset))
{
/* Remove segments completely covered */
it = (s->next != OOO_SEGMENT_INVALID_INDEX) ?
pool_elt_at_index (f->ooo_segments, s->next) : 0;
- while (it && ooo_segment_end_offset (f, it) < end_offset)
+ while (it && offset_lt (ooo_segment_end_offset (f, it), end_offset))
{
next = (it->next != OOO_SEGMENT_INVALID_INDEX) ?
pool_elt_at_index (f->ooo_segments, it->next) : 0;
s->length = end_offset - ooo_segment_offset (f, s);
/* If partial overlap with last, merge */
- if (it && ooo_segment_offset (f, it) < end_offset)
+ if (it && offset_lt (ooo_segment_offset (f, it), end_offset))
{
s->length +=
it->length - (ooo_segment_offset (f, it) - end_offset);
}
}
/* Last but overlapping previous */
- else if (s_eof <= end_offset)
+ else if (offset_leq (s_eof, end_offset))
{
s->length = end_offset - ooo_segment_offset (f, s);
}
{
ooo_segment_t *s;
u32 index, bytes = 0, diff;
+ u32 cursize;
+
+ /* current size has not yet been updated */
+ cursize = svm_fifo_max_dequeue (f) + n_bytes_enqueued;
s = pool_elt_at_index (f->ooo_segments, f->ooos_list_head);
+ diff = (f->nitems + (i32) (f->tail - s->start)) % f->nitems;
+ if (diff > cursize)
+ return 0;
+
/* If last tail update overlaps one/multiple ooo segments, remove them */
- diff = (f->nitems + f->tail - s->fifo_position) % f->nitems;
- while (0 < diff && diff < n_bytes_enqueued)
+ while (0 < diff && diff < cursize)
{
- /* Segment end is beyond the tail. Advance tail and be done */
+ index = s - f->ooo_segments;
+
+ /* Segment end is beyond the tail. Advance tail and remove segment */
if (diff < s->length)
{
f->tail += s->length - diff;
f->tail %= f->nitems;
+ bytes = s->length - diff;
+ ooo_segment_del (f, index);
break;
}
+
/* If we have next go on */
- else if (s->next != OOO_SEGMENT_INVALID_INDEX)
+ if (s->next != OOO_SEGMENT_INVALID_INDEX)
{
- index = s - f->ooo_segments;
s = pool_elt_at_index (f->ooo_segments, s->next);
- diff = (f->nitems + f->tail - s->fifo_position) % f->nitems;
+ diff = (f->nitems + (i32) (f->tail - s->start)) % f->nitems;
ooo_segment_del (f, index);
}
/* End of search */
else
{
+ ooo_segment_del (f, index);
break;
}
}
/* If tail is adjacent to an ooo segment, 'consume' it */
if (diff == 0)
{
- bytes = ((f->nitems - f->cursize) >= s->length) ? s->length :
- f->nitems - f->cursize;
+ bytes = ((f->nitems - cursize) >= s->length) ? s->length :
+ f->nitems - cursize;
f->tail += bytes;
f->tail %= f->nitems;
}
static int
-svm_fifo_enqueue_internal (svm_fifo_t * f,
- int pid, u32 max_bytes, u8 * copy_from_here)
+svm_fifo_enqueue_internal (svm_fifo_t * f, u32 max_bytes, u8 * copy_from_here)
{
u32 total_copy_bytes, first_copy_bytes, second_copy_bytes;
u32 cursize, nitems;
- if (PREDICT_FALSE (f->cursize == f->nitems))
+ /* read cursize, which can only increase while we're working */
+ cursize = svm_fifo_max_dequeue (f);
+
+ if (PREDICT_FALSE (cursize == f->nitems))
return -2; /* fifo stuffed */
- /* read cursize, which can only decrease while we're working */
- cursize = f->cursize;
nitems = f->nitems;
/* Number of bytes we're going to copy */
}
int
-svm_fifo_enqueue_nowait (svm_fifo_t * f,
- int pid, u32 max_bytes, u8 * copy_from_here)
+svm_fifo_enqueue_nowait (svm_fifo_t * f, u32 max_bytes, u8 * copy_from_here)
{
- return svm_fifo_enqueue_internal (f, pid, max_bytes, copy_from_here);
+ return svm_fifo_enqueue_internal (f, max_bytes, copy_from_here);
}
-/** Enqueue a future segment.
+/**
+ * Enqueue a future segment.
+ *
* Two choices: either copies the entire segment, or copies nothing
* Returns 0 of the entire segment was copied
* Returns -1 if none of the segment was copied due to lack of space
*/
-
static int
-svm_fifo_enqueue_with_offset_internal2 (svm_fifo_t * f,
- int pid,
- u32 offset,
- u32 required_bytes,
- u8 * copy_from_here)
+svm_fifo_enqueue_with_offset_internal (svm_fifo_t * f,
+ u32 offset,
+ u32 required_bytes,
+ u8 * copy_from_here)
{
u32 total_copy_bytes, first_copy_bytes, second_copy_bytes;
u32 cursize, nitems;
- u32 tail_plus_offset;
+ u32 normalized_offset;
+ int rv;
- ASSERT (offset > 0);
+ /* Users would do well to avoid this */
+ if (PREDICT_FALSE (f->tail == (offset % f->nitems)))
+ {
+ rv = svm_fifo_enqueue_internal (f, required_bytes, copy_from_here);
+ if (rv > 0)
+ return 0;
+ return -1;
+ }
- /* read cursize, which can only decrease while we're working */
- cursize = f->cursize;
+ /* read cursize, which can only increase while we're working */
+ cursize = svm_fifo_max_dequeue (f);
nitems = f->nitems;
/* Will this request fit? */
- if ((required_bytes + offset) > (nitems - cursize))
+ if ((required_bytes + (offset - f->tail) % nitems) > (nitems - cursize))
return -1;
ooo_segment_add (f, offset, required_bytes);
/* Number of bytes we're going to copy */
total_copy_bytes = required_bytes;
- tail_plus_offset = (f->tail + offset) % nitems;
+ normalized_offset = offset % nitems;
/* Number of bytes in first copy segment */
- first_copy_bytes = ((nitems - tail_plus_offset) < total_copy_bytes)
- ? (nitems - tail_plus_offset) : total_copy_bytes;
+ first_copy_bytes = ((nitems - normalized_offset) < total_copy_bytes)
+ ? (nitems - normalized_offset) : total_copy_bytes;
- clib_memcpy (&f->data[tail_plus_offset], copy_from_here, first_copy_bytes);
+ clib_memcpy (&f->data[normalized_offset], copy_from_here, first_copy_bytes);
/* Number of bytes in second copy segment, if any */
second_copy_bytes = total_copy_bytes - first_copy_bytes;
if (second_copy_bytes)
{
- tail_plus_offset += first_copy_bytes;
- tail_plus_offset %= nitems;
+ normalized_offset += first_copy_bytes;
+ normalized_offset %= nitems;
- ASSERT (tail_plus_offset == 0);
+ ASSERT (normalized_offset == 0);
- clib_memcpy (&f->data[tail_plus_offset],
+ clib_memcpy (&f->data[normalized_offset],
copy_from_here + first_copy_bytes, second_copy_bytes);
}
int
svm_fifo_enqueue_with_offset (svm_fifo_t * f,
- int pid,
u32 offset,
u32 required_bytes, u8 * copy_from_here)
{
- return svm_fifo_enqueue_with_offset_internal2
- (f, pid, offset, required_bytes, copy_from_here);
+ return svm_fifo_enqueue_with_offset_internal (f, offset, required_bytes,
+ copy_from_here);
}
static int
-svm_fifo_dequeue_internal2 (svm_fifo_t * f,
- int pid, u32 max_bytes, u8 * copy_here)
+svm_fifo_dequeue_internal (svm_fifo_t * f, u32 max_bytes, u8 * copy_here)
{
u32 total_copy_bytes, first_copy_bytes, second_copy_bytes;
u32 cursize, nitems;
- if (PREDICT_FALSE (f->cursize == 0))
+ /* read cursize, which can only increase while we're working */
+ cursize = svm_fifo_max_dequeue (f);
+ if (PREDICT_FALSE (cursize == 0))
return -2; /* nothing in the fifo */
- /* read cursize, which can only increase while we're working */
- cursize = f->cursize;
nitems = f->nitems;
/* Number of bytes we're going to copy */
}
int
-svm_fifo_dequeue_nowait (svm_fifo_t * f,
- int pid, u32 max_bytes, u8 * copy_here)
+svm_fifo_dequeue_nowait (svm_fifo_t * f, u32 max_bytes, u8 * copy_here)
{
- return svm_fifo_dequeue_internal2 (f, pid, max_bytes, copy_here);
+ return svm_fifo_dequeue_internal (f, max_bytes, copy_here);
}
int
-svm_fifo_peek (svm_fifo_t * f, int pid, u32 offset, u32 max_bytes,
+svm_fifo_peek (svm_fifo_t * f, u32 relative_offset, u32 max_bytes,
u8 * copy_here)
{
u32 total_copy_bytes, first_copy_bytes, second_copy_bytes;
- u32 cursize, nitems;
+ u32 cursize, nitems, real_head;
- if (PREDICT_FALSE (f->cursize == 0))
+ /* read cursize, which can only increase while we're working */
+ cursize = svm_fifo_max_dequeue (f);
+ if (PREDICT_FALSE (cursize == 0))
return -2; /* nothing in the fifo */
- /* read cursize, which can only increase while we're working */
- cursize = f->cursize;
nitems = f->nitems;
+ real_head = f->head + relative_offset;
+ real_head = real_head >= nitems ? real_head - nitems : real_head;
/* Number of bytes we're going to copy */
total_copy_bytes = (cursize < max_bytes) ? cursize : max_bytes;
{
/* Number of bytes in first copy segment */
first_copy_bytes =
- ((nitems - f->head) < total_copy_bytes) ?
- (nitems - f->head) : total_copy_bytes;
- clib_memcpy (copy_here, &f->data[f->head], first_copy_bytes);
+ ((nitems - real_head) < total_copy_bytes) ?
+ (nitems - real_head) : total_copy_bytes;
+ clib_memcpy (copy_here, &f->data[real_head], first_copy_bytes);
/* Number of bytes in second copy segment, if any */
second_copy_bytes = total_copy_bytes - first_copy_bytes;
}
int
-svm_fifo_dequeue_drop (svm_fifo_t * f, int pid, u32 max_bytes)
+svm_fifo_dequeue_drop (svm_fifo_t * f, u32 max_bytes)
{
u32 total_drop_bytes, first_drop_bytes, second_drop_bytes;
u32 cursize, nitems;
- if (PREDICT_FALSE (f->cursize == 0))
+ /* read cursize, which can only increase while we're working */
+ cursize = svm_fifo_max_dequeue (f);
+ if (PREDICT_FALSE (cursize == 0))
return -2; /* nothing in the fifo */
- /* read cursize, which can only increase while we're working */
- cursize = f->cursize;
nitems = f->nitems;
/* Number of bytes we're going to drop */
return total_drop_bytes;
}
+u32
+svm_fifo_number_ooo_segments (svm_fifo_t * f)
+{
+ return pool_elts (f->ooo_segments);
+}
+
+ooo_segment_t *
+svm_fifo_first_ooo_segment (svm_fifo_t * f)
+{
+ return pool_elt_at_index (f->ooo_segments, f->ooos_list_head);
+}
+
/*
* fd.io coding-style-patch-verification: ON
*
Code Review / vpp.git / blobdiff