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 int
2016 sfifo_test_fifo_segment_hello_world (int verbose)
2017 {
2018   fifo_segment_create_args_t _a, *a = &_a;
2019   fifo_segment_main_t *sm = &segment_main;
2020   u8 *test_data, *retrieved_data = 0;
2021   fifo_segment_t *fs;
2022   svm_fifo_t *f;
2023   int rv;
2024
2025   clib_memset (a, 0, sizeof (*a));
2026   a->segment_name = "fifo-test1";
2027   a->segment_size = 256 << 10;
2028
2029   rv = fifo_segment_create (sm, a);
2030   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2031
2032   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2033   f = fifo_segment_alloc_fifo (fs, 4096, FIFO_SEGMENT_RX_FIFO);
2034
2035   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo");
2036
2037   test_data = format (0, "Hello world%c", 0);
2038   vec_validate (retrieved_data, vec_len (test_data) - 1);
2039
2040   while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
2041     svm_fifo_enqueue (f, vec_len (test_data), test_data);
2042
2043   while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
2044     svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
2045
2046   while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
2047     svm_fifo_enqueue (f, vec_len (test_data), test_data);
2048
2049   while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
2050     svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
2051
2052   SFIFO_TEST (!memcmp (retrieved_data, test_data, vec_len (test_data)),
2053               "data should be identical");
2054
2055   vec_free (test_data);
2056   vec_free (retrieved_data);
2057   vec_free (a->new_segment_indices);
2058   fifo_segment_free_fifo (fs, f);
2059   fifo_segment_delete (sm, fs);
2060   return 0;
2061 }
2062
2063 static int
2064 sfifo_test_fifo_segment_fifo_grow (int verbose)
2065 {
2066   int rv, fifo_size = 4096, n_chunks, n_batch;
2067   fifo_segment_main_t *sm = &segment_main;
2068   fifo_segment_create_args_t _a, *a = &_a;
2069   u32 n_free_chunk_bytes;
2070   fifo_segment_t *fs;
2071   svm_fifo_t *f;
2072
2073   clib_memset (a, 0, sizeof (*a));
2074   a->segment_name = "fifo-test1";
2075   /* size chosen to be able to force multi chunk allocation lower */
2076   a->segment_size = 256 << 10;
2077
2078   /* fifo allocation allocates chunks in batch */
2079   n_batch = FIFO_SEGMENT_ALLOC_BATCH_SIZE;
2080
2081   rv = fifo_segment_create (sm, a);
2082
2083   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2084
2085   /*
2086    * Alloc and grow fifo
2087    */
2088   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2089   f = fifo_segment_alloc_fifo (fs, fifo_size, FIFO_SEGMENT_RX_FIFO);
2090
2091   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo");
2092
2093   n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
2094   SFIFO_TEST (n_chunks == n_batch - 1, "free 2^10B chunks "
2095               "should be %u is %u", n_batch - 1, n_chunks);
2096   rv = fifo_segment_fl_chunk_bytes (fs);
2097   SFIFO_TEST (rv == (n_batch - 1) * fifo_size, "free chunk bytes %u "
2098               "expected %u", rv, (n_batch - 1) * fifo_size);
2099
2100   /* Grow by preallocated fifo_size chunk */
2101   fifo_segment_grow_fifo (fs, f, fifo_size);
2102   SFIFO_TEST (f->size == 2 * fifo_size, "fifo size should be %u is %u",
2103               2 * fifo_size, f->size);
2104   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
2105
2106   n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
2107   SFIFO_TEST (n_chunks == n_batch - 2, "free 2^10B chunks "
2108               "should be %u is %u", n_batch - 2, n_chunks);
2109   rv = fifo_segment_fl_chunk_bytes (fs);
2110   SFIFO_TEST (rv == (n_batch - 2) * fifo_size, "free chunk bytes %u "
2111               "expected %u", rv, (n_batch - 2) * fifo_size);
2112
2113   /* Grow by a size not preallocated but first make sure there's space */
2114   rv = fifo_segment_free_bytes (fs);
2115   SFIFO_TEST (rv > 16 * fifo_size, "free bytes %u more than %u", rv,
2116               16 * fifo_size);
2117
2118   fifo_segment_grow_fifo (fs, f, 16 * fifo_size);
2119   SFIFO_TEST (f->size == 18 * fifo_size, "fifo size should be %u is %u",
2120               18 * fifo_size, f->size);
2121
2122   rv = fifo_segment_fl_chunk_bytes (fs);
2123   SFIFO_TEST (rv == (n_batch - 2) * fifo_size, "free chunk bytes %u "
2124               "expected %u", rv, (n_batch - 2) * fifo_size);
2125
2126   /*
2127    * Free and test free list size
2128    */
2129   fifo_segment_free_fifo (fs, f);
2130
2131   rv = fifo_segment_fl_chunk_bytes (fs);
2132   SFIFO_TEST (rv == (16 + n_batch) * fifo_size, "free chunk bytes expected %u"
2133               " is %u", (16 + n_batch) * fifo_size, rv);
2134   n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
2135   SFIFO_TEST (n_chunks == n_batch, "free 2^10B chunks "
2136               "should be %u is %u", n_batch, n_chunks);
2137   n_chunks = fifo_segment_num_free_chunks (fs, 16 * fifo_size);
2138   SFIFO_TEST (n_chunks == 1, "free 2^14B chunks should be %u is %u", 1,
2139               n_chunks);
2140   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
2141   SFIFO_TEST (n_chunks == 1 + n_batch, "free chunks should be %u is %u",
2142               1 + n_batch, n_chunks);
2143
2144   /*
2145    * Realloc fifo
2146    */
2147   f = fifo_segment_alloc_fifo (fs, fifo_size, FIFO_SEGMENT_RX_FIFO);
2148
2149   fifo_segment_grow_fifo (fs, f, fifo_size);
2150   n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
2151   SFIFO_TEST (n_chunks == n_batch - 2, "free 2^10B chunks should be %u is %u",
2152               n_batch - 2, n_chunks);
2153
2154   fifo_segment_grow_fifo (fs, f, 16 * fifo_size);
2155   n_chunks = fifo_segment_num_free_chunks (fs, 16 * fifo_size);
2156   SFIFO_TEST (n_chunks == 0, "free 2^14B chunks should be %u is %u", 0,
2157               n_chunks);
2158   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
2159   SFIFO_TEST (n_chunks == n_batch - 2, "free chunks should be %u is %u",
2160               n_batch - 2, n_chunks);
2161
2162   /*
2163    * Free again
2164    */
2165   fifo_segment_free_fifo (fs, f);
2166   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
2167   SFIFO_TEST (n_chunks == 1 + n_batch, "free chunks should be %u is %u",
2168               1 + n_batch, n_chunks);
2169
2170   rv = fifo_segment_fl_chunk_bytes (fs);
2171   SFIFO_TEST (rv == (16 + n_batch) * fifo_size, "free chunk bytes expected %u"
2172               " is %u", (16 + n_batch) * fifo_size, rv);
2173
2174   n_free_chunk_bytes = rv;
2175
2176   /*
2177    * Allocate non power of 2 fifo/chunk and check that free chunk bytes
2178    * is correctly updated
2179    */
2180
2181   f = fifo_segment_alloc_fifo (fs, 16 * fifo_size - 1, FIFO_SEGMENT_RX_FIFO);
2182   rv = fifo_segment_fl_chunk_bytes (fs);
2183
2184   SFIFO_TEST (n_free_chunk_bytes - 16 * fifo_size == rv, "free chunk bytes "
2185               "expected %u is %u", n_free_chunk_bytes - 16 * fifo_size, rv);
2186   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
2187
2188   fifo_segment_free_fifo (fs, f);
2189   rv = fifo_segment_fl_chunk_bytes (fs);
2190
2191   SFIFO_TEST (n_free_chunk_bytes == rv, "free chunk bytes expected %u is %u",
2192               n_free_chunk_bytes, rv);
2193
2194   /*
2195    * Force multi chunk fifo allocation
2196    */
2197
2198   /* Check that we can force multi chunk allocation. Note that fifo size
2199    * rounded up to power of 2, i.e., 17 becomes 32 */
2200   rv = fifo_segment_free_bytes (fs);
2201   SFIFO_TEST (rv < 32 * fifo_size, "free bytes %u less than %u", rv,
2202               32 * fifo_size);
2203
2204   f = fifo_segment_alloc_fifo (fs, 17 * fifo_size, FIFO_SEGMENT_RX_FIFO);
2205   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
2206
2207   rv = fifo_segment_fl_chunk_bytes (fs);
2208
2209   /* Make sure that the non-power of two chunk freed above is correctly
2210    * accounted for in the chunk free bytes reduction due to chunk allocation
2211    * for the fifo, i.e., it's rounded up by 1 */
2212   SFIFO_TEST (n_free_chunk_bytes - 17 * fifo_size == rv, "free chunk bytes "
2213               "expected %u is %u", n_free_chunk_bytes - 17 * fifo_size, rv);
2214
2215   fifo_segment_free_fifo (fs, f);
2216
2217   rv = fifo_segment_fl_chunk_bytes (fs);
2218   SFIFO_TEST (n_free_chunk_bytes == rv, "free chunk bytes expected %u is %u",
2219               n_free_chunk_bytes, rv);
2220
2221   /*
2222    * Allocate fifo that has all chunks
2223    */
2224   f = fifo_segment_alloc_fifo (fs, n_free_chunk_bytes, FIFO_SEGMENT_RX_FIFO);
2225   SFIFO_TEST (f != 0, "allocation should work");
2226   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
2227
2228   fifo_segment_free_fifo (fs, f);
2229
2230   rv = fifo_segment_fl_chunk_bytes (fs);
2231   SFIFO_TEST (n_free_chunk_bytes == rv, "free chunk bytes expected %u is %u",
2232               n_free_chunk_bytes, rv);
2233
2234   /*
2235    * Try to allocate more than space available
2236    */
2237
2238   f = fifo_segment_alloc_fifo (fs, n_free_chunk_bytes + fifo_size,
2239                                FIFO_SEGMENT_RX_FIFO);
2240   SFIFO_TEST (f == 0, "allocation should fail");
2241
2242   /*
2243    * Allocate fifo and try to grow beyond available space
2244    */
2245   f = fifo_segment_alloc_fifo (fs, fifo_size, FIFO_SEGMENT_RX_FIFO);
2246   rv = fifo_segment_grow_fifo (fs, f, n_free_chunk_bytes);
2247
2248   SFIFO_TEST (rv == -1, "grow should fail");
2249
2250   fifo_segment_free_fifo (fs, f);
2251
2252   /*
2253    * Cleanup
2254    */
2255   fifo_segment_delete (sm, fs);
2256   vec_free (a->new_segment_indices);
2257   return 0;
2258 }
2259
2260 static int
2261 sfifo_test_fifo_segment_fifo_shrink (int verbose)
2262 {
2263   int i, rv, chunk_size = 4096, n_chunks, n_free;
2264   fifo_segment_main_t *sm = &segment_main;
2265   fifo_segment_create_args_t _a, *a = &_a;
2266   fifo_segment_t *fs;
2267   svm_fifo_t *f;
2268
2269   clib_memset (a, 0, sizeof (*a));
2270   a->segment_name = "fifo-test1";
2271   a->segment_size = 256 << 10;
2272
2273   rv = fifo_segment_create (sm, a);
2274
2275   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2276
2277   /*
2278    * Alloc and grow fifo
2279    */
2280   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2281   f = fifo_segment_alloc_fifo (fs, chunk_size, FIFO_SEGMENT_RX_FIFO);
2282   n_free = FIFO_SEGMENT_ALLOC_BATCH_SIZE - 1;
2283
2284   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo");
2285
2286   for (i = 0; i < 9; i++)
2287     {
2288       fifo_segment_grow_fifo (fs, f, chunk_size);
2289       n_free -= 1;
2290       if (f->size != (i + 2) * chunk_size)
2291         SFIFO_TEST (0, "fifo size should be %u is %u",
2292                     (i + 2) * chunk_size, f->size);
2293     }
2294
2295   rv = svm_fifo_reduce_size (f, 3.5 * chunk_size, 1 /* is producer */ );
2296   SFIFO_TEST (rv == 3 * chunk_size, "len expected %u is %u", 3 * chunk_size,
2297               rv);
2298
2299   n_chunks = fifo_segment_num_free_chunks (fs, chunk_size);
2300   SFIFO_TEST (n_chunks == n_free, "free chunks should be %u is %u", n_free,
2301               n_chunks);
2302
2303   fifo_segment_collect_fifo_chunks (fs, f);
2304
2305   n_free += 3;
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   rv = svm_fifo_reduce_size (f, 7 * chunk_size - 1, 1 /* is producer */ );
2311   SFIFO_TEST (rv == 6 * chunk_size, "len expected %u is %u", 6 * chunk_size,
2312               rv);
2313
2314   fifo_segment_collect_fifo_chunks (fs, f);
2315
2316   n_free += 6;
2317   n_chunks = fifo_segment_num_free_chunks (fs, chunk_size);
2318   SFIFO_TEST (n_chunks == n_free, "free chunks should be %u is %u", n_free,
2319               n_chunks);
2320   /*
2321    * Free
2322    */
2323   fifo_segment_free_fifo (fs, f);
2324   n_free += 1;
2325   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
2326   SFIFO_TEST (n_chunks == n_free, "free chunks should be %u is %u", n_free,
2327               n_chunks);
2328
2329   /*
2330    * Cleanup
2331    */
2332   fifo_segment_delete (sm, fs);
2333   vec_free (a->new_segment_indices);
2334   return 0;
2335 }
2336
2337 static int
2338 sfifo_test_fifo_segment_slave (int verbose)
2339 {
2340   fifo_segment_create_args_t _a, *a = &_a;
2341   fifo_segment_main_t *sm = &segment_main;
2342   u8 *test_data, *retrieved_data = 0;
2343   fifo_segment_t *sp;
2344   fifo_segment_header_t *fsh;
2345   ssvm_shared_header_t *sh;
2346   svm_fifo_t *f;
2347   u32 *result;
2348   int rv, i;
2349
2350   sleep (2);
2351
2352   sm->timeout_in_seconds = 5;
2353   clib_memset (a, 0, sizeof (*a));
2354   a->segment_name = "fifo-test1";
2355
2356   rv = fifo_segment_attach (sm, a);
2357
2358   SFIFO_TEST (!rv, "svm_fifo_segment_attach returned %d", rv);
2359
2360   sp = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2361   vec_free (a->new_segment_indices);
2362   sh = sp->ssvm.sh;
2363   fsh = (fifo_segment_header_t *) sh->opaque[0];
2364
2365   /* might wanna wait.. */
2366   f = fsh->fifos;
2367
2368   /* Lazy bastards united */
2369   test_data = format (0, "Hello world%c", 0);
2370   vec_validate (retrieved_data, vec_len (test_data) - 1);
2371
2372   for (i = 0; i < 1000; i++)
2373     {
2374       svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
2375       if (memcmp (retrieved_data, test_data, vec_len (retrieved_data)))
2376         {
2377           result = (u32 *) f->head_chunk->data;
2378           *result = 1;
2379           _exit (0);
2380         }
2381     }
2382
2383   result = (u32 *) f->head_chunk->data;
2384   *result = 0;
2385
2386   vec_free (test_data);
2387   vec_free (retrieved_data);
2388   _exit (0);
2389 }
2390
2391 static int
2392 sfifo_test_fifo_segment_master_slave (int verbose)
2393 {
2394   fifo_segment_create_args_t _a, *a = &_a;
2395   fifo_segment_main_t *sm = &segment_main;
2396   fifo_segment_t *sp;
2397   svm_fifo_t *f;
2398   u8 *test_data;
2399   u32 *result;
2400   int rv, i;
2401   pid_t pid;
2402
2403   pid = fork ();
2404   if (pid < 0)
2405     SFIFO_TEST (0, "fork failed");
2406
2407   if (!pid)
2408     sfifo_test_fifo_segment_slave (verbose);
2409
2410   clib_memset (a, 0, sizeof (*a));
2411   a->segment_name = "fifo-test1";
2412   a->segment_size = 256 << 10;
2413
2414   rv = fifo_segment_create (sm, a);
2415
2416   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2417
2418   sp = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2419   f = fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FIFO);
2420
2421   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo alloc");
2422
2423   test_data = format (0, "Hello world%c", 0);
2424
2425   usleep (200e3);
2426
2427   for (i = 0; i < 1000; i++)
2428     svm_fifo_enqueue (f, vec_len (test_data), test_data);
2429
2430   /* Wait for slave */
2431   i = 0;
2432   while (svm_fifo_max_dequeue (f) && i++ < 1e10)
2433     ;
2434
2435   usleep (1e3);
2436
2437   result = (u32 *) f->head_chunk->data;
2438   SFIFO_TEST (*result == 0, "slave reported no error");
2439
2440   vec_free (a->new_segment_indices);
2441   vec_free (test_data);
2442   fifo_segment_free_fifo (sp, f);
2443   fifo_segment_delete (sm, sp);
2444   return 0;
2445 }
2446
2447 static int
2448 sfifo_test_fifo_segment_mempig (int verbose)
2449 {
2450   fifo_segment_create_args_t _a, *a = &_a;
2451   fifo_segment_main_t *sm = &segment_main;
2452   fifo_segment_t *sp;
2453   svm_fifo_t *f;
2454   svm_fifo_t **flist = 0;
2455   int rv;
2456   int i;
2457
2458   clib_memset (a, 0, sizeof (*a));
2459
2460   a->segment_name = "fifo-test1";
2461   a->segment_size = 256 << 10;
2462
2463   rv = fifo_segment_create (sm, a);
2464
2465   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2466
2467   sp = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2468
2469   for (i = 0; i < 1000; i++)
2470     {
2471       f = fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FIFO);
2472       if (f == 0)
2473         break;
2474       vec_add1 (flist, f);
2475     }
2476
2477   SFIFO_TEST (vec_len (flist), "created %d fifos", vec_len (flist));
2478
2479   for (i = 0; i < vec_len (flist); i++)
2480     {
2481       f = flist[i];
2482       fifo_segment_free_fifo (sp, f);
2483     }
2484
2485   _vec_len (flist) = 0;
2486
2487   for (i = 0; i < 1000; i++)
2488     {
2489       f = fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FIFO);
2490       if (f == 0)
2491         break;
2492       vec_add1 (flist, f);
2493     }
2494
2495   SFIFO_TEST (vec_len (flist), "second try created %d fifos",
2496               vec_len (flist));
2497   for (i = 0; i < vec_len (flist); i++)
2498     {
2499       f = flist[i];
2500       fifo_segment_free_fifo (sp, f);
2501     }
2502
2503   fifo_segment_delete (sm, sp);
2504   return 0;
2505 }
2506
2507 static int
2508 sfifo_test_fifo_segment_prealloc (int verbose)
2509 {
2510   fifo_segment_create_args_t _a, *a = &_a;
2511   fifo_segment_main_t *sm = &segment_main;
2512   u32 max_pairs, pairs_req, free_space, pair_mem;
2513   svm_fifo_t *f, *old;
2514   fifo_segment_t *fs;
2515   int rv, alloc;
2516
2517   clib_memset (a, 0, sizeof (*a));
2518
2519   a->segment_name = "fifo-test-prealloc";
2520   a->segment_size = 256 << 10;
2521   a->segment_type = SSVM_SEGMENT_MEMFD;
2522
2523   rv = fifo_segment_create (sm, a);
2524   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2525   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2526
2527   /*
2528    * Prealloc chunks and headers
2529    */
2530   free_space = fifo_segment_free_bytes (fs);
2531   SFIFO_TEST (free_space <= 256 << 10, "free space expected %u is %u",
2532               256 << 10, free_space);
2533   rv = fifo_segment_prealloc_fifo_chunks (fs, 4096, 50);
2534   SFIFO_TEST (rv == 0, "chunk prealloc should work");
2535   rv = fifo_segment_num_free_chunks (fs, 4096);
2536   SFIFO_TEST (rv == 50, "prealloc chunks expected %u is %u", 50, rv);
2537   rv = fifo_segment_free_bytes (fs);
2538   free_space -= (sizeof (svm_fifo_chunk_t) + 4096) * 50;
2539   SFIFO_TEST (rv == free_space, "free space expected %u is %u", free_space,
2540               rv);
2541   rv = fifo_segment_fl_chunk_bytes (fs);
2542   SFIFO_TEST (rv == 4096 * 50, "chunk free space expected %u is %u",
2543               4096 * 50, rv);
2544
2545   rv = fifo_segment_prealloc_fifo_hdrs (fs, 50);
2546   SFIFO_TEST (rv == 0, "fifo hdr prealloc should work");
2547   rv = fifo_segment_num_free_fifos (fs);
2548   SFIFO_TEST (rv == 50, "prealloc fifo hdrs expected %u is %u", 50, rv);
2549   rv = fifo_segment_free_bytes (fs);
2550   free_space -= sizeof (svm_fifo_t) * 50;
2551   SFIFO_TEST (rv == free_space, "free space expected %u is %u", free_space,
2552               rv);
2553
2554   fifo_segment_update_free_bytes (fs);
2555   rv = fifo_segment_free_bytes (fs);
2556   SFIFO_TEST (clib_abs (rv - (int) free_space) < 512,
2557               "free space expected %u is %u", free_space, rv);
2558
2559   f = fifo_segment_alloc_fifo (fs, 200 << 10, FIFO_SEGMENT_RX_FIFO);
2560   SFIFO_TEST (f != 0, "fifo allocated");
2561   rv = fifo_segment_num_free_chunks (fs, 4096);
2562   SFIFO_TEST (rv == 0, "prealloc chunks expected %u is %u", 0, rv);
2563   rv = fifo_segment_fl_chunk_bytes (fs);
2564   SFIFO_TEST (rv == 0, "chunk free space expected %u is %u", 0, rv);
2565   SFIFO_TEST (svm_fifo_is_sane (f), "fifo should be sane");
2566
2567   /*
2568    * Multiple preallocs that consume the remaining space
2569    */
2570   fifo_segment_update_free_bytes (fs);
2571   free_space = fifo_segment_free_bytes (fs);
2572   pair_mem = 2 * (4096 + sizeof (*f) + sizeof (svm_fifo_chunk_t));
2573   max_pairs = pairs_req = (free_space / pair_mem) - 1;
2574   fifo_segment_preallocate_fifo_pairs (fs, 4096, 4096, &pairs_req);
2575   SFIFO_TEST (pairs_req == 0, "prealloc pairs should work req %u", max_pairs);
2576   rv = fifo_segment_num_free_chunks (fs, 4096);
2577   SFIFO_TEST (rv == max_pairs * 2, "prealloc chunks expected %u is %u",
2578               max_pairs * 2, rv);
2579
2580   fifo_segment_update_free_bytes (fs);
2581   rv = fifo_segment_free_bytes (fs);
2582   SFIFO_TEST (rv < 2 * pair_mem, "free bytes %u less than %u", rv,
2583               2 * pair_mem);
2584
2585   /* Preallocate as many more chunks as possible. Heap is almost full
2586    * so we may not use all the free space*/
2587   alloc = 0;
2588   while (!fifo_segment_prealloc_fifo_chunks (fs, 4096, 1))
2589     alloc++;
2590   SFIFO_TEST (alloc, "chunk prealloc should work %u", alloc);
2591   rv = fifo_segment_num_free_chunks (fs, 4096);
2592   SFIFO_TEST (rv == max_pairs * 2 + alloc, "prealloc chunks expected %u "
2593               "is %u", max_pairs * 2 + alloc, rv);
2594
2595   rv = fifo_segment_free_bytes (fs);
2596   SFIFO_TEST (rv < pair_mem, "free bytes expected less than %u is %u",
2597               pair_mem, rv);
2598
2599   /*
2600    * Test negative prealloc cases
2601    */
2602   pairs_req = 1;
2603   fifo_segment_preallocate_fifo_pairs (fs, 4096, 4096, &pairs_req);
2604   SFIFO_TEST (pairs_req == 1, "prealloc pairs should not work");
2605
2606   old = f;
2607   f = fifo_segment_alloc_fifo (fs, 200 << 10, FIFO_SEGMENT_RX_FIFO);
2608   SFIFO_TEST (f == 0, "fifo alloc should fail");
2609
2610   rv = fifo_segment_prealloc_fifo_chunks (fs, 4096, 50);
2611   SFIFO_TEST (rv == -1, "chunk prealloc should fail");
2612
2613   rv = fifo_segment_prealloc_fifo_hdrs (fs, 50);
2614   SFIFO_TEST (rv == -1, "fifo hdr prealloc should fail");
2615
2616   /*
2617    * Cleanup
2618    */
2619   fifo_segment_free_fifo (fs, old);
2620   close (fs->ssvm.fd);
2621   fifo_segment_delete (sm, fs);
2622   return 0;
2623 }
2624
2625 static int
2626 sfifo_test_fifo_segment (vlib_main_t * vm, unformat_input_t * input)
2627 {
2628   int rv, verbose = 0;
2629
2630   fifo_segment_main_init (&segment_main, 3ULL << 30, 5);
2631   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2632     {
2633       if (unformat (input, "verbose"))
2634         verbose = 1;
2635       else if (unformat (input, "masterslave"))
2636         {
2637           if ((rv = sfifo_test_fifo_segment_master_slave (verbose)))
2638             return -1;
2639         }
2640       else if (unformat (input, "basic"))
2641         {
2642           if ((rv = sfifo_test_fifo_segment_hello_world (verbose)))
2643             return -1;
2644         }
2645       else if (unformat (input, "mempig"))
2646         {
2647           if ((rv = sfifo_test_fifo_segment_mempig (verbose)))
2648             return -1;
2649         }
2650       else if (unformat (input, "grow fifo"))
2651         {
2652           if ((rv = sfifo_test_fifo_segment_fifo_grow (verbose)))
2653             return -1;
2654         }
2655       else if (unformat (input, "shrink fifo"))
2656         {
2657           if ((rv = sfifo_test_fifo_segment_fifo_shrink (verbose)))
2658             return -1;
2659         }
2660       else if (unformat (input, "prealloc"))
2661         {
2662           if ((rv = sfifo_test_fifo_segment_prealloc (verbose)))
2663             return -1;
2664         }
2665       else if (unformat (input, "all"))
2666         {
2667           if ((rv = sfifo_test_fifo_segment_hello_world (verbose)))
2668             return -1;
2669           if ((rv = sfifo_test_fifo_segment_mempig (verbose)))
2670             return -1;
2671           if ((rv = sfifo_test_fifo_segment_fifo_grow (verbose)))
2672             return -1;
2673           if ((rv = sfifo_test_fifo_segment_fifo_shrink (verbose)))
2674             return -1;
2675           if ((rv = sfifo_test_fifo_segment_prealloc (verbose)))
2676             return -1;
2677           /* Pretty slow so avoid running it always
2678              if ((rv = sfifo_test_fifo_segment_master_slave (verbose)))
2679              return -1;
2680            */
2681         }
2682       else
2683         {
2684           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
2685                            input);
2686           return -1;
2687         }
2688     }
2689   return 0;
2690 }
2691
2692 static clib_error_t *
2693 svm_fifo_test (vlib_main_t * vm, unformat_input_t * input,
2694                vlib_cli_command_t * cmd_arg)
2695 {
2696   int res = 0;
2697   char *str;
2698
2699
2700   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2701     {
2702       if (unformat (input, "fifo1"))
2703         res = sfifo_test_fifo1 (vm, input);
2704       else if (unformat (input, "fifo2"))
2705         res = sfifo_test_fifo2 (vm);
2706       else if (unformat (input, "fifo3"))
2707         res = sfifo_test_fifo3 (vm, input);
2708       else if (unformat (input, "fifo4"))
2709         res = sfifo_test_fifo4 (vm, input);
2710       else if (unformat (input, "fifo5"))
2711         res = sfifo_test_fifo5 (vm, input);
2712       else if (unformat (input, "fifo6"))
2713         res = sfifo_test_fifo6 (vm, input);
2714       else if (unformat (input, "fifo7"))
2715         res = sfifo_test_fifo7 (vm, input);
2716       else if (unformat (input, "large"))
2717         res = sfifo_test_fifo_large (vm, input);
2718       else if (unformat (input, "replay"))
2719         res = sfifo_test_fifo_replay (vm, input);
2720       else if (unformat (input, "grow"))
2721         res = sfifo_test_fifo_grow (vm, input);
2722       else if (unformat (input, "shrink"))
2723         res = sfifo_test_fifo_shrink (vm, input);
2724       else if (unformat (input, "segment"))
2725         res = sfifo_test_fifo_segment (vm, input);
2726       else if (unformat (input, "all"))
2727         {
2728           if ((res = sfifo_test_fifo1 (vm, input)))
2729             goto done;
2730
2731           if ((res = sfifo_test_fifo2 (vm)))
2732             goto done;
2733
2734           /*
2735            * Run a number of fifo3 configs
2736            */
2737           str = "nsegs 10 overlap seed 123";
2738           unformat_init_cstring (input, str);
2739           if ((res = sfifo_test_fifo3 (vm, input)))
2740             goto done;
2741           unformat_free (input);
2742
2743           str = "nsegs 10 overlap seed 123 in-seq-all";
2744           unformat_init_cstring (input, str);
2745           if ((res = sfifo_test_fifo3 (vm, input)))
2746             goto done;
2747           unformat_free (input);
2748
2749           str = "nsegs 10 overlap seed 123 initial-offset 3917";
2750           unformat_init_cstring (input, str);
2751           if ((res = sfifo_test_fifo3 (vm, input)))
2752             goto done;
2753           unformat_free (input);
2754
2755           str = "nsegs 10 overlap seed 123 initial-offset 3917 drop";
2756           unformat_init_cstring (input, str);
2757           if ((res = sfifo_test_fifo3 (vm, input)))
2758             goto done;
2759           unformat_free (input);
2760
2761           str = "nsegs 10 seed 123 initial-offset 3917 drop no-randomize";
2762           unformat_init_cstring (input, str);
2763           if ((res = sfifo_test_fifo3 (vm, input)))
2764             goto done;
2765           unformat_free (input);
2766
2767           if ((res = sfifo_test_fifo4 (vm, input)))
2768             goto done;
2769
2770           if ((res = sfifo_test_fifo5 (vm, input)))
2771             goto done;
2772
2773           if ((res = sfifo_test_fifo6 (vm, input)))
2774             goto done;
2775
2776           if ((res = sfifo_test_fifo7 (vm, input)))
2777             goto done;
2778
2779           if ((res = sfifo_test_fifo_grow (vm, input)))
2780             goto done;
2781
2782           if ((res = sfifo_test_fifo_shrink (vm, input)))
2783             goto done;
2784
2785           str = "all";
2786           unformat_init_cstring (input, str);
2787           if ((res = sfifo_test_fifo_segment (vm, input)))
2788             goto done;
2789         }
2790       else
2791         {
2792           vlib_cli_output (vm, "unknown input `%U'", format_unformat_error,
2793                            input);
2794           res = -1;
2795           goto done;
2796         }
2797
2798     }
2799
2800 done:
2801   if (res)
2802     return clib_error_return (0, "svm fifo unit test failed");
2803   return 0;
2804 }
2805
2806 /* *INDENT-OFF* */
2807 VLIB_CLI_COMMAND (svm_fifo_test_command, static) =
2808 {
2809   .path = "test svm fifo",
2810   .short_help = "internal svm fifo unit tests",
2811   .function = svm_fifo_test,
2812 };
2813 /* *INDENT-ON* */
2814
2815 /*
2816  * fd.io coding-style-patch-verification: ON
2817  *
2818  * Local Variables:
2819  * eval: (c-set-style "gnu")
2820  * End:
2821  */