src/plugins/unittest/svm_fifo_test.c

   1 /*
   2  * Copyright (c) 2019 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 #include <svm/svm_fifo.h>
  16 #include <vlib/vlib.h>
  17 #include <svm/fifo_segment.h>
  18
  19 #define SFIFO_TEST_I(_cond, _comment, _args...)                 \
  20 ({                                                              \
  21   int _evald = (_cond);                                         \
  22   if (!(_evald)) {                                              \
  23     fformat(stderr, "FAIL:%d: " _comment "\n",                  \
  24             __LINE__, ##_args);                                 \
  25   } else {                                                      \
  26     fformat(stderr, "PASS:%d: " _comment "\n",                  \
  27             __LINE__, ##_args);                                 \
  28   }                                                             \
  29   _evald;                                                       \
  30 })
  31
  32 #define SFIFO_TEST(_cond, _comment, _args...)                   \
  33 {                                                               \
  34     if (!SFIFO_TEST_I(_cond, _comment, ##_args)) {              \
  35         return 1;                                               \
  36     }                                                           \
  37 }
  38
  39 typedef struct
  40 {
  41   u32 offset;
  42   u32 len;
  43 } test_pattern_t;
  44
  45 /* *INDENT-OFF* */
  46 test_pattern_t test_pattern[] = {
  47   {380, 8}, {768, 8}, {1156, 8}, {1544, 8}, {1932, 8}, {2320, 8}, {2708, 8},
  48   {2992, 8}, {372, 8}, {760, 8}, {1148, 8}, {1536, 8}, {1924, 8}, {2312, 8},
  49   {2700, 8}, {2984, 8}, {364, 8}, {752, 8}, {1140, 8}, {1528, 8}, {1916, 8},
  50   {2304, 8}, {2692, 8}, {2976, 8}, {356, 8}, {744, 8}, {1132, 8}, {1520, 8},
  51   {1908, 8}, {2296, 8}, {2684, 8}, {2968, 8}, {348, 8}, {736, 8}, {1124, 8},
  52   {1512, 8}, {1900, 8}, {2288, 8}, {2676, 8}, {2960, 8}, {340, 8}, {728, 8},
  53   {1116, 8}, {1504, 8}, {1892, 8}, {2280, 8}, {2668, 8}, {2952, 8}, {332, 8},
  54   {720, 8}, {1108, 8}, {1496, 8}, {1884, 8}, {2272, 8}, {2660, 8}, {2944, 8},
  55   {324, 8}, {712, 8}, {1100, 8}, {1488, 8}, {1876, 8}, {2264, 8}, {2652, 8},
  56   {2936, 8}, {316, 8}, {704, 8}, {1092, 8}, {1480, 8}, {1868, 8}, {2256, 8},
  57   {2644, 8}, {2928, 8}, {308, 8}, {696, 8}, {1084, 8}, {1472, 8}, {1860, 8},
  58   {2248, 8}, {2636, 8}, {2920, 8}, {300, 8}, {688, 8}, {1076, 8}, {1464, 8},
  59   {1852, 8}, {2240, 8}, {2628, 8}, {2912, 8}, {292, 8}, {680, 8}, {1068, 8},
  60   {1456, 8}, {1844, 8}, {2232, 8}, {2620, 8}, {2904, 8}, {284, 8}, {672, 8},
  61   {1060, 8}, {1448, 8}, {1836, 8}, {2224, 8}, {2612, 8}, {2896, 8}, {276, 8},
  62   {664, 8}, {1052, 8}, {1440, 8}, {1828, 8},  {2216, 8}, {2604, 8}, {2888, 8},
  63   {268, 8}, {656, 8}, {1044, 8}, {1432, 8}, {1820, 8}, {2208, 8}, {2596, 8},
  64   {2880, 8}, {260, 8}, {648, 8}, {1036, 8}, {1424, 8}, {1812, 8}, {2200, 8},
  65   {2588, 8}, {2872, 8}, {252, 8}, {640, 8}, {1028, 8}, {1416, 8}, {1804, 8},
  66   {2192, 8}, {2580, 8}, {2864, 8}, {244, 8}, {632, 8}, {1020, 8}, {1408, 8},
  67   {1796, 8}, {2184, 8}, {2572, 8}, {2856, 8}, {236, 8}, {624, 8}, {1012, 8},
  68   {1400, 8}, {1788, 8}, {2176, 8}, {2564, 8}, {2848, 8}, {228, 8}, {616, 8},
  69   {1004, 8}, {1392, 8}, {1780, 8}, {2168, 8}, {2556, 8}, {2840, 8}, {220, 8},
  70   {608, 8}, {996, 8}, {1384, 8}, {1772, 8}, {2160, 8}, {2548, 8}, {2832, 8},
  71   {212, 8}, {600, 8}, {988, 8}, {1376, 8}, {1764, 8}, {2152, 8}, {2540, 8},
  72   {2824, 8}, {204, 8}, {592, 8}, {980, 8}, {1368, 8}, {1756, 8}, {2144, 8},
  73   {2532, 8}, {2816, 8}, {196, 8}, {584, 8}, {972, 8}, {1360, 8}, {1748, 8},
  74   {2136, 8}, {2524, 8}, {2808, 8}, {188, 8}, {576, 8}, {964, 8}, {1352, 8},
  75   {1740, 8}, {2128, 8}, {2516, 8}, {2800, 8}, {180, 8}, {568, 8}, {956, 8},
  76   {1344, 8}, {1732, 8}, {2120, 8}, {2508, 8}, {2792, 8}, {172, 8}, {560, 8},
  77   {948, 8}, {1336, 8}, {1724, 8}, {2112, 8}, {2500, 8}, {2784, 8}, {164, 8},
  78   {552, 8}, {940, 8}, {1328, 8}, {1716, 8}, {2104, 8}, {2492, 8}, {2776, 8},
  79   {156, 8}, {544, 8}, {932, 8}, {1320, 8}, {1708, 8}, {2096, 8}, {2484, 8},
  80   {2768, 8}, {148, 8}, {536, 8}, {924, 8}, {1312, 8}, {1700, 8}, {2088, 8},
  81   {2476, 8}, {2760, 8}, {140, 8}, {528, 8}, {916, 8}, {1304, 8}, {1692, 8},
  82   {2080, 8}, {2468, 8}, {2752, 8}, {132, 8}, {520, 8}, {908, 8}, {1296, 8},
  83   {1684, 8}, {2072, 8}, {2460, 8}, {2744, 8}, {124, 8}, {512, 8}, {900, 8},
  84   {1288, 8}, {1676, 8}, {2064, 8}, {2452, 8}, {2736, 8}, {116, 8}, {504, 8},
  85   {892, 8}, {1280, 8}, {1668, 8}, {2056, 8}, {2444, 8}, {2728, 8}, {108, 8},
  86   {496, 8}, {884, 8}, {1272, 8}, {1660, 8}, {2048, 8}, {2436, 8}, {2720, 8},
  87   {100, 8}, {488, 8}, {876, 8}, {1264, 8}, {1652, 8}, {2040, 8}, {2428, 8},
  88   {2716, 4}, {92, 8}, {480, 8}, {868, 8}, {1256, 8}, {1644, 8}, {2032, 8},
  89   {2420, 8}, {84, 8}, {472, 8}, {860, 8}, {1248, 8}, {1636, 8}, {2024, 8},
  90   {2412, 8}, {76, 8}, {464, 8}, {852, 8}, {1240, 8}, {1628, 8}, {2016, 8},
  91   {2404, 8}, {68, 8}, {456, 8}, {844, 8}, {1232, 8}, {1620, 8}, {2008, 8},
  92   {2396, 8}, {60, 8}, {448, 8}, {836, 8}, {1224, 8}, {1612, 8}, {2000, 8},
  93   {2388, 8}, {52, 8}, {440, 8}, {828, 8}, {1216, 8}, {1604, 8}, {1992, 8},
  94   {2380, 8}, {44, 8}, {432, 8}, {820, 8}, {1208, 8}, {1596, 8}, {1984, 8},
  95   {2372, 8}, {36, 8}, {424, 8}, {812, 8}, {1200, 8}, {1588, 8}, {1976, 8},
  96   {2364, 8}, {28, 8}, {416, 8}, {804, 8}, {1192, 8}, {1580, 8}, {1968, 8},
  97   {2356, 8}, {20, 8}, {408, 8}, {796, 8}, {1184, 8}, {1572, 8}, {1960, 8},
  98   {2348, 8}, {12, 8}, {400, 8}, {788, 8}, {1176, 8}, {1564, 8}, {1952, 8},
  99   {2340, 8}, {4, 8}, {392, 8}, {780, 8}, {1168, 8}, {1556, 8}, {1944, 8},
 100   {2332, 8},
 101   /* missing from original data set */
 102   {388, 4}, {776, 4}, {1164, 4}, {1552, 4}, {1940, 4}, {2328, 4},
 103 };
 104 /* *INDENT-ON* */
 105
 106 int
 107 pattern_cmp (const void *arg1, const void *arg2)
 108 {
 109   test_pattern_t *a1 = (test_pattern_t *) arg1;
 110   test_pattern_t *a2 = (test_pattern_t *) arg2;
 111
 112   if (a1->offset < a2->offset)
 113     return -1;
 114   else if (a1->offset > a2->offset)
 115     return 1;
 116   return 0;
 117 }
 118
 119 static u8
 120 fifo_validate_pattern (vlib_main_t * vm, test_pattern_t * pattern,
 121                        u32 pattern_length)
 122 {
 123   test_pattern_t *tp = pattern;
 124   int i;
 125
 126   /* Go through the pattern and make 100% sure it's sane */
 127   for (i = 0; i < pattern_length - 1; i++)
 128     {
 129       if (tp->offset + tp->len != (tp + 1)->offset)
 130         {
 131           vlib_cli_output (vm, "[%d] missing {%d, %d}", i,
 132                            (tp->offset + tp->len),
 133                            (tp + 1)->offset - (tp->offset + tp->len));
 134           return 0;
 135         }
 136       tp++;
 137     }
 138   return 1;
 139 }
 140
 141 static test_pattern_t *
 142 fifo_get_validate_pattern (vlib_main_t * vm, test_pattern_t * test_data,
 143                            u32 test_data_len)
 144 {
 145   test_pattern_t *validate_pattern = 0;
 146
 147   /* Validate, and try segments in order... */
 148   vec_validate (validate_pattern, test_data_len - 1);
 149   memcpy (validate_pattern, test_data,
 150           test_data_len * sizeof (test_pattern_t));
 151   qsort ((u8 *) validate_pattern, test_data_len, sizeof (test_pattern_t),
 152          pattern_cmp);
 153
 154   if (fifo_validate_pattern (vm, validate_pattern, test_data_len) == 0)
 155     return 0;
 156
 157   return validate_pattern;
 158 }
 159
 160 static svm_fifo_t *
 161 fifo_prepare (u32 fifo_size)
 162 {
 163   svm_fifo_t *f;
 164   f = svm_fifo_create (fifo_size);
 165
 166   /* Paint fifo data vector with -1's */
 167   clib_memset (f->head_chunk->data, 0xFF, fifo_size);
 168
 169   return f;
 170 }
 171
 172 static int
 173 compare_data (u8 * data1, u8 * data2, u32 start, u32 len, u32 * index)
 174 {
 175   int i;
 176
 177   for (i = start; i < start + len; i++)
 178     {
 179       if (data1[i] != data2[i])
 180         {
 181           *index = i;
 182           return 1;
 183         }
 184     }
 185   return 0;
 186 }
 187
 188 int
 189 sfifo_test_fifo1 (vlib_main_t * vm, unformat_input_t * input)
 190 {
 191   svm_fifo_t *f;
 192   u32 fifo_size = 1 << 20;
 193   u32 *test_data = 0;
 194   u32 offset;
 195   int i, rv, verbose = 0;
 196   u32 data_word, test_data_len, j;
 197   ooo_segment_t *ooo_seg;
 198   u8 *data, *s, *data_buf = 0;
 199
 200   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 201     {
 202       if (unformat (input, "verbose"))
 203         verbose = 1;
 204     }
 205
 206   test_data_len = fifo_size / sizeof (u32);
 207   vec_validate (test_data, test_data_len - 1);
 208
 209   for (i = 0; i < vec_len (test_data); i++)
 210     test_data[i] = i;
 211
 212   f = fifo_prepare (fifo_size);
 213
 214   /*
 215    * Enqueue an initial (un-dequeued) chunk
 216    */
 217   rv = svm_fifo_enqueue (f, sizeof (u32), (u8 *) test_data);
 218   SFIFO_TEST ((rv == sizeof (u32)), "enqueued %d", rv);
 219   SFIFO_TEST ((f->tail == 4), "fifo tail %u", f->tail);
 220
 221   /*
 222    * Create 3 chunks in the future. The offsets are relative
 223    * to the current fifo tail
 224    */
 225   for (i = 0; i < 3; i++)
 226     {
 227       offset = (2 * i + 1) * sizeof (u32) - f->tail;
 228       data = (u8 *) (test_data + (2 * i + 1));
 229       if (i == 0)
 230         {
 231           rv = svm_fifo_enqueue (f, sizeof (u32), data);
 232           rv = rv > 0 ? 0 : rv;
 233         }
 234       else
 235         rv = svm_fifo_enqueue_with_offset (f, offset, sizeof (u32), data);
 236       if (verbose)
 237         vlib_cli_output (vm, "add [%d] [%d, %d]", 2 * i + 1, offset,
 238                          offset + sizeof (u32));
 239       if (rv)
 240         {
 241           clib_warning ("enqueue returned %d", rv);
 242           goto err;
 243         }
 244     }
 245
 246   if (verbose)
 247     vlib_cli_output (vm, "fifo after odd segs: %U", format_svm_fifo, f, 1);
 248
 249   SFIFO_TEST ((f->tail == 8), "fifo tail %u", f->tail);
 250   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 2),
 251               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 252
 253   /*
 254    * Try adding a completely overlapped segment
 255    */
 256   offset = 3 * sizeof (u32) - f->tail;
 257   data = (u8 *) (test_data + 3);
 258   rv = svm_fifo_enqueue_with_offset (f, offset, sizeof (u32), data);
 259   if (rv)
 260     {
 261       clib_warning ("enqueue returned %d", rv);
 262       goto err;
 263     }
 264
 265   if (verbose)
 266     vlib_cli_output (vm, "fifo after overlap seg: %U", format_svm_fifo, f, 1);
 267
 268   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 2),
 269               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 270
 271   /*
 272    * Make sure format functions are not buggy
 273    */
 274   s = format (0, "%U", format_svm_fifo, f, 2);
 275   vec_free (s);
 276
 277   /*
 278    * Paint some of missing data backwards
 279    */
 280   for (i = 3; i > 1; i--)
 281     {
 282       offset = (2 * i + 0) * sizeof (u32) - f->tail;
 283       data = (u8 *) (test_data + (2 * i + 0));
 284       rv = svm_fifo_enqueue_with_offset (f, offset, sizeof (u32), data);
 285       if (verbose)
 286         vlib_cli_output (vm, "add [%d] [%d, %d]", 2 * i, offset,
 287                          offset + sizeof (u32));
 288       if (rv)
 289         {
 290           clib_warning ("enqueue returned %d", rv);
 291           goto err;
 292         }
 293     }
 294
 295   if (verbose)
 296     vlib_cli_output (vm, "fifo before missing link: %U", format_svm_fifo, f,
 297                      1);
 298   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
 299               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 300   ooo_seg = svm_fifo_first_ooo_segment (f);
 301   SFIFO_TEST ((ooo_seg->start == 12),
 302               "first ooo seg position %u", ooo_seg->start);
 303   SFIFO_TEST ((ooo_seg->length == 16),
 304               "first ooo seg length %u", ooo_seg->length);
 305
 306   /*
 307    * Enqueue the missing u32
 308    */
 309   rv = svm_fifo_enqueue (f, sizeof (u32), (u8 *) (test_data + 2));
 310   if (verbose)
 311     vlib_cli_output (vm, "fifo after missing link: %U", format_svm_fifo, f,
 312                      1);
 313   SFIFO_TEST ((rv == 20), "bytes to be enqueued %u", rv);
 314   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
 315               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 316
 317   /*
 318    * Collect results
 319    */
 320   for (i = 0; i < 7; i++)
 321     {
 322       rv = svm_fifo_dequeue (f, sizeof (u32), (u8 *) & data_word);
 323       if (rv != sizeof (u32))
 324         {
 325           clib_warning ("bytes dequeues %u", rv);
 326           goto err;
 327         }
 328       if (data_word != test_data[i])
 329         {
 330           clib_warning ("recovered [%d] %d not %d", i, data_word,
 331                         test_data[i]);
 332           goto err;
 333         }
 334     }
 335
 336   /*
 337    * Test segment overlaps: last ooo segment overlaps all
 338    */
 339   svm_fifo_free (f);
 340   f = fifo_prepare (fifo_size);
 341
 342   for (i = 0; i < 4; i++)
 343     {
 344       offset = (2 * i + 1) * sizeof (u32) - f->tail;
 345       data = (u8 *) (test_data + (2 * i + 1));
 346       rv = svm_fifo_enqueue_with_offset (f, offset, sizeof (u32), data);
 347       if (verbose)
 348         vlib_cli_output (vm, "add [%d] [%d, %d]", 2 * i + 1, offset,
 349                          offset + sizeof (u32));
 350       if (rv)
 351         {
 352           clib_warning ("enqueue returned %d", rv);
 353           goto err;
 354         }
 355     }
 356
 357   rv = svm_fifo_enqueue_with_offset (f, 8 - f->tail, 21, data);
 358   SFIFO_TEST ((rv == 0), "ooo enqueued %u", rv);
 359   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
 360               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 361
 362   /* add missing data to be able to dequeue something */
 363   rv = svm_fifo_enqueue (f, 4, data);
 364   SFIFO_TEST ((rv == 32), "enqueued %u", rv);
 365   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
 366               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 367
 368   vec_validate (data_buf, vec_len (test_data));
 369   svm_fifo_peek (f, 0, 4, data_buf);
 370   if (compare_data (data_buf, data, 0, 4, &j))
 371     SFIFO_TEST (0, "[%d] peeked %u expected %u", j, data_buf[j], data[j]);
 372   svm_fifo_peek (f, 8, 21, data_buf);
 373   if (compare_data (data_buf, data, 0, 21, &j))
 374     SFIFO_TEST (0, "[%d] peeked %u expected %u", j, data_buf[j], data[j]);
 375   vec_reset_length (data_buf);
 376
 377   /*
 378    * Test segment overlaps: enqueue and overlap ooo segments
 379    */
 380   svm_fifo_free (f);
 381   f = fifo_prepare (fifo_size);
 382
 383   for (i = 0; i < 4; i++)
 384     {
 385       offset = (2 * i + 1) * sizeof (u32) - f->tail;
 386       data = (u8 *) (test_data + (2 * i + 1));
 387       rv = svm_fifo_enqueue_with_offset (f, offset, sizeof (u32), data);
 388       if (verbose)
 389         vlib_cli_output (vm, "add [%d] [%d, %d]", 2 * i + 1, offset,
 390                          offset + sizeof (u32));
 391       if (rv)
 392         {
 393           clib_warning ("enqueue returned %d", rv);
 394           goto err;
 395         }
 396     }
 397
 398   if (verbose)
 399     vlib_cli_output (vm, "fifo after enqueue: %U", format_svm_fifo, f, 1);
 400
 401   rv = svm_fifo_enqueue (f, 29, data);
 402   if (verbose)
 403     vlib_cli_output (vm, "fifo after enqueueing 29: %U", format_svm_fifo, f,
 404                      1);
 405   SFIFO_TEST ((rv == 32), "ooo enqueued %u", rv);
 406   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
 407               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 408
 409   vec_validate (data_buf, vec_len (data));
 410   svm_fifo_peek (f, 0, vec_len (data), data_buf);
 411   if (compare_data (data_buf, data, 0, vec_len (data), &j))
 412     {
 413       SFIFO_TEST (0, "[%d] peeked %u expected %u", j, data_buf[j], data[j]);
 414     }
 415
 416   /* Try to peek beyond the data */
 417   rv = svm_fifo_peek (f, svm_fifo_max_dequeue (f), vec_len (data), data_buf);
 418   SFIFO_TEST ((rv == 0), "peeked %u expected 0", rv);
 419
 420   vec_free (data_buf);
 421   svm_fifo_free (f);
 422   vec_free (test_data);
 423
 424   return 0;
 425
 426 err:
 427   svm_fifo_free (f);
 428   vec_free (test_data);
 429   return -1;
 430 }
 431
 432 static int
 433 sfifo_test_fifo2 (vlib_main_t * vm)
 434 {
 435   svm_fifo_t *f;
 436   u32 fifo_size = (1 << 20) + 1;
 437   int i, rv, test_data_len;
 438   u64 data64;
 439   test_pattern_t *tp, *vp, *test_data;
 440   ooo_segment_t *ooo_seg;
 441
 442   test_data = test_pattern;
 443   test_data_len = ARRAY_LEN (test_pattern);
 444
 445   vp = fifo_get_validate_pattern (vm, test_data, test_data_len);
 446
 447   /* Create a fifo */
 448   f = fifo_prepare (fifo_size);
 449
 450   /*
 451    * Try with sorted data
 452    */
 453   for (i = 0; i < test_data_len; i++)
 454     {
 455       tp = vp + i;
 456       data64 = tp->offset;
 457       svm_fifo_enqueue_with_offset (f, tp->offset - f->tail, tp->len,
 458                                     (u8 *) & data64);
 459     }
 460
 461   /* Expected result: one big fat chunk at offset 4 */
 462   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
 463               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 464   ooo_seg = svm_fifo_first_ooo_segment (f);
 465   SFIFO_TEST ((ooo_seg->start == 4),
 466               "first ooo seg position %u", ooo_seg->start);
 467   SFIFO_TEST ((ooo_seg->length == 2996),
 468               "first ooo seg length %u", ooo_seg->length);
 469
 470   data64 = 0;
 471   rv = svm_fifo_enqueue (f, sizeof (u32), (u8 *) & data64);
 472   SFIFO_TEST ((rv == 3000), "bytes to be enqueued %u", rv);
 473
 474   svm_fifo_free (f);
 475   vec_free (vp);
 476
 477   /*
 478    * Now try it again w/ unsorted data...
 479    */
 480
 481   f = fifo_prepare (fifo_size);
 482
 483   for (i = 0; i < test_data_len; i++)
 484     {
 485       tp = &test_data[i];
 486       data64 = tp->offset;
 487       rv = svm_fifo_enqueue_with_offset (f, tp->offset - f->tail, tp->len,
 488                                          (u8 *) & data64);
 489       if (rv)
 490         {
 491           clib_warning ("enqueue returned %d", rv);
 492         }
 493     }
 494
 495   /* Expecting the same result: one big fat chunk at offset 4 */
 496   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
 497               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 498   ooo_seg = svm_fifo_first_ooo_segment (f);
 499   SFIFO_TEST ((ooo_seg->start == 4),
 500               "first ooo seg position %u", ooo_seg->start);
 501   SFIFO_TEST ((ooo_seg->length == 2996),
 502               "first ooo seg length %u", ooo_seg->length);
 503
 504   data64 = 0;
 505   rv = svm_fifo_enqueue (f, sizeof (u32), (u8 *) & data64);
 506
 507   SFIFO_TEST ((rv == 3000), "bytes to be enqueued %u", rv);
 508
 509   svm_fifo_free (f);
 510
 511   return 0;
 512 }
 513
 514 static int
 515 sfifo_test_fifo3 (vlib_main_t * vm, unformat_input_t * input)
 516 {
 517   svm_fifo_t *f;
 518   u32 fifo_size = (4 << 10) + 1;
 519   u32 fifo_initial_offset = 0;
 520   u32 total_size = 2 << 10;
 521   int overlap = 0, verbose = 0, randomize = 1, drop = 0, in_seq_all = 0;
 522   u8 *data_pattern = 0, *data_buf = 0;
 523   test_pattern_t *tp, *generate = 0;
 524   u32 nsegs = 2, seg_size, length_so_far;
 525   u32 current_offset, offset_increment, len_this_chunk;
 526   u32 seed = 0xdeaddabe, j;
 527   int i, rv;
 528
 529   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 530     {
 531       if (unformat (input, "fifo-size %d", &fifo_size))
 532         ;
 533       else if (unformat (input, "total-size %d", &total_size))
 534         ;
 535       else if (unformat (input, "verbose"))
 536         verbose = 1;
 537       else if (unformat (input, "overlap"))
 538         overlap = 1;
 539       else if (unformat (input, "initial-offset %d", &fifo_initial_offset))
 540         ;
 541       else if (unformat (input, "seed %d", &seed))
 542         ;
 543       else if (unformat (input, "nsegs %d", &nsegs))
 544         ;
 545       else if (unformat (input, "no-randomize"))
 546         randomize = 0;
 547       else if (unformat (input, "in-seq-all"))
 548         in_seq_all = 1;
 549       else if (unformat (input, "drop"))
 550         drop = 1;
 551       else
 552         {
 553           clib_error_t *e = clib_error_return
 554             (0, "unknown input `%U'", format_unformat_error, input);
 555           clib_error_report (e);
 556           return -1;
 557         }
 558     }
 559
 560   if (total_size > fifo_size)
 561     {
 562       clib_warning ("total_size %d greater than fifo size %d", total_size,
 563                     fifo_size);
 564       return -1;
 565     }
 566   if (overlap && randomize == 0)
 567     {
 568       clib_warning ("Can't enqueue in-order with overlap");
 569       return -1;
 570     }
 571
 572   /*
 573    * Generate data
 574    */
 575   vec_validate (data_pattern, total_size - 1);
 576   for (i = 0; i < vec_len (data_pattern); i++)
 577     data_pattern[i] = i & 0xff;
 578
 579   /*
 580    * Generate segments
 581    */
 582   seg_size = total_size / nsegs;
 583   length_so_far = 0;
 584   current_offset = randomize;
 585   while (length_so_far < total_size)
 586     {
 587       vec_add2 (generate, tp, 1);
 588       len_this_chunk = clib_min (seg_size, total_size - length_so_far);
 589       tp->offset = current_offset;
 590       tp->len = len_this_chunk;
 591
 592       if (overlap && (len_this_chunk == seg_size))
 593         do
 594           {
 595             offset_increment = len_this_chunk
 596               % (1 + (random_u32 (&seed) % len_this_chunk));
 597           }
 598         while (offset_increment == 0);
 599       else
 600         offset_increment = len_this_chunk;
 601
 602       current_offset += offset_increment;
 603       length_so_far = tp->offset + tp->len;
 604     }
 605
 606   /*
 607    * Validate segment list. Only valid for non-overlap cases.
 608    */
 609   if (overlap == 0)
 610     fifo_validate_pattern (vm, generate, vec_len (generate));
 611
 612   if (verbose)
 613     {
 614       vlib_cli_output (vm, "raw data pattern:");
 615       for (i = 0; i < vec_len (generate); i++)
 616         {
 617           vlib_cli_output (vm, "[%d] offset %u len %u", i,
 618                            generate[i].offset, generate[i].len);
 619         }
 620     }
 621
 622   /* Randomize data pattern */
 623   if (randomize)
 624     {
 625       for (i = 0; i < vec_len (generate) / 2; i++)
 626         {
 627           u32 src_index, dst_index;
 628           test_pattern_t _tmp, *tmp = &_tmp;
 629
 630           src_index = random_u32 (&seed) % vec_len (generate);
 631           dst_index = random_u32 (&seed) % vec_len (generate);
 632
 633           tmp[0] = generate[dst_index];
 634           generate[dst_index] = generate[src_index];
 635           generate[src_index] = tmp[0];
 636         }
 637       if (verbose)
 638         {
 639           vlib_cli_output (vm, "randomized data pattern:");
 640           for (i = 0; i < vec_len (generate); i++)
 641             {
 642               vlib_cli_output (vm, "[%d] offset %u len %u", i,
 643                                generate[i].offset, generate[i].len);
 644             }
 645         }
 646     }
 647
 648   /*
 649    * Create a fifo and add segments
 650    */
 651   f = fifo_prepare (fifo_size);
 652
 653   /* manually set head and tail pointers to validate modular arithmetic */
 654   fifo_initial_offset = fifo_initial_offset % fifo_size;
 655   svm_fifo_init_pointers (f, fifo_initial_offset, fifo_initial_offset);
 656
 657   for (i = !randomize; i < vec_len (generate); i++)
 658     {
 659       tp = generate + i;
 660       svm_fifo_enqueue_with_offset (f,
 661                                     fifo_initial_offset + tp->offset -
 662                                     f->tail, tp->len,
 663                                     (u8 *) data_pattern + tp->offset);
 664     }
 665
 666   /* Add the first segment in order for non random data */
 667   if (!randomize)
 668     svm_fifo_enqueue (f, generate[0].len, (u8 *) data_pattern);
 669
 670   /*
 671    * Expected result: one big fat chunk at offset 1 if randomize == 1
 672    */
 673
 674   if (verbose)
 675     vlib_cli_output (vm, "fifo before missing link: %U",
 676                      format_svm_fifo, f, 1 /* verbose */ );
 677
 678   /*
 679    * Add the missing byte if segments were randomized
 680    */
 681   if (randomize)
 682     {
 683       u32 bytes_to_enq = 1;
 684       if (in_seq_all)
 685         bytes_to_enq = total_size;
 686       rv = svm_fifo_enqueue (f, bytes_to_enq, data_pattern + 0);
 687
 688       if (verbose)
 689         vlib_cli_output (vm, "in-order enqueue returned %d", rv);
 690
 691       SFIFO_TEST ((rv == total_size), "enqueued %u expected %u", rv,
 692                   total_size);
 693
 694     }
 695
 696   SFIFO_TEST ((svm_fifo_has_ooo_data (f) == 0), "number of ooo segments %u",
 697               svm_fifo_n_ooo_segments (f));
 698
 699   /*
 700    * Test if peeked data is the same as original data
 701    */
 702   vec_validate (data_buf, vec_len (data_pattern));
 703   svm_fifo_peek (f, 0, vec_len (data_pattern), data_buf);
 704   if (compare_data (data_buf, data_pattern, 0, vec_len (data_pattern), &j))
 705     {
 706       SFIFO_TEST (0, "[%d] peeked %u expected %u", j, data_buf[j],
 707                   data_pattern[j]);
 708     }
 709
 710   /*
 711    * Dequeue or drop all data
 712    */
 713   if (drop)
 714     {
 715       svm_fifo_dequeue_drop (f, vec_len (data_pattern));
 716     }
 717   else
 718     {
 719       memset (data_buf, 0, vec_len (data_pattern));
 720       svm_fifo_dequeue (f, vec_len (data_pattern), data_buf);
 721       if (compare_data
 722           (data_buf, data_pattern, 0, vec_len (data_pattern), &j))
 723         {
 724           SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
 725                       data_pattern[j]);
 726         }
 727     }
 728
 729   SFIFO_TEST ((svm_fifo_max_dequeue (f) == 0), "fifo has %d bytes",
 730               svm_fifo_max_dequeue (f));
 731
 732   svm_fifo_free (f);
 733   vec_free (data_pattern);
 734   vec_free (data_buf);
 735
 736   return 0;
 737 }
 738
 739 static int
 740 sfifo_test_fifo4 (vlib_main_t * vm, unformat_input_t * input)
 741 {
 742   svm_fifo_t *f;
 743   u32 fifo_size = 6 << 10;
 744   u32 fifo_initial_offset = 1000000000;
 745   u32 test_n_bytes = 5000, j;
 746   u8 *test_data = 0, *data_buf = 0;
 747   int i, rv, verbose = 0;
 748
 749   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 750     {
 751       if (unformat (input, "verbose"))
 752         verbose = 1;
 753       else
 754         {
 755           clib_error_t *e = clib_error_return
 756             (0, "unknown input `%U'", format_unformat_error, input);
 757           clib_error_report (e);
 758           return -1;
 759         }
 760     }
 761
 762   /*
 763    * Create a fifo and add segments
 764    */
 765   f = fifo_prepare (fifo_size);
 766
 767   /* Set head and tail pointers */
 768   fifo_initial_offset = fifo_initial_offset % fifo_size;
 769   svm_fifo_init_pointers (f, fifo_initial_offset, fifo_initial_offset);
 770
 771   vec_validate (test_data, test_n_bytes - 1);
 772   for (i = 0; i < vec_len (test_data); i++)
 773     test_data[i] = i;
 774
 775   for (i = test_n_bytes - 1; i > 0; i--)
 776     {
 777       rv = svm_fifo_enqueue_with_offset (f, fifo_initial_offset + i - f->tail,
 778                                          sizeof (u8), &test_data[i]);
 779       if (verbose)
 780         vlib_cli_output (vm, "add [%d] [%d, %d]", i, i, i + sizeof (u8));
 781       if (rv)
 782         {
 783           clib_warning ("enqueue returned %d", rv);
 784           svm_fifo_free (f);
 785           vec_free (test_data);
 786           return -1;
 787         }
 788     }
 789
 790   svm_fifo_enqueue (f, sizeof (u8), &test_data[0]);
 791
 792   vec_validate (data_buf, vec_len (test_data));
 793
 794   svm_fifo_dequeue (f, vec_len (test_data), data_buf);
 795   rv = compare_data (data_buf, test_data, 0, vec_len (test_data), &j);
 796   if (rv)
 797     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
 798                      test_data[j]);
 799   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
 800
 801   svm_fifo_free (f);
 802   vec_free (test_data);
 803   return 0;
 804 }
 805
 806 static u32
 807 fifo_pos (svm_fifo_t * f, u32 pos)
 808 {
 809   return pos % f->size;
 810 }
 811
 812 /* Avoids exposing svm_fifo.c internal function */
 813 static ooo_segment_t *
 814 ooo_seg_next (svm_fifo_t * f, ooo_segment_t * s)
 815 {
 816   if (pool_is_free_index (f->ooo_segments, s->next))
 817     return 0;
 818   return pool_elt_at_index (f->ooo_segments, s->next);
 819 }
 820
 821 static int
 822 sfifo_test_fifo5 (vlib_main_t * vm, unformat_input_t * input)
 823 {
 824   svm_fifo_t *f;
 825   u32 fifo_size = 401, j = 0, offset = 200;
 826   int i, rv, verbose = 0;
 827   u8 *test_data = 0, *data_buf = 0;
 828   ooo_segment_t *ooo_seg;
 829
 830   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 831     {
 832       if (unformat (input, "verbose"))
 833         verbose = 1;
 834       else
 835         {
 836           clib_error_t *e = clib_error_return (0, "unknown input `%U'",
 837                                                format_unformat_error, input);
 838           clib_error_report (e);
 839           return -1;
 840         }
 841     }
 842
 843   f = fifo_prepare (fifo_size);
 844   svm_fifo_init_pointers (f, offset, offset);
 845
 846   vec_validate (test_data, 399);
 847   for (i = 0; i < vec_len (test_data); i++)
 848     test_data[i] = i % 0xff;
 849
 850   /*
 851    * Start with [100, 200] and [300, 400]
 852    */
 853   svm_fifo_enqueue_with_offset (f, 100, 100, &test_data[100]);
 854   svm_fifo_enqueue_with_offset (f, 300, 100, &test_data[300]);
 855
 856   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 2),
 857               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 858   SFIFO_TEST ((f->ooos_newest == 1), "newest %u", f->ooos_newest);
 859   if (verbose)
 860     vlib_cli_output (vm, "fifo after [100, 200] and [300, 400] : %U",
 861                      format_svm_fifo, f, 2 /* verbose */ );
 862
 863   /*
 864    * Add [225, 275]
 865    */
 866
 867   rv = svm_fifo_enqueue_with_offset (f, 225, 50, &test_data[225]);
 868   if (verbose)
 869     vlib_cli_output (vm, "fifo after [225, 275] : %U",
 870                      format_svm_fifo, f, 2 /* verbose */ );
 871   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 3),
 872               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 873   ooo_seg = svm_fifo_first_ooo_segment (f);
 874   SFIFO_TEST ((ooo_seg->start == fifo_pos (f, 100 + offset)),
 875               "first seg start %u expected %u", ooo_seg->start,
 876               fifo_pos (f, 100 + offset));
 877   SFIFO_TEST ((ooo_seg->length == 100), "first seg length %u expected %u",
 878               ooo_seg->length, 100);
 879   ooo_seg = ooo_seg_next (f, ooo_seg);
 880   SFIFO_TEST ((ooo_seg->start == fifo_pos (f, 225 + offset)),
 881               "second seg start %u expected %u",
 882               ooo_seg->start, fifo_pos (f, 225 + offset));
 883   SFIFO_TEST ((ooo_seg->length == 50), "second seg length %u expected %u",
 884               ooo_seg->length, 50);
 885   ooo_seg = ooo_seg_next (f, ooo_seg);
 886   SFIFO_TEST ((ooo_seg->start == fifo_pos (f, 300 + offset)),
 887               "third seg start %u expected %u",
 888               ooo_seg->start, fifo_pos (f, 300 + offset));
 889   SFIFO_TEST ((ooo_seg->length == 100), "third seg length %u expected %u",
 890               ooo_seg->length, 100);
 891   SFIFO_TEST ((f->ooos_newest == 2), "newest %u", f->ooos_newest);
 892   /*
 893    * Add [190, 310]
 894    */
 895   rv = svm_fifo_enqueue_with_offset (f, 190, 120, &test_data[190]);
 896   if (verbose)
 897     vlib_cli_output (vm, "fifo after [190, 310] : %U",
 898                      format_svm_fifo, f, 1 /* verbose */ );
 899   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
 900               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 901   ooo_seg = svm_fifo_first_ooo_segment (f);
 902   SFIFO_TEST ((ooo_seg->start == fifo_pos (f, offset + 100)),
 903               "first seg start %u expected %u",
 904               ooo_seg->start, fifo_pos (f, offset + 100));
 905   SFIFO_TEST ((ooo_seg->length == 300), "first seg length %u expected %u",
 906               ooo_seg->length, 300);
 907
 908   /*
 909    * Add [0, 150]
 910    */
 911   rv = svm_fifo_enqueue (f, 150, test_data);
 912
 913   if (verbose)
 914     vlib_cli_output (vm, "fifo after [0 150] : %U", format_svm_fifo, f,
 915                      2 /* verbose */ );
 916
 917   SFIFO_TEST ((rv == 400), "managed to enqueue %u expected %u", rv, 400);
 918   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
 919               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 920
 921   vec_validate (data_buf, 399);
 922   svm_fifo_peek (f, 0, 400, data_buf);
 923   if (compare_data (data_buf, test_data, 0, 400, &j))
 924     {
 925       SFIFO_TEST (0, "[%d] peeked %u expected %u", j, data_buf[j],
 926                   test_data[j]);
 927     }
 928
 929   /*
 930    * Add [100 200] and overlap it with [50 250]
 931    */
 932   svm_fifo_free (f);
 933   f = fifo_prepare (fifo_size);
 934
 935   svm_fifo_enqueue_with_offset (f, 100, 100, &test_data[100]);
 936   svm_fifo_enqueue_with_offset (f, 50, 200, &test_data[50]);
 937   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
 938               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 939   ooo_seg = svm_fifo_first_ooo_segment (f);
 940   SFIFO_TEST ((ooo_seg->start == 50), "first seg start %u expected %u",
 941               ooo_seg->start, 50);
 942   SFIFO_TEST ((ooo_seg->length == 200), "first seg length %u expected %u",
 943               ooo_seg->length, 200);
 944
 945   svm_fifo_free (f);
 946   vec_free (test_data);
 947   return 0;
 948 }
 949
 950 /*
 951  * Test ooo head/tail u32 wrapping
 952  */
 953 static int
 954 sfifo_test_fifo6 (vlib_main_t * vm, unformat_input_t * input)
 955 {
 956   u32 fifo_size = 101, n_test_bytes = 100;
 957   int i, j, rv, __clib_unused verbose = 0;
 958   u8 *test_data = 0, *data_buf = 0;
 959   ooo_segment_t *ooo_seg;
 960   svm_fifo_t *f;
 961
 962   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 963     {
 964       if (unformat (input, "verbose"))
 965         verbose = 1;
 966       else
 967         {
 968           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
 969                            input);
 970           return -1;
 971         }
 972     }
 973
 974   f = fifo_prepare (fifo_size);
 975   vec_validate (test_data, n_test_bytes - 1);
 976   vec_validate (data_buf, n_test_bytes - 1);
 977   for (i = 0; i < vec_len (test_data); i++)
 978     test_data[i] = i % 0xff;
 979
 980   /*
 981    * Test ooo segment distance to/from tail with u32 wrap
 982    */
 983
 984   /*
 985    * |0|---[start]--(len5)-->|0|--(len6)-->[end]---|0|
 986    */
 987   rv = f_distance_from (f, ~0 - 5, 5);
 988   SFIFO_TEST (rv == 11, "distance to tail should be %u is %u", 11, rv);
 989
 990   rv = f_distance_to (f, ~0 - 5, 5);
 991   SFIFO_TEST (rv == f->size - 11, "distance from tail should be %u is %u",
 992               f->size - 11, rv);
 993
 994   /*
 995    * |0|---[end]--(len5)-->|0|--(len6)-->[start]---|0|
 996    */
 997   rv = f_distance_to (f, 5, ~0 - 5);
 998   SFIFO_TEST (rv == 11, "distance from tail should be %u is %u", 11, rv);
 999
1000   rv = f_distance_from (f, 5, ~0 - 5);
1001   SFIFO_TEST (rv == f->size - 11, "distance to tail should be %u is %u",
1002               f->size - 11, rv);
1003
1004   /*
1005    * Add ooo with tail and ooo segment start u32 wrap
1006    */
1007   svm_fifo_init_pointers (f, ~0, ~0);
1008   svm_fifo_enqueue_with_offset (f, 10, 10, &test_data[10]);
1009   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
1010               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
1011   ooo_seg = svm_fifo_first_ooo_segment (f);
1012   rv = ooo_segment_offset_prod (f, ooo_seg);
1013   SFIFO_TEST (rv == 10, "offset should be %u is %u", 10, rv);
1014
1015   svm_fifo_enqueue (f, 10, test_data);
1016   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
1017               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
1018   SFIFO_TEST (f->ooos_list_head == OOO_SEGMENT_INVALID_INDEX,
1019               "there should be no ooo seg");
1020
1021   svm_fifo_peek (f, 5, 10, &data_buf[5]);
1022   if (compare_data (data_buf, test_data, 5, 10, (u32 *) & j))
1023     SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
1024                 test_data[j]);
1025
1026   svm_fifo_dequeue (f, 20, data_buf);
1027   if (compare_data (data_buf, test_data, 0, 20, (u32 *) & j))
1028     SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
1029                 test_data[j]);
1030
1031   /*
1032    * Force collect with tail u32 wrap and without ooo segment start u32 wrap
1033    */
1034   svm_fifo_init_pointers (f, ~0 - 10, ~0 - 10);
1035   svm_fifo_enqueue_with_offset (f, 5, 15, &test_data[5]);
1036   svm_fifo_enqueue (f, 12, test_data);
1037
1038   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
1039               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
1040   SFIFO_TEST (f->ooos_list_head == OOO_SEGMENT_INVALID_INDEX,
1041               "there should be no ooo seg");
1042
1043   svm_fifo_dequeue (f, 20, data_buf);
1044   if (compare_data (data_buf, test_data, 0, 20, (u32 *) & j))
1045     SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
1046                 test_data[j]);
1047
1048   /*
1049    * Cleanup
1050    */
1051   vec_free (test_data);
1052   vec_free (data_buf);
1053   svm_fifo_free (f);
1054   return 0;
1055 }
1056
1057 /*
1058  * Multiple ooo enqueues and dequeues that force fifo tail/head wrap
1059  */
1060 static int
1061 sfifo_test_fifo7 (vlib_main_t * vm, unformat_input_t * input)
1062 {
1063   u32 fifo_size = 101, n_iterations = 100;
1064   int i, j, rv, __clib_unused verbose = 0;
1065   u8 *test_data = 0, *data_buf = 0;
1066   u64 n_test_bytes = 100;
1067   svm_fifo_t *f;
1068
1069   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1070     {
1071       if (unformat (input, "verbose"))
1072         verbose = 1;
1073       else
1074         {
1075           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1076                            input);
1077           return -1;
1078         }
1079     }
1080
1081   /*
1082    * Prepare data structures
1083    */
1084   f = fifo_prepare (fifo_size);
1085   svm_fifo_init_pointers (f, ~0, ~0);
1086
1087   vec_validate (test_data, n_test_bytes - 1);
1088   vec_validate (data_buf, n_test_bytes - 1);
1089   for (i = 0; i < vec_len (test_data); i++)
1090     test_data[i] = i % 0xff;
1091
1092   /*
1093    * Run n iterations of test
1094    */
1095   for (i = 0; i < n_iterations; i++)
1096     {
1097       for (j = n_test_bytes - 1; j > 0; j -= 2)
1098         {
1099           svm_fifo_enqueue_with_offset (f, j, 1, &test_data[j]);
1100           rv = svm_fifo_n_ooo_segments (f);
1101           if (rv != (n_test_bytes - j) / 2 + 1)
1102             SFIFO_TEST (0, "number of ooo segments expected %u is %u",
1103                         (n_test_bytes - j) / 2 + 1, rv);
1104         }
1105
1106       svm_fifo_enqueue_with_offset (f, 1, n_test_bytes - 1, &test_data[1]);
1107       rv = svm_fifo_n_ooo_segments (f);
1108       if (rv != 1)
1109         SFIFO_TEST (0, "number of ooo segments %u", rv);
1110
1111       svm_fifo_enqueue (f, 1, test_data);
1112       rv = svm_fifo_n_ooo_segments (f);
1113       if (rv != 0)
1114         SFIFO_TEST (0, "number of ooo segments %u", rv);
1115
1116       svm_fifo_dequeue (f, n_test_bytes, data_buf);
1117       if (compare_data (data_buf, test_data, 0, n_test_bytes, (u32 *) & j))
1118         SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
1119                     test_data[j]);
1120       svm_fifo_init_pointers (f, ~0 - i, ~0 - i);
1121     }
1122   SFIFO_TEST (1, "passed multiple ooo enqueue/dequeue");
1123
1124   /*
1125    * Cleanup
1126    */
1127   vec_free (test_data);
1128   vec_free (data_buf);
1129   svm_fifo_free (f);
1130   return 0;
1131 }
1132
1133 /*
1134  * Enqueue more than 4GB
1135  */
1136 static int
1137 sfifo_test_fifo_large (vlib_main_t * vm, unformat_input_t * input)
1138 {
1139   u32 n_iterations = 100, n_bytes_per_iter, half;
1140   int i, j, rv, __clib_unused verbose = 0;
1141   u8 *test_data = 0, *data_buf = 0;
1142   u64 n_test_bytes = 100;
1143   svm_fifo_t *f;
1144
1145   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1146     {
1147       if (unformat (input, "verbose"))
1148         verbose = 1;
1149       else
1150         {
1151           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1152                            input);
1153           return -1;
1154         }
1155     }
1156
1157
1158   n_test_bytes = 5ULL << 30;
1159   n_iterations = 1 << 10;
1160   n_bytes_per_iter = n_test_bytes / n_iterations;
1161
1162   f = fifo_prepare (n_bytes_per_iter + 1);
1163   svm_fifo_init_pointers (f, ~0, ~0);
1164
1165   vec_validate (test_data, n_bytes_per_iter - 1);
1166   vec_validate (data_buf, n_bytes_per_iter - 1);
1167   for (i = 0; i < vec_len (test_data); i++)
1168     test_data[i] = i % 0xff;
1169
1170   half = n_bytes_per_iter / 2;
1171   for (i = 0; i < n_iterations; i++)
1172     {
1173       svm_fifo_enqueue_with_offset (f, half, half, &test_data[half]);
1174       svm_fifo_enqueue (f, half, test_data);
1175       rv = svm_fifo_n_ooo_segments (f);
1176       if (rv != 0)
1177         SFIFO_TEST (0, "number of ooo segments %u", rv);
1178       svm_fifo_dequeue (f, n_bytes_per_iter, data_buf);
1179       if (compare_data (data_buf, test_data, 0, n_bytes_per_iter,
1180                         (u32 *) & j))
1181         SFIFO_TEST (0, "[%d][%d] dequeued %u expected %u", i, j, data_buf[j],
1182                     test_data[j]);
1183     }
1184   SFIFO_TEST (1, "passed large transfer");
1185
1186   return 0;
1187 }
1188
1189 static int
1190 sfifo_test_fifo_grow (vlib_main_t * vm, unformat_input_t * input)
1191 {
1192   int verbose = 0, fifo_size = 201, start_offset = 100, i, j, rv;
1193   int test_n_bytes, deq_bytes, enq_bytes, n_deqs, n_enqs;
1194   svm_fifo_chunk_t *c, *next, *prev;
1195   u8 *test_data = 0, *data_buf = 0;
1196   svm_fifo_t *f;
1197   u32 old_tail;
1198
1199   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1200     {
1201       if (unformat (input, "verbose"))
1202         verbose = 1;
1203       else
1204         {
1205           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1206                            input);
1207           return -1;
1208         }
1209     }
1210
1211   f = fifo_prepare (fifo_size);
1212   svm_fifo_init_pointers (f, start_offset, start_offset);
1213
1214   /*
1215    * Add with fifo not wrapped
1216    */
1217   c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + 100);
1218   c->length = 100;
1219   c->start_byte = ~0;
1220   c->next = 0;
1221
1222   svm_fifo_add_chunk (f, c);
1223
1224   SFIFO_TEST (f->size == fifo_size + 100, "size expected %u is %u",
1225               fifo_size + 100, f->size);
1226   SFIFO_TEST (c->start_byte == fifo_size, "start byte expected %u is %u",
1227               fifo_size, c->start_byte);
1228   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1229
1230   /*
1231    *  Add with fifo wrapped
1232    */
1233
1234   svm_fifo_init_pointers (f, f->nitems - 100, f->nitems + 100);
1235   c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + 100);
1236   c->length = 100;
1237   c->start_byte = ~0;
1238   c->next = 0;
1239
1240   svm_fifo_add_chunk (f, c);
1241
1242   SFIFO_TEST (f->end_chunk != c, "tail chunk should not be updated");
1243   SFIFO_TEST (f->size == fifo_size + 100, "size expected %u is %u",
1244               fifo_size + 100, f->size);
1245   SFIFO_TEST (c->start_byte == fifo_size + 100, "start byte expected %u is "
1246               " %u", fifo_size + 100, c->start_byte);
1247   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1248
1249   /*
1250    * Unwrap fifo
1251    */
1252   vec_validate (data_buf, 200);
1253   svm_fifo_dequeue (f, 201, data_buf);
1254
1255   SFIFO_TEST (f->end_chunk == c, "tail chunk should be updated");
1256   SFIFO_TEST (f->size == fifo_size + 200, "size expected %u is %u",
1257               fifo_size + 200, f->size);
1258   SFIFO_TEST (c->start_byte == fifo_size + 100, "start byte expected %u is "
1259               "%u", fifo_size + 100, c->start_byte);
1260   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1261
1262   /*
1263    * Add N chunks
1264    */
1265   svm_fifo_init_pointers (f, f->nitems - 100, f->nitems + 100);
1266
1267   prev = 0;
1268   for (i = 0; i < 5; i++)
1269     {
1270       c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + 100);
1271       c->length = 100;
1272       c->start_byte = ~0;
1273       c->next = prev;
1274       prev = c;
1275     }
1276
1277   svm_fifo_add_chunk (f, c);
1278   SFIFO_TEST (f->size == fifo_size + 200, "size expected %u is %u",
1279               fifo_size + 200, f->size);
1280
1281   prev = 0;
1282   for (i = 0; i < 5; i++)
1283     {
1284       c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + 100);
1285       c->length = 100;
1286       c->start_byte = ~0;
1287       c->next = prev;
1288       prev = c;
1289     }
1290
1291   svm_fifo_add_chunk (f, c);
1292   SFIFO_TEST (f->size == fifo_size + 200, "size expected %u is %u",
1293               fifo_size + 200, f->size);
1294
1295   old_tail = f->tail;
1296   svm_fifo_dequeue (f, 101, data_buf);
1297
1298   SFIFO_TEST (f->size == fifo_size + 200 + 10 * 100, "size expected %u is %u",
1299               fifo_size + 200 + 10 * 100, f->size);
1300   SFIFO_TEST (f->tail == old_tail, "new tail expected %u is %u", old_tail,
1301               f->tail);
1302   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1303
1304   /*
1305    * Enqueue/dequeue tests
1306    */
1307
1308   test_n_bytes = f->nitems;
1309   vec_validate (test_data, test_n_bytes - 1);
1310   vec_validate (data_buf, vec_len (test_data));
1311   n_deqs = n_enqs = 6;
1312   deq_bytes = enq_bytes = vec_len (test_data) / n_deqs;
1313
1314   for (i = 0; i < vec_len (test_data); i++)
1315     test_data[i] = i;
1316
1317   /*
1318    * Enqueue/deq boundary conditions
1319    */
1320   svm_fifo_init_pointers (f, 201, 201);
1321   SFIFO_TEST (f->tail_chunk->start_byte == 201, "start byte expected %u is "
1322               "%u", 201, f->tail_chunk->start_byte);
1323
1324   svm_fifo_enqueue (f, 200, test_data);
1325   SFIFO_TEST (f->tail_chunk->start_byte == 401, "start byte expected %u is "
1326               "%u", 401, f->tail_chunk->start_byte);
1327
1328   svm_fifo_dequeue (f, 200, data_buf);
1329   SFIFO_TEST (f->head_chunk->start_byte == 401, "start byte expected %u is "
1330               "%u", 401, f->head_chunk->start_byte);
1331
1332   /*
1333    * Simple enqueue/deq and data validation (1)
1334    */
1335   svm_fifo_init_pointers (f, f->nitems / 2, f->nitems / 2);
1336   for (i = 0; i < test_n_bytes; i++)
1337     {
1338       rv = svm_fifo_enqueue (f, sizeof (u8), &test_data[i]);
1339       if (rv < 0)
1340         {
1341           clib_warning ("enqueue returned %d", rv);
1342           goto cleanup;
1343         }
1344     }
1345
1346   SFIFO_TEST (svm_fifo_max_dequeue (f) == test_n_bytes, "max deq expected %u "
1347               "is %u", test_n_bytes, svm_fifo_max_dequeue (f));
1348
1349   for (i = 0; i < test_n_bytes; i++)
1350     svm_fifo_dequeue (f, 1, &data_buf[i]);
1351
1352   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1353                      (u32 *) & j);
1354   if (rv)
1355     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
1356                      test_data[j]);
1357   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
1358   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1359
1360   /*
1361    * Simple enqueue/deq and data validation (2)
1362    */
1363   for (i = 0; i <= n_enqs; i++)
1364     {
1365       rv = svm_fifo_enqueue (f, enq_bytes, test_data + i * enq_bytes);
1366       if (rv < 0)
1367         {
1368           clib_warning ("enqueue returned %d", rv);
1369           goto cleanup;
1370         }
1371     }
1372
1373   SFIFO_TEST (svm_fifo_max_dequeue (f) == test_n_bytes, "max deq expected %u "
1374               "is %u", test_n_bytes, svm_fifo_max_dequeue (f));
1375
1376   for (i = 0; i <= n_deqs; i++)
1377     svm_fifo_dequeue (f, deq_bytes, data_buf + i * deq_bytes);
1378
1379   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1380                      (u32 *) & j);
1381   if (rv)
1382     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
1383                      test_data[j]);
1384   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
1385   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1386
1387   /*
1388    * Simple enqueue and drop
1389    */
1390   for (i = 0; i <= n_enqs; i++)
1391     {
1392       rv = svm_fifo_enqueue (f, enq_bytes, test_data + i * enq_bytes);
1393       if (rv < 0)
1394         SFIFO_TEST (0, "failed to enqueue");
1395     }
1396
1397   rv = svm_fifo_dequeue_drop (f, test_n_bytes / 2);
1398   SFIFO_TEST (rv == test_n_bytes / 2, "drop should be equal");
1399   SFIFO_TEST (svm_fifo_is_sane (f), "head chunk should be valid");
1400   rv = svm_fifo_dequeue_drop (f, test_n_bytes / 2);
1401   SFIFO_TEST (rv == test_n_bytes / 2, "drop should be equal");
1402   SFIFO_TEST (svm_fifo_is_sane (f), "head chunk should be valid");
1403   SFIFO_TEST (svm_fifo_max_dequeue (f) == 0, "should be empty");
1404
1405   /*
1406    * Simple enqueue and drop all
1407    */
1408
1409   /* Enqueue just enough data to make sure fifo is not full */
1410   for (i = 0; i <= n_enqs / 2; i++)
1411     {
1412       rv = svm_fifo_enqueue (f, enq_bytes, test_data + i * enq_bytes);
1413       if (rv < 0)
1414         SFIFO_TEST (0, "failed to enqueue");
1415     }
1416
1417   /* check drop all as well */
1418   svm_fifo_dequeue_drop_all (f);
1419   SFIFO_TEST (svm_fifo_is_sane (f), "head chunk should be valid");
1420   SFIFO_TEST (svm_fifo_max_dequeue (f) == 0, "should be empty");
1421
1422   /*
1423    * OOO enqueues/dequeues and data validation (1)
1424    */
1425   for (i = test_n_bytes - 1; i > 0; i--)
1426     {
1427       rv = svm_fifo_enqueue_with_offset (f, i, sizeof (u8), &test_data[i]);
1428       if (verbose)
1429         vlib_cli_output (vm, "add [%d] [%d, %d]", i, i, i + sizeof (u8));
1430       if (rv)
1431         {
1432           clib_warning ("enqueue returned %d", rv);
1433           goto cleanup;
1434         }
1435     }
1436
1437   SFIFO_TEST (svm_fifo_max_dequeue (f) == 0, "max deq expected %u is %u",
1438               0, svm_fifo_max_dequeue (f));
1439
1440   svm_fifo_enqueue (f, sizeof (u8), &test_data[0]);
1441
1442   memset (data_buf, 0, vec_len (data_buf));
1443   for (i = 0; i <= n_deqs; i++)
1444     svm_fifo_dequeue (f, deq_bytes, data_buf + i * deq_bytes);
1445
1446   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1447                      (u32 *) & j);
1448   if (rv)
1449     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
1450                      test_data[j]);
1451   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
1452   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1453
1454   /*
1455    * OOO enqueues/dequeues and data validation (2)
1456    */
1457
1458   for (i = n_enqs; i > 0; i--)
1459     {
1460       u32 enq_now = clib_min (enq_bytes, vec_len (test_data) - i * enq_bytes);
1461       rv = svm_fifo_enqueue_with_offset (f, i * enq_bytes, enq_now,
1462                                          test_data + i * enq_bytes);
1463       if (verbose)
1464         vlib_cli_output (vm, "add [%d, %d]", i * enq_bytes,
1465                          i * enq_bytes + enq_now);
1466       if (rv)
1467         {
1468           clib_warning ("enqueue returned %d", rv);
1469           goto cleanup;
1470         }
1471     }
1472   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1473
1474   svm_fifo_enqueue (f, enq_bytes, &test_data[0]);
1475   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1476
1477   memset (data_buf, 0, vec_len (data_buf));
1478   for (i = 0; i <= n_deqs; i++)
1479     svm_fifo_dequeue (f, deq_bytes, data_buf + i * deq_bytes);
1480
1481   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1482                      (u32 *) & j);
1483   if (rv)
1484     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
1485                      test_data[j]);
1486   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
1487   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1488
1489   /*
1490    * Cleanup
1491    */
1492
1493 cleanup:
1494
1495   c = f->start_chunk->next;
1496   while (c && c != f->start_chunk)
1497     {
1498       next = c->next;
1499       clib_mem_free (c);
1500       c = next;
1501     }
1502
1503   svm_fifo_free (f);
1504   vec_free (test_data);
1505   vec_free (data_buf);
1506   return 0;
1507 }
1508
1509 static int
1510 chunk_list_len (svm_fifo_chunk_t * c)
1511 {
1512   svm_fifo_chunk_t *it;
1513   int count = 0;
1514
1515   if (!c)
1516     return 0;
1517
1518   count = 1;
1519   it = c->next;
1520   while (it && it != c)
1521     {
1522       it = it->next;
1523       count++;
1524     }
1525   return count;
1526 }
1527
1528 static void
1529 chunk_list_free (svm_fifo_chunk_t * c, svm_fifo_chunk_t * stop)
1530 {
1531   svm_fifo_chunk_t *it, *next;
1532
1533   it = c;
1534   while (it && it != stop)
1535     {
1536       next = it->next;
1537       clib_mem_free (it);
1538       it = next;
1539     }
1540 }
1541
1542 static void
1543 chunk_list_splice (svm_fifo_chunk_t * a, svm_fifo_chunk_t * b)
1544 {
1545   svm_fifo_chunk_t *it;
1546
1547   it = a;
1548   while (it->next)
1549     it = it->next;
1550   it->next = b;
1551 }
1552
1553 static int
1554 sfifo_test_fifo_shrink (vlib_main_t * vm, unformat_input_t * input)
1555 {
1556   int __clib_unused verbose = 0, fifo_size = 101, chunk_size = 100;
1557   int i, rv, test_n_bytes, diff, deq_bytes;
1558   svm_fifo_chunk_t *c, *prev, *collected;
1559   u8 *test_data = 0, *data_buf = 0;
1560   svm_fifo_t *f;
1561
1562   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1563     {
1564       if (unformat (input, "verbose"))
1565         verbose = 1;
1566       else
1567         {
1568           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1569                            input);
1570           return -1;
1571         }
1572     }
1573
1574   /*
1575    * Init fifo with multiple chunks
1576    */
1577   f = fifo_prepare (fifo_size);
1578   svm_fifo_init_pointers (f, 0, 0);
1579
1580   prev = 0;
1581   for (i = 0; i < 11; i++)
1582     {
1583       c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + chunk_size);
1584       c->length = 100;
1585       c->start_byte = ~0;
1586       c->next = prev;
1587       prev = c;
1588     }
1589
1590   svm_fifo_add_chunk (f, c);
1591   SFIFO_TEST (f->size == 12 * chunk_size + 1, "size expected %u is %u",
1592               12 * chunk_size + 1, f->size);
1593
1594   /*
1595    * No fifo wrap and no chunk used (one chunk)
1596    */
1597   rv = svm_fifo_reduce_size (f, chunk_size, 0);
1598   SFIFO_TEST (rv == chunk_size, "len expected %u is %u", chunk_size, rv);
1599   SFIFO_TEST (f->size == 12 * chunk_size + 1, "size expected %u is %u",
1600               12 * chunk_size + 1, f->size);
1601   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1602   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1603
1604   /* Check enqueue space to force size reduction */
1605   (void) svm_fifo_max_enqueue (f);
1606
1607   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1608               11 * chunk_size + 1, f->size);
1609   SFIFO_TEST (f->flags & SVM_FIFO_F_COLLECT_CHUNKS, "collect flag should"
1610               " be set");
1611   SFIFO_TEST (!(f->flags & SVM_FIFO_F_SHRINK), "shrink flag should not be"
1612               " set");
1613   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1614
1615   collected = c = svm_fifo_collect_chunks (f);
1616   rv = chunk_list_len (c);
1617   SFIFO_TEST (rv == 1, "expected %u chunks got %u", 1, rv);
1618   rv = chunk_list_len (f->start_chunk);
1619   SFIFO_TEST (rv == 11, "expected %u chunks got %u", 11, rv);
1620   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1621               " not be set");
1622   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1623
1624   /*
1625    * Fifo wrap and multiple chunks used
1626    */
1627
1628   /* Init test data and fifo */
1629   test_n_bytes = f->nitems;
1630   vec_validate (test_data, test_n_bytes - 1);
1631   vec_validate (data_buf, vec_len (test_data));
1632
1633   for (i = 0; i < vec_len (test_data); i++)
1634     test_data[i] = i;
1635
1636   svm_fifo_init_pointers (f, f->size / 2, f->size / 2);
1637   for (i = 0; i < test_n_bytes; i++)
1638     {
1639       rv = svm_fifo_enqueue (f, sizeof (u8), &test_data[i]);
1640       if (rv < 0)
1641         SFIFO_TEST (0, "enqueue returned");
1642     }
1643
1644   /* Try to reduce fifo size with fifo full */
1645   rv = svm_fifo_reduce_size (f, 3.5 * chunk_size, 0);
1646   SFIFO_TEST (rv == 3 * chunk_size, "len expected %u is %u", 3 * chunk_size,
1647               rv);
1648   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1649               11 * chunk_size + 1, f->size);
1650   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1651   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1652
1653   /* Check enqueue space to try size reduction. Should not work */
1654   rv = svm_fifo_max_enqueue (f);
1655
1656   SFIFO_TEST (rv == 0, "free space expected %u is %u", 0, rv);
1657   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1658               11 * chunk_size + 1, f->size);
1659   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1660   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1661               " not be set");
1662   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1663
1664   /* Dequeue byte-by-byte up to last byte on last chunk */
1665   deq_bytes = f->size - f->size / 2 - 1;
1666   for (i = 0; i < deq_bytes; i++)
1667     {
1668       (void) svm_fifo_max_enqueue (f);
1669       rv = svm_fifo_dequeue (f, 1, &data_buf[i]);
1670       if (rv < 0)
1671         SFIFO_TEST (0, "dequeue returned");
1672     }
1673   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1674
1675   rv = svm_fifo_max_enqueue (f);
1676
1677   /* We've dequeued more than 3*chunk_size so nitems should be updated */
1678   SFIFO_TEST (f->nitems == 8 * chunk_size, "nitems expected %u is %u",
1679               8 * chunk_size, f->nitems);
1680   /* Free space should be what was dequeued - 3 * chunk_size, which was
1681    * consumed by shrinking the fifo */
1682   diff = deq_bytes - 3 * chunk_size;
1683   SFIFO_TEST (rv == diff, "free space expected %u is %u", diff, rv);
1684   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1685               11 * chunk_size + 1, f->size);
1686   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1687   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1688               " not be set");
1689   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1690
1691   /* Dequeue one more such that head goes beyond last chunk */
1692   rv = svm_fifo_dequeue (f, 1, &data_buf[deq_bytes]);
1693   if (rv < 0)
1694     SFIFO_TEST (0, "dequeue returned");
1695
1696   rv = svm_fifo_max_enqueue (f);
1697   SFIFO_TEST (f->nitems == 8 * chunk_size, "nitems expected %u is %u",
1698               8 * chunk_size, f->nitems);
1699   SFIFO_TEST (rv == diff + 1, "free space expected %u is %u", diff + 1, rv);
1700   SFIFO_TEST (f->size == 8 * chunk_size + 1, "size expected %u is %u",
1701               8 * chunk_size + 1, f->size);
1702   SFIFO_TEST (!(f->flags & SVM_FIFO_F_SHRINK), "shrink flag should not be"
1703               " set");
1704   SFIFO_TEST (f->flags & SVM_FIFO_F_COLLECT_CHUNKS, "collect flag should"
1705               " be set");
1706   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1707
1708   /* Dequeue the rest of the data */
1709   deq_bytes += 1;
1710   for (i = 0; i < test_n_bytes - deq_bytes; i++)
1711     {
1712       rv = svm_fifo_dequeue (f, 1, &data_buf[i + deq_bytes]);
1713       if (rv < 0)
1714         SFIFO_TEST (0, "dequeue returned");
1715     }
1716
1717   rv = svm_fifo_max_enqueue (f);
1718
1719   SFIFO_TEST (f->size == 8 * chunk_size + 1, "size expected %u is %u",
1720               8 * chunk_size + 1, f->size);
1721   SFIFO_TEST (rv == 8 * chunk_size, "free space expected %u is %u",
1722               8 * chunk_size, rv);
1723
1724   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1725                      (u32 *) & i);
1726   if (rv)
1727     SFIFO_TEST (0, "[%d] dequeued %u expected %u", i, data_buf[i],
1728                 test_data[i]);
1729
1730   c = svm_fifo_collect_chunks (f);
1731   rv = chunk_list_len (c);
1732   SFIFO_TEST (rv == 3, "expected %u chunks got %u", 3, rv);
1733   rv = chunk_list_len (f->start_chunk);
1734   SFIFO_TEST (rv == 8, "expected %u chunks got %u", 8, rv);
1735   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1736               " not be set");
1737   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1738
1739   /*
1740    * OOO segment on chunk that should be removed
1741    */
1742
1743   svm_fifo_add_chunk (f, c);
1744   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1745               11 * chunk_size + 1, f->size);
1746
1747   memset (data_buf, 0, vec_len (data_buf));
1748   svm_fifo_init_pointers (f, f->size / 2, f->size / 2);
1749   svm_fifo_enqueue (f, 200, test_data);
1750   svm_fifo_enqueue_with_offset (f, 50, vec_len (test_data) - 250,
1751                                 &test_data[250]);
1752
1753   /* Free space */
1754   rv = svm_fifo_max_enqueue (f);
1755   SFIFO_TEST (rv == vec_len (test_data) - 200, "free space expected %u is %u",
1756               vec_len (test_data) - 200, rv);
1757   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1758
1759   /* Ask to reduce size */
1760   rv = svm_fifo_reduce_size (f, 3.5 * chunk_size, 0);
1761   SFIFO_TEST (rv == 3 * chunk_size, "len expected %u is %u", 3 * chunk_size,
1762               rv);
1763   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1764               11 * chunk_size + 1, f->size);
1765   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1766   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1767
1768   /* Try to force size reduction but it should fail */
1769   rv = svm_fifo_max_enqueue (f);
1770
1771   SFIFO_TEST (rv == vec_len (test_data) - 200, "free space expected %u is %u",
1772               vec_len (test_data) - 200, rv);
1773   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1774               11 * chunk_size + 1, f->size);
1775   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1776   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1777               " not be set");
1778   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1779
1780   /* Dequeue the in order data. This should shrink nitems */
1781   rv = svm_fifo_dequeue (f, 200, data_buf);
1782   if (rv < 0)
1783     SFIFO_TEST (0, "dequeue returned");
1784
1785   rv = svm_fifo_max_enqueue (f);
1786   SFIFO_TEST (rv == vec_len (test_data) - 200, "free space expected %u is %u",
1787               vec_len (test_data) - 200, rv);
1788   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1789               11 * chunk_size + 1, f->size);
1790   SFIFO_TEST (f->nitems == 11 * chunk_size - 200, "nitems expected %u is %u",
1791               11 * chunk_size - 200, f->nitems);
1792   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1793   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1794               " not be set");
1795   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1796
1797   /* Enqueue the missing 50 bytes. Fifo will become full */
1798   rv = svm_fifo_enqueue (f, 50, &test_data[200]);
1799   SFIFO_TEST (rv == vec_len (test_data) - 200, "free space expected %u is %u",
1800               vec_len (test_data) - 200, rv);
1801   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1802
1803   rv = svm_fifo_max_enqueue (f);
1804
1805   SFIFO_TEST (rv == 0, "free space expected %u is %u", 0, rv);
1806   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1807               11 * chunk_size + 1, f->size);
1808   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1809   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1810               " not be set");
1811   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1812
1813
1814   /* Dequeue a chunk and check nitems shrink but fifo still full */
1815   svm_fifo_dequeue (f, 100, &data_buf[200]);
1816
1817   rv = svm_fifo_max_enqueue (f);
1818
1819   SFIFO_TEST (rv == 0, "free space expected %u is %u", 0, rv);
1820   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1821               11 * chunk_size + 1, f->size);
1822   SFIFO_TEST (f->nitems == 11 * chunk_size - 300, "nitems expected %u is %u",
1823               11 * chunk_size - 300, f->nitems);
1824   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1825   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1826               " not be set");
1827   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1828
1829   /* Dequeue enough to unwrap the fifo */
1830   deq_bytes = f->size - f->size / 2 - 300;
1831   svm_fifo_dequeue (f, deq_bytes, &data_buf[300]);
1832   rv = svm_fifo_max_enqueue (f);
1833
1834   /* Overall we've dequeued deq_bytes + 300, but fifo size shrunk 300 */
1835   SFIFO_TEST (rv == 300 + deq_bytes - 300, "free space expected %u is %u",
1836               300 + deq_bytes - 300, rv);
1837   SFIFO_TEST (f->size == 8 * chunk_size + 1, "size expected %u is %u",
1838               8 * chunk_size + 1, f->size);
1839   SFIFO_TEST (f->nitems == 8 * chunk_size, "nitems expected %u is %u",
1840               8 * chunk_size, f->nitems);
1841   SFIFO_TEST (!(f->flags & SVM_FIFO_F_SHRINK), "shrink flag should not be"
1842               " set");
1843   SFIFO_TEST (f->flags & SVM_FIFO_F_COLLECT_CHUNKS, "collect flag should"
1844               " be set");
1845   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1846
1847   /* Dequeue the rest */
1848   svm_fifo_dequeue (f, test_n_bytes / 2, &data_buf[300 + deq_bytes]);
1849   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1850                      (u32 *) & i);
1851   if (rv)
1852     SFIFO_TEST (0, "[%d] dequeued %u expected %u", i, data_buf[i],
1853                 test_data[i]);
1854
1855   c = svm_fifo_collect_chunks (f);
1856   rv = chunk_list_len (c);
1857   SFIFO_TEST (rv == 3, "expected %u chunks got %u", 3, rv);
1858   rv = chunk_list_len (f->start_chunk);
1859   SFIFO_TEST (rv == 8, "expected %u chunks got %u", 8, rv);
1860   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1861               " not be set");
1862   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1863
1864   chunk_list_splice (collected, c);
1865
1866   /*
1867    * Remove all chunks possible (1)
1868    *
1869    * Tail and head are in first chunk that is not removed
1870    */
1871   svm_fifo_init_pointers (f, 600, 600);
1872   rv = svm_fifo_reduce_size (f, 8 * chunk_size, 1);
1873   SFIFO_TEST (rv == 7 * chunk_size, "actual len expected %u is %u",
1874               7 * chunk_size, rv);
1875   SFIFO_TEST (f->size == 6 * chunk_size + 1, "size expected %u is %u",
1876               6 * chunk_size + 1, f->size);
1877   SFIFO_TEST (f->nitems == 1 * chunk_size, "nitems expected %u is %u",
1878               1 * chunk_size, f->nitems);
1879   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1880   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1881               " not be set");
1882   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1883
1884   rv = svm_fifo_max_enqueue (f);
1885   SFIFO_TEST (rv == chunk_size, "free space expected %u is %u", chunk_size,
1886               rv);
1887   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1888
1889   /* Force head/tail to move to first chunk */
1890   svm_fifo_enqueue (f, 1, test_data);
1891   svm_fifo_dequeue (f, 1, data_buf);
1892   rv = svm_fifo_max_enqueue (f);
1893
1894   SFIFO_TEST (rv == chunk_size, "free space expected %u is %u", chunk_size,
1895               rv);
1896   SFIFO_TEST (f->size == chunk_size + 1, "size expected %u is %u",
1897               chunk_size + 1, f->size);
1898   SFIFO_TEST (!(f->flags & SVM_FIFO_F_SHRINK), "shrink flag should not be"
1899               " set");
1900   SFIFO_TEST (f->flags & SVM_FIFO_F_COLLECT_CHUNKS, "collect flag should"
1901               " be set");
1902   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1903
1904   c = svm_fifo_collect_chunks (f);
1905   rv = chunk_list_len (c);
1906   SFIFO_TEST (rv == 7, "expected %u chunks got %u", 7, rv);
1907   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1908               " not be set");
1909   SFIFO_TEST (!(f->flags & SVM_FIFO_F_MULTI_CHUNK), "multi-chunk flag should"
1910               " not be set");
1911   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1912
1913   /* re-add chunks for next test */
1914   svm_fifo_add_chunk (f, c);
1915
1916   /*
1917    * Remove all chunks possible (2)
1918    *
1919    * Tail and head are in the first chunk that should eventually be removed
1920    */
1921   svm_fifo_init_pointers (f, 601, 601);
1922   rv = svm_fifo_reduce_size (f, 8 * chunk_size, 1);
1923   SFIFO_TEST (rv == 7 * chunk_size, "actual len expected %u is %u",
1924               7 * chunk_size, rv);
1925   SFIFO_TEST (f->size == 7 * chunk_size + 1, "size expected %u is %u",
1926               7 * chunk_size + 1, f->size);
1927   SFIFO_TEST (f->nitems == 1 * chunk_size, "nitems expected %u is %u",
1928               1 * chunk_size, f->nitems);
1929   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1930   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1931               " not be set");
1932   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1933
1934   rv = svm_fifo_max_enqueue (f);
1935   SFIFO_TEST (rv == chunk_size, "free space expected %u is %u", chunk_size,
1936               rv);
1937   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1938
1939   /* Force head/tail to move to first chunk */
1940   svm_fifo_enqueue (f, chunk_size, test_data);
1941   svm_fifo_dequeue (f, chunk_size, data_buf);
1942   rv = svm_fifo_max_enqueue (f);
1943
1944   SFIFO_TEST (rv == chunk_size, "free space expected %u is %u", chunk_size,
1945               rv);
1946   SFIFO_TEST (f->size == chunk_size + 1, "size expected %u is %u",
1947               chunk_size + 1, f->size);
1948   SFIFO_TEST (!(f->flags & SVM_FIFO_F_SHRINK), "shrink flag should not be"
1949               " set");
1950   SFIFO_TEST (f->flags & SVM_FIFO_F_COLLECT_CHUNKS, "collect flag should"
1951               " be set");
1952   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1953
1954   c = svm_fifo_collect_chunks (f);
1955   rv = chunk_list_len (c);
1956   SFIFO_TEST (rv == 7, "expected %u chunks got %u", 7, rv);
1957   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1958               " not be set");
1959   SFIFO_TEST (!(f->flags & SVM_FIFO_F_MULTI_CHUNK), "multi-chunk flag should"
1960               " not be set");
1961   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
1962
1963   chunk_list_splice (collected, c);
1964
1965   /*
1966    * Cleanup
1967    */
1968
1969   chunk_list_free (f->start_chunk->next, f->start_chunk);
1970   chunk_list_free (collected, 0);
1971   svm_fifo_free (f);
1972   vec_free (test_data);
1973   vec_free (data_buf);
1974
1975   return 0;
1976 }
1977
1978 /* *INDENT-OFF* */
1979 svm_fifo_trace_elem_t fifo_trace[] = {};
1980 /* *INDENT-ON* */
1981
1982 static int
1983 sfifo_test_fifo_replay (vlib_main_t * vm, unformat_input_t * input)
1984 {
1985   svm_fifo_t f;
1986   int verbose = 0;
1987   u8 no_read = 0, *str = 0;
1988
1989   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1990     {
1991       if (unformat (input, "verbose"))
1992         verbose = 1;
1993       else if (unformat (input, "no-read"))
1994         no_read = 1;
1995       else
1996         {
1997           clib_error_t *e = clib_error_return
1998             (0, "unknown input `%U'", format_unformat_error, input);
1999           clib_error_report (e);
2000           return -1;
2001         }
2002     }
2003
2004 #if SVMF_FIFO_TRACE
2005   f.trace = fifo_trace;
2006 #endif
2007
2008   str = svm_fifo_replay (str, &f, no_read, verbose);
2009   vlib_cli_output (vm, "%v", str);
2010   return 0;
2011 }
2012
2013 static fifo_segment_main_t segment_main;
2014
2015 static svm_fifo_t *
2016 fifo_segment_alloc_fifo (fifo_segment_t * fs, u32 data_bytes,
2017                          fifo_segment_ftype_t ftype)
2018 {
2019   return fifo_segment_alloc_fifo_w_slice (fs, 0, data_bytes, ftype);
2020 }
2021
2022 static int
2023 sfifo_test_fifo_segment_hello_world (int verbose)
2024 {
2025   fifo_segment_create_args_t _a, *a = &_a;
2026   fifo_segment_main_t *sm = &segment_main;
2027   u8 *test_data, *retrieved_data = 0;
2028   fifo_segment_t *fs;
2029   svm_fifo_t *f;
2030   int rv;
2031
2032   clib_memset (a, 0, sizeof (*a));
2033   a->segment_name = "fifo-test1";
2034   a->segment_size = 256 << 10;
2035
2036   rv = fifo_segment_create (sm, a);
2037   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2038
2039   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2040   f = fifo_segment_alloc_fifo (fs, 4096, FIFO_SEGMENT_RX_FIFO);
2041
2042   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo");
2043
2044   test_data = format (0, "Hello world%c", 0);
2045   vec_validate (retrieved_data, vec_len (test_data) - 1);
2046
2047   while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
2048     svm_fifo_enqueue (f, vec_len (test_data), test_data);
2049
2050   while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
2051     svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
2052
2053   while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
2054     svm_fifo_enqueue (f, vec_len (test_data), test_data);
2055
2056   while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
2057     svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
2058
2059   SFIFO_TEST (!memcmp (retrieved_data, test_data, vec_len (test_data)),
2060               "data should be identical");
2061
2062   vec_free (test_data);
2063   vec_free (retrieved_data);
2064   vec_free (a->new_segment_indices);
2065   fifo_segment_free_fifo (fs, f);
2066   fifo_segment_delete (sm, fs);
2067   return 0;
2068 }
2069
2070 static int
2071 sfifo_test_fifo_segment_fifo_grow (int verbose)
2072 {
2073   int rv, fifo_size = 4096, n_chunks, n_batch;
2074   fifo_segment_main_t *sm = &segment_main;
2075   fifo_segment_create_args_t _a, *a = &_a;
2076   u32 n_free_chunk_bytes;
2077   fifo_segment_t *fs;
2078   svm_fifo_t *f;
2079
2080   clib_memset (a, 0, sizeof (*a));
2081   a->segment_name = "fifo-test1";
2082   /* size chosen to be able to force multi chunk allocation lower */
2083   a->segment_size = 256 << 10;
2084
2085   /* fifo allocation allocates chunks in batch */
2086   n_batch = FIFO_SEGMENT_ALLOC_BATCH_SIZE;
2087
2088   rv = fifo_segment_create (sm, a);
2089
2090   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2091
2092   /*
2093    * Alloc and grow fifo
2094    */
2095   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2096   f = fifo_segment_alloc_fifo (fs, fifo_size, FIFO_SEGMENT_RX_FIFO);
2097
2098   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo");
2099
2100   n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
2101   SFIFO_TEST (n_chunks == n_batch - 1, "free 2^10B chunks "
2102               "should be %u is %u", n_batch - 1, n_chunks);
2103   rv = fifo_segment_fl_chunk_bytes (fs);
2104   SFIFO_TEST (rv == (n_batch - 1) * fifo_size, "free chunk bytes %u "
2105               "expected %u", rv, (n_batch - 1) * fifo_size);
2106
2107   /* Grow by preallocated fifo_size chunk */
2108   fifo_segment_grow_fifo (fs, f, fifo_size);
2109   SFIFO_TEST (f->size == 2 * fifo_size, "fifo size should be %u is %u",
2110               2 * fifo_size, f->size);
2111   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
2112
2113   n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
2114   SFIFO_TEST (n_chunks == n_batch - 2, "free 2^10B chunks "
2115               "should be %u is %u", n_batch - 2, n_chunks);
2116   rv = fifo_segment_fl_chunk_bytes (fs);
2117   SFIFO_TEST (rv == (n_batch - 2) * fifo_size, "free chunk bytes %u "
2118               "expected %u", rv, (n_batch - 2) * fifo_size);
2119
2120   /* Grow by a size not preallocated but first make sure there's space */
2121   rv = fifo_segment_free_bytes (fs);
2122   SFIFO_TEST (rv > 16 * fifo_size, "free bytes %u more than %u", rv,
2123               16 * fifo_size);
2124
2125   fifo_segment_grow_fifo (fs, f, 16 * fifo_size);
2126   SFIFO_TEST (f->size == 18 * fifo_size, "fifo size should be %u is %u",
2127               18 * fifo_size, f->size);
2128
2129   rv = fifo_segment_fl_chunk_bytes (fs);
2130   SFIFO_TEST (rv == (n_batch - 2) * fifo_size, "free chunk bytes %u "
2131               "expected %u", rv, (n_batch - 2) * fifo_size);
2132
2133   /*
2134    * Free and test free list size
2135    */
2136   fifo_segment_free_fifo (fs, f);
2137
2138   rv = fifo_segment_fl_chunk_bytes (fs);
2139   SFIFO_TEST (rv == (16 + n_batch) * fifo_size, "free chunk bytes expected %u"
2140               " is %u", (16 + n_batch) * fifo_size, rv);
2141   n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
2142   SFIFO_TEST (n_chunks == n_batch, "free 2^10B chunks "
2143               "should be %u is %u", n_batch, n_chunks);
2144   n_chunks = fifo_segment_num_free_chunks (fs, 16 * fifo_size);
2145   SFIFO_TEST (n_chunks == 1, "free 2^14B chunks should be %u is %u", 1,
2146               n_chunks);
2147   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
2148   SFIFO_TEST (n_chunks == 1 + n_batch, "free chunks should be %u is %u",
2149               1 + n_batch, n_chunks);
2150
2151   /*
2152    * Realloc fifo
2153    */
2154   f = fifo_segment_alloc_fifo (fs, fifo_size, FIFO_SEGMENT_RX_FIFO);
2155
2156   fifo_segment_grow_fifo (fs, f, fifo_size);
2157   n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
2158   SFIFO_TEST (n_chunks == n_batch - 2, "free 2^10B chunks should be %u is %u",
2159               n_batch - 2, n_chunks);
2160
2161   fifo_segment_grow_fifo (fs, f, 16 * fifo_size);
2162   n_chunks = fifo_segment_num_free_chunks (fs, 16 * fifo_size);
2163   SFIFO_TEST (n_chunks == 0, "free 2^14B chunks should be %u is %u", 0,
2164               n_chunks);
2165   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
2166   SFIFO_TEST (n_chunks == n_batch - 2, "free chunks should be %u is %u",
2167               n_batch - 2, n_chunks);
2168
2169   /*
2170    * Free again
2171    */
2172   fifo_segment_free_fifo (fs, f);
2173   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
2174   SFIFO_TEST (n_chunks == 1 + n_batch, "free chunks should be %u is %u",
2175               1 + n_batch, n_chunks);
2176
2177   rv = fifo_segment_fl_chunk_bytes (fs);
2178   SFIFO_TEST (rv == (16 + n_batch) * fifo_size, "free chunk bytes expected %u"
2179               " is %u", (16 + n_batch) * fifo_size, rv);
2180
2181   n_free_chunk_bytes = rv;
2182
2183   /*
2184    * Allocate non power of 2 fifo/chunk and check that free chunk bytes
2185    * is correctly updated
2186    */
2187
2188   f = fifo_segment_alloc_fifo (fs, 16 * fifo_size - 1, FIFO_SEGMENT_RX_FIFO);
2189   rv = fifo_segment_fl_chunk_bytes (fs);
2190
2191   SFIFO_TEST (n_free_chunk_bytes - 16 * fifo_size == rv, "free chunk bytes "
2192               "expected %u is %u", n_free_chunk_bytes - 16 * fifo_size, rv);
2193   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
2194
2195   fifo_segment_free_fifo (fs, f);
2196   rv = fifo_segment_fl_chunk_bytes (fs);
2197
2198   SFIFO_TEST (n_free_chunk_bytes == rv, "free chunk bytes expected %u is %u",
2199               n_free_chunk_bytes, rv);
2200
2201   /*
2202    * Force multi chunk fifo allocation
2203    */
2204
2205   /* Check that we can force multi chunk allocation. Note that fifo size
2206    * rounded up to power of 2, i.e., 17 becomes 32 */
2207   rv = fifo_segment_free_bytes (fs);
2208   SFIFO_TEST (rv < 32 * fifo_size, "free bytes %u less than %u", rv,
2209               32 * fifo_size);
2210
2211   f = fifo_segment_alloc_fifo (fs, 17 * fifo_size, FIFO_SEGMENT_RX_FIFO);
2212   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
2213
2214   rv = fifo_segment_fl_chunk_bytes (fs);
2215
2216   /* Make sure that the non-power of two chunk freed above is correctly
2217    * accounted for in the chunk free bytes reduction due to chunk allocation
2218    * for the fifo, i.e., it's rounded up by 1 */
2219   SFIFO_TEST (n_free_chunk_bytes - 17 * fifo_size == rv, "free chunk bytes "
2220               "expected %u is %u", n_free_chunk_bytes - 17 * fifo_size, rv);
2221
2222   fifo_segment_free_fifo (fs, f);
2223
2224   rv = fifo_segment_fl_chunk_bytes (fs);
2225   SFIFO_TEST (n_free_chunk_bytes == rv, "free chunk bytes expected %u is %u",
2226               n_free_chunk_bytes, rv);
2227
2228   /*
2229    * Allocate fifo that has all chunks
2230    */
2231   f = fifo_segment_alloc_fifo (fs, n_free_chunk_bytes, FIFO_SEGMENT_RX_FIFO);
2232   SFIFO_TEST (f != 0, "allocation should work");
2233   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
2234
2235   fifo_segment_free_fifo (fs, f);
2236
2237   rv = fifo_segment_fl_chunk_bytes (fs);
2238   SFIFO_TEST (n_free_chunk_bytes == rv, "free chunk bytes expected %u is %u",
2239               n_free_chunk_bytes, rv);
2240
2241   /*
2242    * Try to allocate more than space available
2243    */
2244
2245   f = fifo_segment_alloc_fifo (fs, n_free_chunk_bytes + fifo_size,
2246                                FIFO_SEGMENT_RX_FIFO);
2247   SFIFO_TEST (f == 0, "allocation should fail");
2248
2249   /*
2250    * Allocate fifo and try to grow beyond available space
2251    */
2252   f = fifo_segment_alloc_fifo (fs, fifo_size, FIFO_SEGMENT_RX_FIFO);
2253   rv = fifo_segment_grow_fifo (fs, f, n_free_chunk_bytes);
2254
2255   SFIFO_TEST (rv == -1, "grow should fail");
2256
2257   fifo_segment_free_fifo (fs, f);
2258
2259   /*
2260    * Cleanup
2261    */
2262   fifo_segment_delete (sm, fs);
2263   vec_free (a->new_segment_indices);
2264   return 0;
2265 }
2266
2267 static int
2268 sfifo_test_fifo_segment_fifo_shrink (int verbose)
2269 {
2270   int i, rv, chunk_size = 4096, n_chunks, n_free;
2271   fifo_segment_main_t *sm = &segment_main;
2272   fifo_segment_create_args_t _a, *a = &_a;
2273   fifo_segment_t *fs;
2274   svm_fifo_t *f;
2275
2276   clib_memset (a, 0, sizeof (*a));
2277   a->segment_name = "fifo-test1";
2278   a->segment_size = 256 << 10;
2279
2280   rv = fifo_segment_create (sm, a);
2281
2282   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2283
2284   /*
2285    * Alloc and grow fifo
2286    */
2287   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2288   f = fifo_segment_alloc_fifo (fs, chunk_size, FIFO_SEGMENT_RX_FIFO);
2289   n_free = FIFO_SEGMENT_ALLOC_BATCH_SIZE - 1;
2290
2291   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo");
2292
2293   for (i = 0; i < 9; i++)
2294     {
2295       fifo_segment_grow_fifo (fs, f, chunk_size);
2296       n_free -= 1;
2297       if (f->size != (i + 2) * chunk_size)
2298         SFIFO_TEST (0, "fifo size should be %u is %u",
2299                     (i + 2) * chunk_size, f->size);
2300     }
2301
2302   rv = svm_fifo_reduce_size (f, 3.5 * chunk_size, 1 /* is producer */ );
2303   SFIFO_TEST (rv == 3 * chunk_size, "len expected %u is %u", 3 * chunk_size,
2304               rv);
2305
2306   n_chunks = fifo_segment_num_free_chunks (fs, chunk_size);
2307   SFIFO_TEST (n_chunks == n_free, "free chunks should be %u is %u", n_free,
2308               n_chunks);
2309
2310   fifo_segment_collect_fifo_chunks (fs, f);
2311
2312   n_free += 3;
2313   n_chunks = fifo_segment_num_free_chunks (fs, chunk_size);
2314   SFIFO_TEST (n_chunks == n_free, "free chunks should be %u is %u", n_free,
2315               n_chunks);
2316
2317   rv = svm_fifo_reduce_size (f, 7 * chunk_size - 1, 1 /* is producer */ );
2318   SFIFO_TEST (rv == 6 * chunk_size, "len expected %u is %u", 6 * chunk_size,
2319               rv);
2320
2321   fifo_segment_collect_fifo_chunks (fs, f);
2322
2323   n_free += 6;
2324   n_chunks = fifo_segment_num_free_chunks (fs, chunk_size);
2325   SFIFO_TEST (n_chunks == n_free, "free chunks should be %u is %u", n_free,
2326               n_chunks);
2327   /*
2328    * Free
2329    */
2330   fifo_segment_free_fifo (fs, f);
2331   n_free += 1;
2332   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
2333   SFIFO_TEST (n_chunks == n_free, "free chunks should be %u is %u", n_free,
2334               n_chunks);
2335
2336   /*
2337    * Cleanup
2338    */
2339   fifo_segment_delete (sm, fs);
2340   vec_free (a->new_segment_indices);
2341   return 0;
2342 }
2343
2344 static int
2345 sfifo_test_fifo_segment_slave (int verbose)
2346 {
2347   fifo_segment_create_args_t _a, *a = &_a;
2348   fifo_segment_main_t *sm = &segment_main;
2349   u8 *test_data, *retrieved_data = 0;
2350   fifo_segment_t *fs;
2351   svm_fifo_t *f;
2352   u32 *result;
2353   int rv, i;
2354
2355   sleep (2);
2356
2357   sm->timeout_in_seconds = 5;
2358   clib_memset (a, 0, sizeof (*a));
2359   a->segment_name = "fifo-test1";
2360
2361   rv = fifo_segment_attach (sm, a);
2362
2363   SFIFO_TEST (!rv, "svm_fifo_segment_attach returned %d", rv);
2364
2365   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2366   vec_free (a->new_segment_indices);
2367
2368   /* might wanna wait.. */
2369   f = fifo_segment_get_slice_fifo_list (fs, 0);
2370
2371   /* Lazy bastards united */
2372   test_data = format (0, "Hello world%c", 0);
2373   vec_validate (retrieved_data, vec_len (test_data) - 1);
2374
2375   for (i = 0; i < 1000; i++)
2376     {
2377       svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
2378       if (memcmp (retrieved_data, test_data, vec_len (retrieved_data)))
2379         {
2380           result = (u32 *) f->head_chunk->data;
2381           *result = 1;
2382           _exit (0);
2383         }
2384     }
2385
2386   result = (u32 *) f->head_chunk->data;
2387   *result = 0;
2388
2389   vec_free (test_data);
2390   vec_free (retrieved_data);
2391   _exit (0);
2392 }
2393
2394 static int
2395 sfifo_test_fifo_segment_master_slave (int verbose)
2396 {
2397   fifo_segment_create_args_t _a, *a = &_a;
2398   fifo_segment_main_t *sm = &segment_main;
2399   fifo_segment_t *sp;
2400   svm_fifo_t *f;
2401   u8 *test_data;
2402   u32 *result;
2403   int rv, i;
2404   pid_t pid;
2405
2406   pid = fork ();
2407   if (pid < 0)
2408     SFIFO_TEST (0, "fork failed");
2409
2410   if (!pid)
2411     sfifo_test_fifo_segment_slave (verbose);
2412
2413   clib_memset (a, 0, sizeof (*a));
2414   a->segment_name = "fifo-test1";
2415   a->segment_size = 256 << 10;
2416
2417   rv = fifo_segment_create (sm, a);
2418
2419   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2420
2421   sp = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2422   f = fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FIFO);
2423
2424   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo alloc");
2425
2426   test_data = format (0, "Hello world%c", 0);
2427
2428   usleep (200e3);
2429
2430   for (i = 0; i < 1000; i++)
2431     svm_fifo_enqueue (f, vec_len (test_data), test_data);
2432
2433   /* Wait for slave */
2434   i = 0;
2435   while (svm_fifo_max_dequeue (f) && i++ < 1e10)
2436     ;
2437
2438   usleep (1e3);
2439
2440   result = (u32 *) f->head_chunk->data;
2441   SFIFO_TEST (*result == 0, "slave reported no error");
2442
2443   vec_free (a->new_segment_indices);
2444   vec_free (test_data);
2445   fifo_segment_free_fifo (sp, f);
2446   fifo_segment_delete (sm, sp);
2447   return 0;
2448 }
2449
2450 static int
2451 sfifo_test_fifo_segment_mempig (int verbose)
2452 {
2453   fifo_segment_create_args_t _a, *a = &_a;
2454   fifo_segment_main_t *sm = &segment_main;
2455   fifo_segment_t *sp;
2456   svm_fifo_t *f;
2457   svm_fifo_t **flist = 0;
2458   int rv;
2459   int i;
2460
2461   clib_memset (a, 0, sizeof (*a));
2462
2463   a->segment_name = "fifo-test1";
2464   a->segment_size = 256 << 10;
2465
2466   rv = fifo_segment_create (sm, a);
2467
2468   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2469
2470   sp = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2471
2472   for (i = 0; i < 1000; i++)
2473     {
2474       f = fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FIFO);
2475       if (f == 0)
2476         break;
2477       vec_add1 (flist, f);
2478     }
2479
2480   SFIFO_TEST (vec_len (flist), "created %d fifos", vec_len (flist));
2481
2482   for (i = 0; i < vec_len (flist); i++)
2483     {
2484       f = flist[i];
2485       fifo_segment_free_fifo (sp, f);
2486     }
2487
2488   _vec_len (flist) = 0;
2489
2490   for (i = 0; i < 1000; i++)
2491     {
2492       f = fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FIFO);
2493       if (f == 0)
2494         break;
2495       vec_add1 (flist, f);
2496     }
2497
2498   SFIFO_TEST (vec_len (flist), "second try created %d fifos",
2499               vec_len (flist));
2500   for (i = 0; i < vec_len (flist); i++)
2501     {
2502       f = flist[i];
2503       fifo_segment_free_fifo (sp, f);
2504     }
2505
2506   fifo_segment_delete (sm, sp);
2507   return 0;
2508 }
2509
2510 static int
2511 sfifo_test_fifo_segment_prealloc (int verbose)
2512 {
2513   fifo_segment_create_args_t _a, *a = &_a;
2514   fifo_segment_main_t *sm = &segment_main;
2515   u32 max_pairs, pairs_req, free_space, pair_mem;
2516   svm_fifo_t *f, *old;
2517   fifo_segment_t *fs;
2518   int rv, alloc;
2519
2520   clib_memset (a, 0, sizeof (*a));
2521
2522   a->segment_name = "fifo-test-prealloc";
2523   a->segment_size = 256 << 10;
2524   a->segment_type = SSVM_SEGMENT_MEMFD;
2525
2526   rv = fifo_segment_create (sm, a);
2527   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2528   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2529
2530   /*
2531    * Prealloc chunks and headers
2532    */
2533   free_space = fifo_segment_free_bytes (fs);
2534   SFIFO_TEST (free_space <= 256 << 10, "free space expected %u is %u",
2535               256 << 10, free_space);
2536   rv = fifo_segment_prealloc_fifo_chunks (fs, 0, 4096, 50);
2537   SFIFO_TEST (rv == 0, "chunk prealloc should work");
2538   rv = fifo_segment_num_free_chunks (fs, 4096);
2539   SFIFO_TEST (rv == 50, "prealloc chunks expected %u is %u", 50, rv);
2540   rv = fifo_segment_free_bytes (fs);
2541   free_space -= (sizeof (svm_fifo_chunk_t) + 4096) * 50;
2542   SFIFO_TEST (rv == free_space, "free space expected %u is %u", free_space,
2543               rv);
2544   rv = fifo_segment_fl_chunk_bytes (fs);
2545   SFIFO_TEST (rv == 4096 * 50, "chunk free space expected %u is %u",
2546               4096 * 50, rv);
2547
2548   rv = fifo_segment_prealloc_fifo_hdrs (fs, 0, 50);
2549   SFIFO_TEST (rv == 0, "fifo hdr prealloc should work");
2550   rv = fifo_segment_num_free_fifos (fs);
2551   SFIFO_TEST (rv == 50, "prealloc fifo hdrs expected %u is %u", 50, rv);
2552   rv = fifo_segment_free_bytes (fs);
2553   free_space -= sizeof (svm_fifo_t) * 50;
2554   SFIFO_TEST (rv == free_space, "free space expected %u is %u", free_space,
2555               rv);
2556
2557   fifo_segment_update_free_bytes (fs);
2558   rv = fifo_segment_free_bytes (fs);
2559   SFIFO_TEST (clib_abs (rv - (int) free_space) < 512,
2560               "free space expected %u is %u", free_space, rv);
2561
2562   f = fifo_segment_alloc_fifo (fs, 200 << 10, FIFO_SEGMENT_RX_FIFO);
2563   SFIFO_TEST (f != 0, "fifo allocated");
2564   rv = fifo_segment_num_free_chunks (fs, 4096);
2565   SFIFO_TEST (rv == 0, "prealloc chunks expected %u is %u", 0, rv);
2566   rv = fifo_segment_fl_chunk_bytes (fs);
2567   SFIFO_TEST (rv == 0, "chunk free space expected %u is %u", 0, rv);
2568   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
2569
2570   /*
2571    * Multiple preallocs that consume the remaining space
2572    */
2573   fifo_segment_update_free_bytes (fs);
2574   free_space = fifo_segment_free_bytes (fs);
2575   pair_mem = 2 * (4096 + sizeof (*f) + sizeof (svm_fifo_chunk_t));
2576   max_pairs = pairs_req = (free_space / pair_mem) - 1;
2577   fifo_segment_preallocate_fifo_pairs (fs, 4096, 4096, &pairs_req);
2578   SFIFO_TEST (pairs_req == 0, "prealloc pairs should work req %u", max_pairs);
2579   rv = fifo_segment_num_free_chunks (fs, 4096);
2580   SFIFO_TEST (rv == max_pairs * 2, "prealloc chunks expected %u is %u",
2581               max_pairs * 2, rv);
2582
2583   fifo_segment_update_free_bytes (fs);
2584   rv = fifo_segment_free_bytes (fs);
2585   SFIFO_TEST (rv < 2 * pair_mem, "free bytes %u less than %u", rv,
2586               2 * pair_mem);
2587
2588   /* Preallocate as many more chunks as possible. Heap is almost full
2589    * so we may not use all the free space*/
2590   alloc = 0;
2591   while (!fifo_segment_prealloc_fifo_chunks (fs, 0, 4096, 1))
2592     alloc++;
2593   SFIFO_TEST (alloc, "chunk prealloc should work %u", alloc);
2594   rv = fifo_segment_num_free_chunks (fs, 4096);
2595   SFIFO_TEST (rv == max_pairs * 2 + alloc, "prealloc chunks expected %u "
2596               "is %u", max_pairs * 2 + alloc, rv);
2597
2598   rv = fifo_segment_free_bytes (fs);
2599   SFIFO_TEST (rv < pair_mem, "free bytes expected less than %u is %u",
2600               pair_mem, rv);
2601
2602   /*
2603    * Test negative prealloc cases
2604    */
2605   pairs_req = 1;
2606   fifo_segment_preallocate_fifo_pairs (fs, 4096, 4096, &pairs_req);
2607   SFIFO_TEST (pairs_req == 1, "prealloc pairs should not work");
2608
2609   old = f;
2610   f = fifo_segment_alloc_fifo (fs, 200 << 10, FIFO_SEGMENT_RX_FIFO);
2611   SFIFO_TEST (f == 0, "fifo alloc should fail");
2612
2613   rv = fifo_segment_prealloc_fifo_chunks (fs, 0, 4096, 50);
2614   SFIFO_TEST (rv == -1, "chunk prealloc should fail");
2615
2616   rv = fifo_segment_prealloc_fifo_hdrs (fs, 0, 50);
2617   SFIFO_TEST (rv == -1, "fifo hdr prealloc should fail");
2618
2619   /*
2620    * Cleanup
2621    */
2622   fifo_segment_free_fifo (fs, old);
2623   close (fs->ssvm.fd);
2624   fifo_segment_delete (sm, fs);
2625   return 0;
2626 }
2627
2628 static int
2629 sfifo_test_fifo_segment (vlib_main_t * vm, unformat_input_t * input)
2630 {
2631   int rv, verbose = 0;
2632
2633   fifo_segment_main_init (&segment_main, 3ULL << 30, 5);
2634   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2635     {
2636       if (unformat (input, "verbose"))
2637         verbose = 1;
2638       else if (unformat (input, "masterslave"))
2639         {
2640           if ((rv = sfifo_test_fifo_segment_master_slave (verbose)))
2641             return -1;
2642         }
2643       else if (unformat (input, "basic"))
2644         {
2645           if ((rv = sfifo_test_fifo_segment_hello_world (verbose)))
2646             return -1;
2647         }
2648       else if (unformat (input, "mempig"))
2649         {
2650           if ((rv = sfifo_test_fifo_segment_mempig (verbose)))
2651             return -1;
2652         }
2653       else if (unformat (input, "grow fifo"))
2654         {
2655           if ((rv = sfifo_test_fifo_segment_fifo_grow (verbose)))
2656             return -1;
2657         }
2658       else if (unformat (input, "shrink fifo"))
2659         {
2660           if ((rv = sfifo_test_fifo_segment_fifo_shrink (verbose)))
2661             return -1;
2662         }
2663       else if (unformat (input, "prealloc"))
2664         {
2665           if ((rv = sfifo_test_fifo_segment_prealloc (verbose)))
2666             return -1;
2667         }
2668       else if (unformat (input, "all"))
2669         {
2670           if ((rv = sfifo_test_fifo_segment_hello_world (verbose)))
2671             return -1;
2672           if ((rv = sfifo_test_fifo_segment_mempig (verbose)))
2673             return -1;
2674           if ((rv = sfifo_test_fifo_segment_fifo_grow (verbose)))
2675             return -1;
2676           if ((rv = sfifo_test_fifo_segment_fifo_shrink (verbose)))
2677             return -1;
2678           if ((rv = sfifo_test_fifo_segment_prealloc (verbose)))
2679             return -1;
2680           /* Pretty slow so avoid running it always
2681              if ((rv = sfifo_test_fifo_segment_master_slave (verbose)))
2682              return -1;
2683            */
2684         }
2685       else
2686         {
2687           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
2688                            input);
2689           return -1;
2690         }
2691     }
2692   return 0;
2693 }
2694
2695 static clib_error_t *
2696 svm_fifo_test (vlib_main_t * vm, unformat_input_t * input,
2697                vlib_cli_command_t * cmd_arg)
2698 {
2699   int res = 0;
2700   char *str;
2701
2702
2703   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2704     {
2705       if (unformat (input, "fifo1"))
2706         res = sfifo_test_fifo1 (vm, input);
2707       else if (unformat (input, "fifo2"))
2708         res = sfifo_test_fifo2 (vm);
2709       else if (unformat (input, "fifo3"))
2710         res = sfifo_test_fifo3 (vm, input);
2711       else if (unformat (input, "fifo4"))
2712         res = sfifo_test_fifo4 (vm, input);
2713       else if (unformat (input, "fifo5"))
2714         res = sfifo_test_fifo5 (vm, input);
2715       else if (unformat (input, "fifo6"))
2716         res = sfifo_test_fifo6 (vm, input);
2717       else if (unformat (input, "fifo7"))
2718         res = sfifo_test_fifo7 (vm, input);
2719       else if (unformat (input, "large"))
2720         res = sfifo_test_fifo_large (vm, input);
2721       else if (unformat (input, "replay"))
2722         res = sfifo_test_fifo_replay (vm, input);
2723       else if (unformat (input, "grow"))
2724         res = sfifo_test_fifo_grow (vm, input);
2725       else if (unformat (input, "shrink"))
2726         res = sfifo_test_fifo_shrink (vm, input);
2727       else if (unformat (input, "segment"))
2728         res = sfifo_test_fifo_segment (vm, input);
2729       else if (unformat (input, "all"))
2730         {
2731           if ((res = sfifo_test_fifo1 (vm, input)))
2732             goto done;
2733
2734           if ((res = sfifo_test_fifo2 (vm)))
2735             goto done;
2736
2737           /*
2738            * Run a number of fifo3 configs
2739            */
2740           str = "nsegs 10 overlap seed 123";
2741           unformat_init_cstring (input, str);
2742           if ((res = sfifo_test_fifo3 (vm, input)))
2743             goto done;
2744           unformat_free (input);
2745
2746           str = "nsegs 10 overlap seed 123 in-seq-all";
2747           unformat_init_cstring (input, str);
2748           if ((res = sfifo_test_fifo3 (vm, input)))
2749             goto done;
2750           unformat_free (input);
2751
2752           str = "nsegs 10 overlap seed 123 initial-offset 3917";
2753           unformat_init_cstring (input, str);
2754           if ((res = sfifo_test_fifo3 (vm, input)))
2755             goto done;
2756           unformat_free (input);
2757
2758           str = "nsegs 10 overlap seed 123 initial-offset 3917 drop";
2759           unformat_init_cstring (input, str);
2760           if ((res = sfifo_test_fifo3 (vm, input)))
2761             goto done;
2762           unformat_free (input);
2763
2764           str = "nsegs 10 seed 123 initial-offset 3917 drop no-randomize";
2765           unformat_init_cstring (input, str);
2766           if ((res = sfifo_test_fifo3 (vm, input)))
2767             goto done;
2768           unformat_free (input);
2769
2770           if ((res = sfifo_test_fifo4 (vm, input)))
2771             goto done;
2772
2773           if ((res = sfifo_test_fifo5 (vm, input)))
2774             goto done;
2775
2776           if ((res = sfifo_test_fifo6 (vm, input)))
2777             goto done;
2778
2779           if ((res = sfifo_test_fifo7 (vm, input)))
2780             goto done;
2781
2782           if ((res = sfifo_test_fifo_grow (vm, input)))
2783             goto done;
2784
2785           if ((res = sfifo_test_fifo_shrink (vm, input)))
2786             goto done;
2787
2788           str = "all";
2789           unformat_init_cstring (input, str);
2790           if ((res = sfifo_test_fifo_segment (vm, input)))
2791             goto done;
2792         }
2793       else
2794         {
2795           vlib_cli_output (vm, "unknown input `%U'", format_unformat_error,
2796                            input);
2797           res = -1;
2798           goto done;
2799         }
2800
2801     }
2802
2803 done:
2804   if (res)
2805     return clib_error_return (0, "svm fifo unit test failed");
2806   return 0;
2807 }
2808
2809 /* *INDENT-OFF* */
2810 VLIB_CLI_COMMAND (svm_fifo_test_command, static) =
2811 {
2812   .path = "test svm fifo",
2813   .short_help = "internal svm fifo unit tests",
2814   .function = svm_fifo_test,
2815 };
2816 /* *INDENT-ON* */
2817
2818 /*
2819  * fd.io coding-style-patch-verification: ON
2820  *
2821  * Local Variables:
2822  * eval: (c-set-style "gnu")
2823  * End:
2824  */