f->ooos_list_head = OOO_SEGMENT_INVALID_INDEX;
f->segment_index = SVM_FIFO_INVALID_INDEX;
f->refcnt = 1;
- f->default_chunk.start_byte = 0;
- f->default_chunk.length = f->size;
- f->default_chunk.next = f->start_chunk = f->end_chunk = &f->default_chunk;
+ f->head = f->tail = f->flags = 0;
f->head_chunk = f->tail_chunk = f->ooo_enq = f->ooo_deq = f->start_chunk;
}
+void
+svm_fifo_init_chunks (svm_fifo_t * f)
+{
+ svm_fifo_chunk_t *c, *prev;
+
+ if (f->start_chunk->next == f->start_chunk)
+ return;
+
+ f->flags |= SVM_FIFO_F_MULTI_CHUNK;
+ rb_tree_init (&f->chunk_lookup);
+ rb_tree_add2 (&f->chunk_lookup, 0, pointer_to_uword (f->start_chunk));
+
+ f->start_chunk->start_byte = 0;
+ prev = f->start_chunk;
+ c = prev->next;
+
+ while (c != f->start_chunk)
+ {
+ c->start_byte = prev->start_byte + prev->length;
+ rb_tree_add2 (&f->chunk_lookup, c->start_byte, pointer_to_uword (c));
+ prev = c;
+ c = c->next;
+ }
+}
+
/**
* Creates a 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;
u32 rounded_data_size;
+ svm_fifo_chunk_t *c;
+ svm_fifo_t *f;
- /* always round fifo data size to the next highest power-of-two */
- rounded_data_size = (1 << (max_log2 (data_size_in_bytes)));
- f = clib_mem_alloc_aligned_or_null (sizeof (*f) + rounded_data_size,
- CLIB_CACHE_LINE_BYTES);
+ f = clib_mem_alloc_aligned_or_null (sizeof (*f), CLIB_CACHE_LINE_BYTES);
if (f == 0)
return 0;
clib_memset (f, 0, sizeof (*f));
+
+ /* always round fifo data size to the next highest power-of-two */
+ rounded_data_size = (1 << (max_log2 (data_size_in_bytes)));
+ c = clib_mem_alloc_aligned_or_null (sizeof (*c) + rounded_data_size,
+ CLIB_CACHE_LINE_BYTES);
+ if (!c)
+ {
+ clib_mem_free (f);
+ return 0;
+ }
+
+ c->next = c;
+ c->start_byte = 0;
+ c->length = data_size_in_bytes;
+ f->start_chunk = f->end_chunk = c;
+
svm_fifo_init (f, data_size_in_bytes);
return f;
}
if (pos < prev->key)
{
cur = rb_tree_predecessor (rt, prev);
+ if (rb_node_is_tnil (rt, cur))
+ return 0;
c = uword_to_pointer (cur->opaque, svm_fifo_chunk_t *);
if (svm_fifo_chunk_includes_pos (c, pos))
return c;
* that this is called with the heap where the rbtree's pool is pushed. */
if (!(f->flags & SVM_FIFO_F_MULTI_CHUNK))
{
+ ASSERT (f->start_chunk->next == f->start_chunk);
rb_tree_init (&f->chunk_lookup);
rb_tree_add2 (&f->chunk_lookup, 0, pointer_to_uword (f->start_chunk));
f->flags |= SVM_FIFO_F_MULTI_CHUNK;
}
+ /* If fifo is not wrapped, update the size now */
+ if (!svm_fifo_is_wrapped (f))
+ {
+ /* Initialize chunks and add to lookup rbtree */
+ cur = c;
+ if (f->new_chunks)
+ {
+ prev = f->new_chunks;
+ while (prev->next)
+ prev = prev->next;
+ prev->next = c;
+ }
+ else
+ prev = f->end_chunk;
+
+ while (cur)
+ {
+ cur->start_byte = prev->start_byte + prev->length;
+ rb_tree_add2 (&f->chunk_lookup, cur->start_byte,
+ pointer_to_uword (cur));
+ prev = cur;
+ cur = cur->next;
+ }
+
+ ASSERT (!f->new_chunks);
+ svm_fifo_grow (f, c);
+ return;
+ }
+
+ /* Wrapped */
+ if (f->flags & SVM_FIFO_F_SINGLE_THREAD_OWNED)
+ {
+ ASSERT (f->master_thread_index == os_get_thread_index ());
+
+ if (!f->new_chunks && f->head_chunk != f->tail_chunk)
+ {
+ u32 head = 0, tail = 0;
+ f_load_head_tail_cons (f, &head, &tail);
+
+ svm_fifo_chunk_t *tmp = f->tail_chunk->next;
+
+ prev = f->tail_chunk;
+ u32 add_bytes = 0;
+ cur = prev->next;
+ while (cur != f->start_chunk)
+ {
+ /* remove any existing rb_tree entry */
+ rb_tree_del (&f->chunk_lookup, cur->start_byte);
+ cur = cur->next;
+ }
+
+ /* insert new chunk after the tail_chunk */
+ f->tail_chunk->next = c;
+ while (c)
+ {
+ add_bytes += c->length;
+ c->start_byte = prev->start_byte + prev->length;
+ rb_tree_add2 (&f->chunk_lookup, c->start_byte,
+ pointer_to_uword (c));
+
+ prev = c;
+ c = c->next;
+ }
+ prev->next = tmp;
+
+ /* shift existing chunks along */
+ cur = tmp;
+ while (cur != f->start_chunk)
+ {
+ cur->start_byte = prev->start_byte + prev->length;
+ rb_tree_add2 (&f->chunk_lookup, cur->start_byte,
+ pointer_to_uword (cur));
+ prev = cur;
+ cur = cur->next;
+ }
+
+ f->size += add_bytes;
+ f->nitems = f->size - 1;
+ f->new_chunks = 0;
+ head += add_bytes;
+
+ clib_atomic_store_rel_n (&f->head, head);
+ ASSERT (svm_fifo_is_sane (f));
+
+ return;
+ }
+ }
+
+ /* Wrapped, and optimization of single-thread-owned fifo cannot be applied */
/* Initialize chunks and add to lookup rbtree */
cur = c;
if (f->new_chunks)
cur = cur->next;
}
- /* If fifo is not wrapped, update the size now */
- if (!svm_fifo_is_wrapped (f))
- {
- ASSERT (!f->new_chunks);
- svm_fifo_grow (f, c);
- return;
- }
-
/* Postpone size update */
if (!f->new_chunks)
{
void
svm_fifo_try_shrink (svm_fifo_t * f, u32 head, u32 tail)
{
- u32 len_to_shrink = 0, tail_pos, len;
+ u32 len_to_shrink = 0, tail_pos, len, last_pos;
svm_fifo_chunk_t *cur, *prev, *next, *start;
tail_pos = tail;
* - not wrapped
* - last used byte less than start of last chunk
*/
- if (tail_pos >= head && tail_pos <= f->end_chunk->start_byte)
+ if (tail_pos >= head && tail_pos < f->end_chunk->start_byte)
{
/* Lookup the last position not to be removed. Since size still needs
- * to be nitems + 1, nitems must fall within the usable space */
- tail_pos = tail_pos > 0 ? tail_pos - 1 : tail_pos;
- prev = svm_fifo_find_chunk (f, clib_max (f->nitems, tail_pos));
+ * to be nitems + 1, nitems must fall within the usable space. Also,
+ * first segment is not removable, so tail_pos can be 0. */
+ last_pos = tail_pos > 0 ? tail_pos - 1 : tail_pos;
+ prev = svm_fifo_find_chunk (f, clib_max (f->nitems, last_pos));
next = prev->next;
+ /* If tail_pos is first position in next, skip the chunk, otherwise,
+ * we must update the tail and, if fifo size is 0, even the head.
+ * We should not invalidate the tail for the caller and must not change
+ * consumer owned variables from code that's typically called by the
+ * producer */
+ if (next->start_byte == tail_pos)
+ {
+ prev = next;
+ next = next->next;
+ }
while (next != f->start_chunk)
{
cur = next;
/* collect out-of-order segments */
if (PREDICT_FALSE (f->ooos_list_head != OOO_SEGMENT_INVALID_INDEX))
- len += ooo_segment_try_collect (f, len, &tail);
+ {
+ len += ooo_segment_try_collect (f, len, &tail);
+ if (!svm_fifo_chunk_includes_pos (f->tail_chunk, tail))
+ f->tail_chunk = svm_fifo_find_chunk (f, tail);
+ }
/* store-rel: producer owned index (paired with load-acq in consumer) */
clib_atomic_store_rel_n (&f->tail, tail);
/* load-relaxed: producer owned index */
tail = f->tail;
tail = (tail + len) % f->size;
+
+ if (!svm_fifo_chunk_includes_pos (f->tail_chunk, tail))
+ f->tail_chunk = svm_fifo_find_chunk (f, tail);
+
/* store-rel: producer owned index (paired with load-acq in consumer) */
clib_atomic_store_rel_n (&f->tail, tail);
}
if (PREDICT_FALSE (cursize == 0))
return SVM_FIFO_EEMPTY;
- svm_fifo_trace_add (f, tail, total_drop_bytes, 3);
-
/* number of bytes we're going to drop */
total_drop_bytes = clib_min (cursize, len);
+ svm_fifo_trace_add (f, tail, total_drop_bytes, 3);
+
/* move head */
head = (head + total_drop_bytes) % f->size;
+ if (!svm_fifo_chunk_includes_pos (f->head_chunk, head))
+ f->head_chunk = svm_fifo_find_chunk (f, head);
+
+ if (PREDICT_FALSE (f->flags & SVM_FIFO_F_GROW))
+ svm_fifo_try_grow (f, head);
+
/* store-rel: consumer owned index (paired with load-acq in producer) */
clib_atomic_store_rel_n (&f->head, head);
{
/* consumer foreign index */
u32 tail = clib_atomic_load_acq_n (&f->tail);
+
+ if (!svm_fifo_chunk_includes_pos (f->head_chunk, tail))
+ f->head_chunk = svm_fifo_find_chunk (f, tail);
+
+ if (PREDICT_FALSE (f->flags & SVM_FIFO_F_GROW))
+ svm_fifo_try_grow (f, tail);
+
/* store-rel: consumer owned index (paired with load-acq in producer) */
clib_atomic_store_rel_n (&f->head, tail);
}
}
}
+u8
+svm_fifo_is_sane (svm_fifo_t * f)
+{
+ if (f->size - 1 != f->nitems && !(f->flags & SVM_FIFO_F_SHRINK))
+ return 0;
+ if (!svm_fifo_chunk_includes_pos (f->head_chunk, f->head))
+ return 0;
+ if (!svm_fifo_chunk_includes_pos (f->tail_chunk, f->tail))
+ return 0;
+
+ if (f->start_chunk->next != f->start_chunk)
+ {
+ svm_fifo_chunk_t *c, *prev = 0, *tmp;
+ u32 size = 0;
+
+ if (!(f->flags & SVM_FIFO_F_MULTI_CHUNK))
+ return 0;
+
+ c = f->start_chunk;
+ do
+ {
+ tmp = svm_fifo_find_chunk (f, c->start_byte);
+ if (tmp != c)
+ return 0;
+ if (prev && (prev->start_byte + prev->length != c->start_byte))
+ return 0;
+ size += c->length;
+ prev = c;
+ c = c->next;
+ }
+ while (c != f->start_chunk);
+
+ if (size != f->size)
+ return 0;
+ }
+
+ return 1;
+}
+
+u8
+svm_fifo_set_single_thread_owned (svm_fifo_t * f)
+{
+ if (f->flags & SVM_FIFO_F_SINGLE_THREAD_OWNED)
+ {
+ if (f->master_thread_index == os_get_thread_index ())
+ {
+ /* just a duplicate call */
+ return 0;
+ }
+
+ /* already owned by another thread */
+ return 1;
+ }
+
+ f->flags |= SVM_FIFO_F_SINGLE_THREAD_OWNED;
+ return 0;
+}
+
u8 *
format_ooo_segment (u8 * s, va_list * args)
{
Code Review / vpp.git / blobdiff