/*
* Enqueue an initial (un-dequeued) chunk
*/
- rv = svm_fifo_enqueue_nowait (f, sizeof (u32), (u8 *) test_data);
+ rv = svm_fifo_enqueue (f, sizeof (u32), (u8 *) test_data);
SFIFO_TEST ((rv == sizeof (u32)), "enqueued %d", rv);
SFIFO_TEST ((f->tail == 4), "fifo tail %u", f->tail);
data = (u8 *) (test_data + (2 * i + 1));
if (i == 0)
{
- rv = svm_fifo_enqueue_nowait (f, sizeof (u32), data);
+ rv = svm_fifo_enqueue (f, sizeof (u32), data);
rv = rv > 0 ? 0 : rv;
}
else
vlib_cli_output (vm, "fifo after odd segs: %U", format_svm_fifo, f, 1);
SFIFO_TEST ((f->tail == 8), "fifo tail %u", f->tail);
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 2),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 2),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
/*
* Try adding a completely overlapped segment
if (verbose)
vlib_cli_output (vm, "fifo after overlap seg: %U", format_svm_fifo, f, 1);
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 2),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 2),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
/*
* Make sure format functions are not buggy
if (verbose)
vlib_cli_output (vm, "fifo before missing link: %U", format_svm_fifo, f,
1);
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 1),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
ooo_seg = svm_fifo_first_ooo_segment (f);
SFIFO_TEST ((ooo_seg->start == 12),
"first ooo seg position %u", ooo_seg->start);
/*
* Enqueue the missing u32
*/
- rv = svm_fifo_enqueue_nowait (f, sizeof (u32), (u8 *) (test_data + 2));
+ rv = svm_fifo_enqueue (f, sizeof (u32), (u8 *) (test_data + 2));
if (verbose)
vlib_cli_output (vm, "fifo after missing link: %U", format_svm_fifo, f,
1);
SFIFO_TEST ((rv == 20), "bytes to be enqueued %u", rv);
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 0),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
/*
* Collect results
*/
for (i = 0; i < 7; i++)
{
- rv = svm_fifo_dequeue_nowait (f, sizeof (u32), (u8 *) & data_word);
+ rv = svm_fifo_dequeue (f, sizeof (u32), (u8 *) & data_word);
if (rv != sizeof (u32))
{
clib_warning ("bytes dequeues %u", rv);
rv = svm_fifo_enqueue_with_offset (f, 8 - f->tail, 21, data);
SFIFO_TEST ((rv == 0), "ooo enqueued %u", rv);
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 1),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
/* add missing data to be able to dequeue something */
- rv = svm_fifo_enqueue_nowait (f, 4, data);
+ rv = svm_fifo_enqueue (f, 4, data);
SFIFO_TEST ((rv == 32), "enqueued %u", rv);
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 0),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
vec_validate (data_buf, vec_len (test_data));
svm_fifo_peek (f, 0, 4, data_buf);
if (verbose)
vlib_cli_output (vm, "fifo after enqueue: %U", format_svm_fifo, f, 1);
- rv = svm_fifo_enqueue_nowait (f, 29, data);
+ rv = svm_fifo_enqueue (f, 29, data);
if (verbose)
vlib_cli_output (vm, "fifo after enqueueing 29: %U", format_svm_fifo, f,
1);
SFIFO_TEST ((rv == 32), "ooo enqueued %u", rv);
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 0),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
vec_validate (data_buf, vec_len (data));
svm_fifo_peek (f, 0, vec_len (data), data_buf);
}
/* Expected result: one big fat chunk at offset 4 */
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 1),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
ooo_seg = svm_fifo_first_ooo_segment (f);
SFIFO_TEST ((ooo_seg->start == 4),
"first ooo seg position %u", ooo_seg->start);
"first ooo seg length %u", ooo_seg->length);
data64 = 0;
- rv = svm_fifo_enqueue_nowait (f, sizeof (u32), (u8 *) & data64);
+ rv = svm_fifo_enqueue (f, sizeof (u32), (u8 *) & data64);
SFIFO_TEST ((rv == 3000), "bytes to be enqueued %u", rv);
svm_fifo_free (f);
}
/* Expecting the same result: one big fat chunk at offset 4 */
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 1),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
ooo_seg = svm_fifo_first_ooo_segment (f);
SFIFO_TEST ((ooo_seg->start == 4),
"first ooo seg position %u", ooo_seg->start);
"first ooo seg length %u", ooo_seg->length);
data64 = 0;
- rv = svm_fifo_enqueue_nowait (f, sizeof (u32), (u8 *) & data64);
+ rv = svm_fifo_enqueue (f, sizeof (u32), (u8 *) & data64);
SFIFO_TEST ((rv == 3000), "bytes to be enqueued %u", rv);
/* Add the first segment in order for non random data */
if (!randomize)
- svm_fifo_enqueue_nowait (f, generate[0].len, (u8 *) data_pattern);
+ svm_fifo_enqueue (f, generate[0].len, (u8 *) data_pattern);
/*
* Expected result: one big fat chunk at offset 1 if randomize == 1
u32 bytes_to_enq = 1;
if (in_seq_all)
bytes_to_enq = total_size;
- rv = svm_fifo_enqueue_nowait (f, bytes_to_enq, data_pattern + 0);
+ rv = svm_fifo_enqueue (f, bytes_to_enq, data_pattern + 0);
if (verbose)
vlib_cli_output (vm, "in-order enqueue returned %d", rv);
}
SFIFO_TEST ((svm_fifo_has_ooo_data (f) == 0), "number of ooo segments %u",
- svm_fifo_number_ooo_segments (f));
+ svm_fifo_n_ooo_segments (f));
/*
* Test if peeked data is the same as original data
}
else
{
- svm_fifo_dequeue_nowait (f, vec_len (data_pattern), data_buf);
+ svm_fifo_dequeue (f, vec_len (data_pattern), data_buf);
if (compare_data
(data_buf, data_pattern, 0, vec_len (data_pattern), &j))
{
}
}
- svm_fifo_enqueue_nowait (f, sizeof (u8), &test_data[0]);
+ svm_fifo_enqueue (f, sizeof (u8), &test_data[0]);
vec_validate (data_buf, vec_len (test_data));
- svm_fifo_dequeue_nowait (f, vec_len (test_data), data_buf);
+ svm_fifo_dequeue (f, vec_len (test_data), data_buf);
rv = compare_data (data_buf, test_data, 0, vec_len (test_data), &j);
if (rv)
vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
static u32
fifo_pos (svm_fifo_t * f, u32 pos)
{
- return pos;
+ return pos % f->size;
}
/* Avoids exposing svm_fifo.c internal function */
svm_fifo_enqueue_with_offset (f, 100, 100, &test_data[100]);
svm_fifo_enqueue_with_offset (f, 300, 100, &test_data[300]);
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 2),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 2),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
SFIFO_TEST ((f->ooos_newest == 1), "newest %u", f->ooos_newest);
if (verbose)
vlib_cli_output (vm, "fifo after [100, 200] and [300, 400] : %U",
if (verbose)
vlib_cli_output (vm, "fifo after [225, 275] : %U",
format_svm_fifo, f, 2 /* verbose */ );
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 3),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 3),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
ooo_seg = svm_fifo_first_ooo_segment (f);
SFIFO_TEST ((ooo_seg->start == fifo_pos (f, 100 + offset)),
"first seg start %u expected %u", ooo_seg->start,
if (verbose)
vlib_cli_output (vm, "fifo after [190, 310] : %U",
format_svm_fifo, f, 1 /* verbose */ );
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 1),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
ooo_seg = svm_fifo_first_ooo_segment (f);
SFIFO_TEST ((ooo_seg->start == fifo_pos (f, offset + 100)),
"first seg start %u expected %u",
/*
* Add [0, 150]
*/
- rv = svm_fifo_enqueue_nowait (f, 150, test_data);
+ rv = svm_fifo_enqueue (f, 150, test_data);
if (verbose)
vlib_cli_output (vm, "fifo after [0 150] : %U", format_svm_fifo, f,
2 /* verbose */ );
SFIFO_TEST ((rv == 400), "managed to enqueue %u expected %u", rv, 400);
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 0),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
vec_validate (data_buf, 399);
svm_fifo_peek (f, 0, 400, data_buf);
svm_fifo_enqueue_with_offset (f, 100, 100, &test_data[100]);
svm_fifo_enqueue_with_offset (f, 50, 200, &test_data[50]);
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 1),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
ooo_seg = svm_fifo_first_ooo_segment (f);
SFIFO_TEST ((ooo_seg->start == 50), "first seg start %u expected %u",
ooo_seg->start, 50);
/*
* |0|---[start]--(len5)-->|0|--(len6)-->[end]---|0|
*/
- rv = ooo_segment_distance_to_tail (f, ~0 - 5, 5);
+ rv = f_distance_from (f, ~0 - 5, 5);
SFIFO_TEST (rv == 11, "distance to tail should be %u is %u", 11, rv);
- rv = ooo_segment_distance_from_tail (f, ~0 - 5, 5);
+ rv = f_distance_to (f, ~0 - 5, 5);
SFIFO_TEST (rv == f->size - 11, "distance from tail should be %u is %u",
f->size - 11, rv);
/*
* |0|---[end]--(len5)-->|0|--(len6)-->[start]---|0|
*/
- rv = ooo_segment_distance_from_tail (f, 5, ~0 - 5);
+ rv = f_distance_to (f, 5, ~0 - 5);
SFIFO_TEST (rv == 11, "distance from tail should be %u is %u", 11, rv);
- rv = ooo_segment_distance_to_tail (f, 5, ~0 - 5);
+ rv = f_distance_from (f, 5, ~0 - 5);
SFIFO_TEST (rv == f->size - 11, "distance to tail should be %u is %u",
f->size - 11, rv);
*/
svm_fifo_init_pointers (f, ~0, ~0);
svm_fifo_enqueue_with_offset (f, 10, 10, &test_data[10]);
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 1),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
ooo_seg = svm_fifo_first_ooo_segment (f);
rv = ooo_segment_offset_prod (f, ooo_seg);
SFIFO_TEST (rv == 10, "offset should be %u is %u", 10, rv);
- svm_fifo_enqueue_nowait (f, 10, test_data);
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 0),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ svm_fifo_enqueue (f, 10, test_data);
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
SFIFO_TEST (f->ooos_list_head == OOO_SEGMENT_INVALID_INDEX,
"there should be no ooo seg");
SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
test_data[j]);
- svm_fifo_dequeue_nowait (f, 20, data_buf);
+ svm_fifo_dequeue (f, 20, data_buf);
if (compare_data (data_buf, test_data, 0, 20, (u32 *) & j))
SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
test_data[j]);
*/
svm_fifo_init_pointers (f, ~0 - 10, ~0 - 10);
svm_fifo_enqueue_with_offset (f, 5, 15, &test_data[5]);
- svm_fifo_enqueue_nowait (f, 12, test_data);
+ svm_fifo_enqueue (f, 12, test_data);
- SFIFO_TEST ((svm_fifo_number_ooo_segments (f) == 0),
- "number of ooo segments %u", svm_fifo_number_ooo_segments (f));
+ SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
+ "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
SFIFO_TEST (f->ooos_list_head == OOO_SEGMENT_INVALID_INDEX,
"there should be no ooo seg");
- svm_fifo_dequeue_nowait (f, 20, data_buf);
+ svm_fifo_dequeue (f, 20, data_buf);
if (compare_data (data_buf, test_data, 0, 20, (u32 *) & j))
SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
test_data[j]);
for (j = n_test_bytes - 1; j > 0; j -= 2)
{
svm_fifo_enqueue_with_offset (f, j, 1, &test_data[j]);
- rv = svm_fifo_number_ooo_segments (f);
+ rv = svm_fifo_n_ooo_segments (f);
if (rv != (n_test_bytes - j) / 2 + 1)
SFIFO_TEST (0, "number of ooo segments expected %u is %u",
(n_test_bytes - j) / 2 + 1, rv);
}
svm_fifo_enqueue_with_offset (f, 1, n_test_bytes - 1, &test_data[1]);
- rv = svm_fifo_number_ooo_segments (f);
+ rv = svm_fifo_n_ooo_segments (f);
if (rv != 1)
SFIFO_TEST (0, "number of ooo segments %u", rv);
- svm_fifo_enqueue_nowait (f, 1, test_data);
- rv = svm_fifo_number_ooo_segments (f);
+ svm_fifo_enqueue (f, 1, test_data);
+ rv = svm_fifo_n_ooo_segments (f);
if (rv != 0)
SFIFO_TEST (0, "number of ooo segments %u", rv);
- svm_fifo_dequeue_nowait (f, n_test_bytes, data_buf);
+ svm_fifo_dequeue (f, n_test_bytes, data_buf);
if (compare_data (data_buf, test_data, 0, n_test_bytes, (u32 *) & j))
SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
test_data[j]);
for (i = 0; i < n_iterations; i++)
{
svm_fifo_enqueue_with_offset (f, half, half, &test_data[half]);
- svm_fifo_enqueue_nowait (f, half, test_data);
- rv = svm_fifo_number_ooo_segments (f);
+ svm_fifo_enqueue (f, half, test_data);
+ rv = svm_fifo_n_ooo_segments (f);
if (rv != 0)
SFIFO_TEST (0, "number of ooo segments %u", rv);
- svm_fifo_dequeue_nowait (f, n_bytes_per_iter, data_buf);
+ svm_fifo_dequeue (f, n_bytes_per_iter, data_buf);
if (compare_data (data_buf, test_data, 0, n_bytes_per_iter,
(u32 *) & j))
SFIFO_TEST (0, "[%d][%d] dequeued %u expected %u", i, j, data_buf[j],
svm_fifo_chunk_t *c, *next, *prev;
u8 *test_data = 0, *data_buf = 0;
svm_fifo_t *f;
+ u32 old_tail;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
* Unwrap fifo
*/
vec_validate (data_buf, 200);
- svm_fifo_dequeue_nowait (f, 201, data_buf);
+ svm_fifo_dequeue (f, 201, data_buf);
SFIFO_TEST (f->end_chunk == c, "tail chunk should be updated");
SFIFO_TEST (f->size == fifo_size + 200, "size expected %u is %u",
SFIFO_TEST (f->size == fifo_size + 200, "size expected %u is %u",
fifo_size + 200, f->size);
- svm_fifo_dequeue_nowait (f, 201, data_buf);
+ old_tail = f->tail;
+ svm_fifo_dequeue (f, 101, data_buf);
SFIFO_TEST (f->size == fifo_size + 200 + 10 * 100, "size expected %u is %u",
fifo_size + 200 + 10 * 100, f->size);
+ SFIFO_TEST (f->tail == old_tail, "new tail expected %u is %u", old_tail,
+ f->tail);
+
/*
* Enqueue/dequeue tests
*/
SFIFO_TEST (f->tail_chunk->start_byte == 201, "start byte expected %u is "
"%u", 201, f->tail_chunk->start_byte);
- svm_fifo_enqueue_nowait (f, 200, test_data);
+ svm_fifo_enqueue (f, 200, test_data);
SFIFO_TEST (f->tail_chunk->start_byte == 401, "start byte expected %u is "
"%u", 401, f->tail_chunk->start_byte);
- svm_fifo_dequeue_nowait (f, 200, data_buf);
+ svm_fifo_dequeue (f, 200, data_buf);
SFIFO_TEST (f->head_chunk->start_byte == 401, "start byte expected %u is "
"%u", 401, f->head_chunk->start_byte);
svm_fifo_init_pointers (f, f->nitems / 2, f->nitems / 2);
for (i = 0; i < test_n_bytes; i++)
{
- rv = svm_fifo_enqueue_nowait (f, sizeof (u8), &test_data[i]);
+ rv = svm_fifo_enqueue (f, sizeof (u8), &test_data[i]);
if (rv < 0)
{
clib_warning ("enqueue returned %d", rv);
"is %u", test_n_bytes, svm_fifo_max_dequeue (f));
for (i = 0; i < test_n_bytes; i++)
- svm_fifo_dequeue_nowait (f, 1, &data_buf[i]);
+ svm_fifo_dequeue (f, 1, &data_buf[i]);
rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
(u32 *) & j);
*/
for (i = 0; i <= n_enqs; i++)
{
- rv = svm_fifo_enqueue_nowait (f, enq_bytes, test_data + i * enq_bytes);
+ rv = svm_fifo_enqueue (f, enq_bytes, test_data + i * enq_bytes);
if (rv < 0)
{
clib_warning ("enqueue returned %d", rv);
"is %u", test_n_bytes, svm_fifo_max_dequeue (f));
for (i = 0; i <= n_deqs; i++)
- svm_fifo_dequeue_nowait (f, deq_bytes, data_buf + i * deq_bytes);
+ svm_fifo_dequeue (f, deq_bytes, data_buf + i * deq_bytes);
rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
(u32 *) & j);
SFIFO_TEST (svm_fifo_max_dequeue (f) == 0, "max deq expected %u is %u",
0, svm_fifo_max_dequeue (f));
- svm_fifo_enqueue_nowait (f, sizeof (u8), &test_data[0]);
+ svm_fifo_enqueue (f, sizeof (u8), &test_data[0]);
memset (data_buf, 0, vec_len (data_buf));
for (i = 0; i <= n_deqs; i++)
- svm_fifo_dequeue_nowait (f, deq_bytes, data_buf + i * deq_bytes);
+ svm_fifo_dequeue (f, deq_bytes, data_buf + i * deq_bytes);
rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
(u32 *) & j);
}
}
- svm_fifo_enqueue_nowait (f, enq_bytes, &test_data[0]);
+ svm_fifo_enqueue (f, enq_bytes, &test_data[0]);
memset (data_buf, 0, vec_len (data_buf));
for (i = 0; i <= n_deqs; i++)
- svm_fifo_dequeue_nowait (f, deq_bytes, data_buf + i * deq_bytes);
+ svm_fifo_dequeue (f, deq_bytes, data_buf + i * deq_bytes);
rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
(u32 *) & j);
}
svm_fifo_free (f);
+ vec_free (test_data);
+ vec_free (data_buf);
+ return 0;
+}
+
+static int
+chunk_list_len (svm_fifo_chunk_t * c)
+{
+ svm_fifo_chunk_t *it;
+ int count = 0;
+
+ if (!c)
+ return 0;
+
+ count = 1;
+ it = c->next;
+ while (it && it != c)
+ {
+ it = it->next;
+ count++;
+ }
+ return count;
+}
+
+static void
+chunk_list_free (svm_fifo_chunk_t * c, svm_fifo_chunk_t * stop)
+{
+ svm_fifo_chunk_t *it, *next;
+
+ it = c;
+ while (it && it != stop)
+ {
+ next = it->next;
+ clib_mem_free (it);
+ it = next;
+ }
+}
+
+static void
+chunk_list_splice (svm_fifo_chunk_t * a, svm_fifo_chunk_t * b)
+{
+ svm_fifo_chunk_t *it;
+
+ it = a;
+ while (it->next)
+ it = it->next;
+ it->next = b;
+}
+
+static int
+sfifo_test_fifo_shrink (vlib_main_t * vm, unformat_input_t * input)
+{
+ int __clib_unused verbose = 0, fifo_size = 101, chunk_size = 100;
+ int i, rv, test_n_bytes, diff, deq_bytes;
+ svm_fifo_chunk_t *c, *prev, *collected;
+ u8 *test_data = 0, *data_buf = 0;
+ svm_fifo_t *f;
+
+ while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
+ {
+ if (unformat (input, "verbose"))
+ verbose = 1;
+ else
+ {
+ vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
+ input);
+ return -1;
+ }
+ }
+
+ /*
+ * Init fifo with multiple chunks
+ */
+ f = fifo_prepare (fifo_size);
+ svm_fifo_init_pointers (f, 0, 0);
+
+ prev = 0;
+ for (i = 0; i < 11; i++)
+ {
+ c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + chunk_size);
+ c->length = 100;
+ c->start_byte = ~0;
+ c->next = prev;
+ prev = c;
+ }
+
+ svm_fifo_add_chunk (f, c);
+ SFIFO_TEST (f->size == 12 * chunk_size + 1, "size expected %u is %u",
+ 12 * chunk_size + 1, f->size);
+
+ /*
+ * No fifo wrap and no chunk used (one chunk)
+ */
+ rv = svm_fifo_reduce_size (f, chunk_size, 0);
+ SFIFO_TEST (rv == chunk_size, "len expected %u is %u", chunk_size, rv);
+ SFIFO_TEST (f->size == 12 * chunk_size + 1, "size expected %u is %u",
+ 12 * chunk_size + 1, f->size);
+ SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
+
+ /* Check enqueue space to force size reduction */
+ (void) svm_fifo_max_enqueue (f);
+
+ SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
+ 11 * chunk_size + 1, f->size);
+ SFIFO_TEST (f->flags & SVM_FIFO_F_COLLECT_CHUNKS, "collect flag should"
+ " be set");
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_SHRINK), "shrink flag should not be"
+ " set");
+
+ collected = c = svm_fifo_collect_chunks (f);
+ rv = chunk_list_len (c);
+ SFIFO_TEST (rv == 1, "expected %u chunks got %u", 1, rv);
+ rv = chunk_list_len (f->start_chunk);
+ SFIFO_TEST (rv == 11, "expected %u chunks got %u", 11, rv);
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
+ " not be set");
+
+ /*
+ * Fifo wrap and multiple chunks used
+ */
+
+ /* Init test data and fifo */
+ test_n_bytes = f->nitems;
+ vec_validate (test_data, test_n_bytes - 1);
+ vec_validate (data_buf, vec_len (test_data));
+
+ for (i = 0; i < vec_len (test_data); i++)
+ test_data[i] = i;
+
+ svm_fifo_init_pointers (f, f->size / 2, f->size / 2);
+ for (i = 0; i < test_n_bytes; i++)
+ {
+ rv = svm_fifo_enqueue (f, sizeof (u8), &test_data[i]);
+ if (rv < 0)
+ SFIFO_TEST (0, "enqueue returned");
+ }
+
+ /* Try to reduce fifo size with fifo full */
+ rv = svm_fifo_reduce_size (f, 3.5 * chunk_size, 0);
+ SFIFO_TEST (rv == 3 * chunk_size, "len expected %u is %u", 3 * chunk_size,
+ rv);
+ SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
+ 11 * chunk_size + 1, f->size);
+ SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
+
+ /* Check enqueue space to try size reduction. Should not work */
+ rv = svm_fifo_max_enqueue (f);
+
+ SFIFO_TEST (rv == 0, "free space expected %u is %u", 0, rv);
+ SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
+ 11 * chunk_size + 1, f->size);
+ SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
+ " not be set");
+
+ /* Dequeue byte-by-byte up to last byte on last chunk */
+ deq_bytes = f->size - f->size / 2 - 1;
+ for (i = 0; i < deq_bytes; i++)
+ {
+ (void) svm_fifo_max_enqueue (f);
+ rv = svm_fifo_dequeue (f, 1, &data_buf[i]);
+ if (rv < 0)
+ SFIFO_TEST (0, "dequeue returned");
+ }
+
+ rv = svm_fifo_max_enqueue (f);
+
+ /* We've dequeued more than 3*chunk_size so nitems should be updated */
+ SFIFO_TEST (f->nitems == 8 * chunk_size, "nitems expected %u is %u",
+ 8 * chunk_size, f->nitems);
+ /* Free space should be what was dequeued - 3 * chunk_size, which was
+ * consumed by shrinking the fifo */
+ diff = deq_bytes - 3 * chunk_size;
+ SFIFO_TEST (rv == diff, "free space expected %u is %u", diff, rv);
+ SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
+ 11 * chunk_size + 1, f->size);
+ SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
+ " not be set");
+
+ /* Dequeue one more such that head goes beyond last chunk */
+ rv = svm_fifo_dequeue (f, 1, &data_buf[deq_bytes]);
+ if (rv < 0)
+ SFIFO_TEST (0, "dequeue returned");
+
+ rv = svm_fifo_max_enqueue (f);
+ SFIFO_TEST (f->nitems == 8 * chunk_size, "nitems expected %u is %u",
+ 8 * chunk_size, f->nitems);
+ SFIFO_TEST (rv == diff + 1, "free space expected %u is %u", diff + 1, rv);
+ SFIFO_TEST (f->size == 8 * chunk_size + 1, "size expected %u is %u",
+ 8 * chunk_size + 1, f->size);
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_SHRINK), "shrink flag should not be"
+ " set");
+ SFIFO_TEST (f->flags & SVM_FIFO_F_COLLECT_CHUNKS, "collect flag should"
+ " be set");
+
+ /* Dequeue the rest of the data */
+ deq_bytes += 1;
+ for (i = 0; i < test_n_bytes - deq_bytes; i++)
+ {
+ rv = svm_fifo_dequeue (f, 1, &data_buf[i + deq_bytes]);
+ if (rv < 0)
+ SFIFO_TEST (0, "dequeue returned");
+ }
+
+ rv = svm_fifo_max_enqueue (f);
+
+ SFIFO_TEST (f->size == 8 * chunk_size + 1, "size expected %u is %u",
+ 8 * chunk_size + 1, f->size);
+ SFIFO_TEST (rv == 8 * chunk_size, "free space expected %u is %u",
+ 8 * chunk_size, rv);
+ rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
+ (u32 *) & i);
+ if (rv)
+ SFIFO_TEST (0, "[%d] dequeued %u expected %u", i, data_buf[i],
+ test_data[i]);
+
+ c = svm_fifo_collect_chunks (f);
+ rv = chunk_list_len (c);
+ SFIFO_TEST (rv == 3, "expected %u chunks got %u", 3, rv);
+ rv = chunk_list_len (f->start_chunk);
+ SFIFO_TEST (rv == 8, "expected %u chunks got %u", 8, rv);
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
+ " not be set");
+
+ /*
+ * OOO segment on chunk that should be removed
+ */
+
+ svm_fifo_add_chunk (f, c);
+ SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
+ 11 * chunk_size + 1, f->size);
+
+ memset (data_buf, 0, vec_len (data_buf));
+ svm_fifo_init_pointers (f, f->size / 2, f->size / 2);
+ svm_fifo_enqueue (f, 200, test_data);
+ svm_fifo_enqueue_with_offset (f, 50, vec_len (test_data) - 250,
+ &test_data[250]);
+
+ /* Free space */
+ rv = svm_fifo_max_enqueue (f);
+ SFIFO_TEST (rv == vec_len (test_data) - 200, "free space expected %u is %u",
+ vec_len (test_data) - 200, rv);
+
+ /* Ask to reduce size */
+ rv = svm_fifo_reduce_size (f, 3.5 * chunk_size, 0);
+ SFIFO_TEST (rv == 3 * chunk_size, "len expected %u is %u", 3 * chunk_size,
+ rv);
+ SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
+ 11 * chunk_size + 1, f->size);
+ SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
+
+ /* Try to force size reduction but it should fail */
+ rv = svm_fifo_max_enqueue (f);
+
+ SFIFO_TEST (rv == vec_len (test_data) - 200, "free space expected %u is %u",
+ vec_len (test_data) - 200, rv);
+ SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
+ 11 * chunk_size + 1, f->size);
+ SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
+ " not be set");
+
+ /* Dequeue the in order data. This should shrink nitems */
+ rv = svm_fifo_dequeue (f, 200, data_buf);
+ if (rv < 0)
+ SFIFO_TEST (0, "dequeue returned");
+
+ rv = svm_fifo_max_enqueue (f);
+ SFIFO_TEST (rv == vec_len (test_data) - 200, "free space expected %u is %u",
+ vec_len (test_data) - 200, rv);
+ SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
+ 11 * chunk_size + 1, f->size);
+ SFIFO_TEST (f->nitems == 11 * chunk_size - 200, "nitems expected %u is %u",
+ 11 * chunk_size - 200, f->nitems);
+ SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
+ " not be set");
+
+ /* Enqueue the missing 50 bytes. Fifo will become full */
+ rv = svm_fifo_enqueue (f, 50, &test_data[200]);
+ SFIFO_TEST (rv == vec_len (test_data) - 200, "free space expected %u is %u",
+ vec_len (test_data) - 200, rv);
+
+ rv = svm_fifo_max_enqueue (f);
+
+ SFIFO_TEST (rv == 0, "free space expected %u is %u", 0, rv);
+ SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
+ 11 * chunk_size + 1, f->size);
+ SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
+ " not be set");
+
+
+ /* Dequeue a chunk and check nitems shrink but fifo still full */
+ svm_fifo_dequeue (f, 100, &data_buf[200]);
+
+ rv = svm_fifo_max_enqueue (f);
+
+ SFIFO_TEST (rv == 0, "free space expected %u is %u", 0, rv);
+ SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
+ 11 * chunk_size + 1, f->size);
+ SFIFO_TEST (f->nitems == 11 * chunk_size - 300, "nitems expected %u is %u",
+ 11 * chunk_size - 300, f->nitems);
+ SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
+ " not be set");
+
+ /* Dequeue enough to unwrap the fifo */
+ deq_bytes = f->size - f->size / 2 - 300;
+ svm_fifo_dequeue (f, deq_bytes, &data_buf[300]);
+ rv = svm_fifo_max_enqueue (f);
+
+ /* Overall we've dequeued deq_bytes + 300, but fifo size shrunk 300 */
+ SFIFO_TEST (rv == 300 + deq_bytes - 300, "free space expected %u is %u",
+ 300 + deq_bytes - 300, rv);
+ SFIFO_TEST (f->size == 8 * chunk_size + 1, "size expected %u is %u",
+ 8 * chunk_size + 1, f->size);
+ SFIFO_TEST (f->nitems == 8 * chunk_size, "nitems expected %u is %u",
+ 8 * chunk_size, f->nitems);
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_SHRINK), "shrink flag should not be"
+ " set");
+ SFIFO_TEST (f->flags & SVM_FIFO_F_COLLECT_CHUNKS, "collect flag should"
+ " be set");
+
+ /* Dequeue the rest */
+ svm_fifo_dequeue (f, test_n_bytes / 2, &data_buf[300 + deq_bytes]);
+ rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
+ (u32 *) & i);
+ if (rv)
+ SFIFO_TEST (0, "[%d] dequeued %u expected %u", i, data_buf[i],
+ test_data[i]);
+
+ c = svm_fifo_collect_chunks (f);
+ rv = chunk_list_len (c);
+ SFIFO_TEST (rv == 3, "expected %u chunks got %u", 3, rv);
+ rv = chunk_list_len (f->start_chunk);
+ SFIFO_TEST (rv == 8, "expected %u chunks got %u", 8, rv);
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
+ " not be set");
+
+ chunk_list_splice (collected, c);
+
+ /*
+ * Remove all chunks possible
+ */
+ svm_fifo_init_pointers (f, 601, 601);
+ rv = svm_fifo_reduce_size (f, 8 * chunk_size, 1);
+ SFIFO_TEST (rv == 7 * chunk_size, "actual len expected %u is %u",
+ 7 * chunk_size, rv);
+ SFIFO_TEST (f->size == 6 * chunk_size + 1, "size expected %u is %u",
+ 6 * chunk_size + 1, f->size);
+ SFIFO_TEST (f->nitems == 1 * chunk_size, "nitems expected %u is %u",
+ 1 * chunk_size, f->nitems);
+ SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
+ " not be set");
+
+ rv = svm_fifo_max_enqueue (f);
+ SFIFO_TEST (rv == chunk_size, "free space expected %u is %u", chunk_size,
+ rv);
+
+ /* Force head/tail to move to first chunk */
+ svm_fifo_enqueue (f, 1, test_data);
+ svm_fifo_dequeue (f, 1, data_buf);
+ rv = svm_fifo_max_enqueue (f);
+
+ SFIFO_TEST (rv == chunk_size, "free space expected %u is %u", chunk_size,
+ rv);
+ SFIFO_TEST (f->size == chunk_size + 1, "size expected %u is %u",
+ chunk_size + 1, f->size);
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_SHRINK), "shrink flag should not be"
+ " set");
+ SFIFO_TEST (f->flags & SVM_FIFO_F_COLLECT_CHUNKS, "collect flag should"
+ " be set");
+
+ c = svm_fifo_collect_chunks (f);
+ rv = chunk_list_len (c);
+ SFIFO_TEST (rv == 7, "expected %u chunks got %u", 7, rv);
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
+ " not be set");
+ SFIFO_TEST (!(f->flags & SVM_FIFO_F_MULTI_CHUNK), "multi-chunk flag should"
+ " not be set");
+
+ chunk_list_splice (collected, c);
+
+ /*
+ * Cleanup
+ */
+
+ chunk_list_free (f->start_chunk->next, f->start_chunk);
+ chunk_list_free (collected, 0);
+ svm_fifo_free (f);
+ vec_free (test_data);
vec_free (data_buf);
+
return 0;
}
vec_validate (retrieved_data, vec_len (test_data) - 1);
while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
- svm_fifo_enqueue_nowait (f, vec_len (test_data), test_data);
+ svm_fifo_enqueue (f, vec_len (test_data), test_data);
while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
- svm_fifo_dequeue_nowait (f, vec_len (retrieved_data), retrieved_data);
+ svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
- svm_fifo_enqueue_nowait (f, vec_len (test_data), test_data);
+ svm_fifo_enqueue (f, vec_len (test_data), test_data);
while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
- svm_fifo_dequeue_nowait (f, vec_len (retrieved_data), retrieved_data);
+ svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
SFIFO_TEST (!memcmp (retrieved_data, test_data, vec_len (test_data)),
"data should be identical");
static int
sfifo_test_fifo_segment_fifo_grow (int verbose)
{
+ int rv, fifo_size = 4096, n_chunks, n_free;
fifo_segment_main_t *sm = &segment_main;
fifo_segment_create_args_t _a, *a = &_a;
- int rv, fifo_size = 4096, n_chunks;
fifo_segment_t *fs;
svm_fifo_t *f;
*/
fifo_segment_free_fifo (fs, f);
+ /* fifo allocation allocates chunks in batch */
+ n_free = FIFO_SEGMENT_ALLOC_BATCH_SIZE;
+
n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
- SFIFO_TEST (n_chunks == 1, "free 2^10B chunks should be %u is %u", 1,
- n_chunks);
+ SFIFO_TEST (n_chunks == n_free, "free 2^10B chunks "
+ "should be %u is %u", n_free, n_chunks);
n_chunks = fifo_segment_num_free_chunks (fs, 16 * fifo_size);
SFIFO_TEST (n_chunks == 1, "free 2^14B chunks should be %u is %u", 1,
n_chunks);
n_chunks = fifo_segment_num_free_chunks (fs, ~0);
- SFIFO_TEST (n_chunks == 2, "free chunks should be %u is %u", 2, n_chunks);
+ SFIFO_TEST (n_chunks == 1 + n_free, "free chunks should be %u is %u",
+ 1 + n_free, n_chunks);
/*
* Realloc fifo
fifo_segment_grow_fifo (fs, f, fifo_size);
n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
- SFIFO_TEST (n_chunks == 0, "free 2^10B chunks should be %u is %u", 0,
- n_chunks);
+ SFIFO_TEST (n_chunks == n_free - 2, "free 2^10B chunks should be %u is %u",
+ n_free - 2, n_chunks);
fifo_segment_grow_fifo (fs, f, 16 * fifo_size);
+ n_chunks = fifo_segment_num_free_chunks (fs, 16 * fifo_size);
SFIFO_TEST (n_chunks == 0, "free 2^14B chunks should be %u is %u", 0,
n_chunks);
n_chunks = fifo_segment_num_free_chunks (fs, ~0);
- SFIFO_TEST (n_chunks == 0, "free chunks should be %u is %u", 0, n_chunks);
+ SFIFO_TEST (n_chunks == n_free - 2, "free chunks should be %u is %u",
+ n_free - 2, n_chunks);
/*
* Free again
*/
fifo_segment_free_fifo (fs, f);
n_chunks = fifo_segment_num_free_chunks (fs, ~0);
- SFIFO_TEST (n_chunks == 2, "free chunks should be %u is %u", 2, n_chunks);
+ SFIFO_TEST (n_chunks == 1 + n_free, "free chunks should be %u is %u",
+ 1 + n_free, n_chunks);
+
+ /*
+ * Cleanup
+ */
+ fifo_segment_delete (sm, fs);
+ vec_free (a->new_segment_indices);
+ return 0;
+}
+
+static int
+sfifo_test_fifo_segment_fifo_shrink (int verbose)
+{
+ int i, rv, chunk_size = 4096, n_chunks, n_free;
+ fifo_segment_main_t *sm = &segment_main;
+ fifo_segment_create_args_t _a, *a = &_a;
+ fifo_segment_t *fs;
+ svm_fifo_t *f;
+
+ clib_memset (a, 0, sizeof (*a));
+ a->segment_name = "fifo-test1";
+ a->segment_size = 256 << 10;
+
+ rv = fifo_segment_create (sm, a);
+
+ SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
+
+ /*
+ * Alloc and grow fifo
+ */
+ fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
+ f = fifo_segment_alloc_fifo (fs, chunk_size, FIFO_SEGMENT_RX_FIFO);
+ n_free = FIFO_SEGMENT_ALLOC_BATCH_SIZE - 1;
+
+ SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo");
+
+ for (i = 0; i < 9; i++)
+ {
+ fifo_segment_grow_fifo (fs, f, chunk_size);
+ n_free -= 1;
+ if (f->size != (i + 2) * chunk_size)
+ SFIFO_TEST (0, "fifo size should be %u is %u",
+ (i + 2) * chunk_size, f->size);
+ }
+
+ rv = svm_fifo_reduce_size (f, 3.5 * chunk_size, 1 /* is producer */ );
+ SFIFO_TEST (rv == 3 * chunk_size, "len expected %u is %u", 3 * chunk_size,
+ rv);
+
+ n_chunks = fifo_segment_num_free_chunks (fs, chunk_size);
+ SFIFO_TEST (n_chunks == n_free, "free chunks should be %u is %u", n_free,
+ n_chunks);
+
+ fifo_segment_collect_fifo_chunks (fs, f);
+
+ n_free += 3;
+ n_chunks = fifo_segment_num_free_chunks (fs, chunk_size);
+ SFIFO_TEST (n_chunks == n_free, "free chunks should be %u is %u", n_free,
+ n_chunks);
+
+ rv = svm_fifo_reduce_size (f, 7 * chunk_size - 1, 1 /* is producer */ );
+ SFIFO_TEST (rv == 6 * chunk_size, "len expected %u is %u", 6 * chunk_size,
+ rv);
+
+ fifo_segment_collect_fifo_chunks (fs, f);
+
+ n_free += 6;
+ n_chunks = fifo_segment_num_free_chunks (fs, chunk_size);
+ SFIFO_TEST (n_chunks == n_free, "free chunks should be %u is %u", n_free,
+ n_chunks);
+ /*
+ * Free
+ */
+ fifo_segment_free_fifo (fs, f);
+ n_free += 1;
+ n_chunks = fifo_segment_num_free_chunks (fs, ~0);
+ SFIFO_TEST (n_chunks == n_free, "free chunks should be %u is %u", n_free,
+ n_chunks);
/*
* Cleanup
for (i = 0; i < 1000; i++)
{
- svm_fifo_dequeue_nowait (f, vec_len (retrieved_data), retrieved_data);
+ svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
if (memcmp (retrieved_data, test_data, vec_len (retrieved_data)))
{
result = (u32 *) f->head_chunk->data;
usleep (200e3);
for (i = 0; i < 1000; i++)
- svm_fifo_enqueue_nowait (f, vec_len (test_data), test_data);
+ svm_fifo_enqueue (f, vec_len (test_data), test_data);
/* Wait for slave */
i = 0;
if ((rv = sfifo_test_fifo_segment_fifo_grow (verbose)))
return -1;
}
+ else if (unformat (input, "shrink fifo"))
+ {
+ if ((rv = sfifo_test_fifo_segment_fifo_shrink (verbose)))
+ return -1;
+ }
else if (unformat (input, "all"))
{
if ((rv = sfifo_test_fifo_segment_hello_world (verbose)))
return -1;
if ((rv = sfifo_test_fifo_segment_fifo_grow (verbose)))
return -1;
+ if ((rv = sfifo_test_fifo_segment_fifo_shrink (verbose)))
+ return -1;
/* Pretty slow so avoid running it always
if ((rv = sfifo_test_fifo_segment_master_slave (verbose)))
return -1;
res = sfifo_test_fifo_replay (vm, input);
else if (unformat (input, "grow"))
res = sfifo_test_fifo_grow (vm, input);
+ else if (unformat (input, "shrink"))
+ res = sfifo_test_fifo_shrink (vm, input);
else if (unformat (input, "segment"))
res = sfifo_test_fifo_segment (vm, input);
else if (unformat (input, "all"))
if ((res = sfifo_test_fifo_grow (vm, input)))
goto done;
+ if ((res = sfifo_test_fifo_shrink (vm, input)))
+ goto done;
+
str = "all";
unformat_init_cstring (input, str);
if ((res = sfifo_test_fifo_segment (vm, input)))
Code Review / vpp.git / blobdiff