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   vec_reset_length (data_buf);
 710
 711   /*
 712    * Dequeue or drop all data
 713    */
 714   if (drop)
 715     {
 716       svm_fifo_dequeue_drop (f, vec_len (data_pattern));
 717     }
 718   else
 719     {
 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
1229   /*
1230    *  Add with fifo wrapped
1231    */
1232
1233   svm_fifo_init_pointers (f, f->nitems - 100, f->nitems + 100);
1234   c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + 100);
1235   c->length = 100;
1236   c->start_byte = ~0;
1237   c->next = 0;
1238
1239   svm_fifo_add_chunk (f, c);
1240
1241   SFIFO_TEST (f->end_chunk != c, "tail chunk should not be updated");
1242   SFIFO_TEST (f->size == fifo_size + 100, "size expected %u is %u",
1243               fifo_size + 100, f->size);
1244   SFIFO_TEST (c->start_byte == fifo_size + 100, "start byte expected %u is "
1245               " %u", fifo_size + 100, c->start_byte);
1246
1247   /*
1248    * Unwrap fifo
1249    */
1250   vec_validate (data_buf, 200);
1251   svm_fifo_dequeue (f, 201, data_buf);
1252
1253   SFIFO_TEST (f->end_chunk == c, "tail chunk should be updated");
1254   SFIFO_TEST (f->size == fifo_size + 200, "size expected %u is %u",
1255               fifo_size + 200, f->size);
1256   SFIFO_TEST (c->start_byte == fifo_size + 100, "start byte expected %u is "
1257               "%u", fifo_size + 100, c->start_byte);
1258
1259   /*
1260    * Add N chunks
1261    */
1262   svm_fifo_init_pointers (f, f->nitems - 100, f->nitems + 100);
1263
1264   prev = 0;
1265   for (i = 0; i < 5; i++)
1266     {
1267       c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + 100);
1268       c->length = 100;
1269       c->start_byte = ~0;
1270       c->next = prev;
1271       prev = c;
1272     }
1273
1274   svm_fifo_add_chunk (f, c);
1275   SFIFO_TEST (f->size == fifo_size + 200, "size expected %u is %u",
1276               fifo_size + 200, f->size);
1277
1278   prev = 0;
1279   for (i = 0; i < 5; i++)
1280     {
1281       c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + 100);
1282       c->length = 100;
1283       c->start_byte = ~0;
1284       c->next = prev;
1285       prev = c;
1286     }
1287
1288   svm_fifo_add_chunk (f, c);
1289   SFIFO_TEST (f->size == fifo_size + 200, "size expected %u is %u",
1290               fifo_size + 200, f->size);
1291
1292   old_tail = f->tail;
1293   svm_fifo_dequeue (f, 101, data_buf);
1294
1295   SFIFO_TEST (f->size == fifo_size + 200 + 10 * 100, "size expected %u is %u",
1296               fifo_size + 200 + 10 * 100, f->size);
1297   SFIFO_TEST (f->tail == old_tail, "new tail expected %u is %u", old_tail,
1298               f->tail);
1299
1300   /*
1301    * Enqueue/dequeue tests
1302    */
1303
1304   test_n_bytes = f->nitems;
1305   vec_validate (test_data, test_n_bytes - 1);
1306   vec_validate (data_buf, vec_len (test_data));
1307   n_deqs = n_enqs = 6;
1308   deq_bytes = enq_bytes = vec_len (test_data) / n_deqs;
1309
1310   for (i = 0; i < vec_len (test_data); i++)
1311     test_data[i] = i;
1312
1313   /*
1314    * Enqueue/deq boundary conditions
1315    */
1316   svm_fifo_init_pointers (f, 201, 201);
1317   SFIFO_TEST (f->tail_chunk->start_byte == 201, "start byte expected %u is "
1318               "%u", 201, f->tail_chunk->start_byte);
1319
1320   svm_fifo_enqueue (f, 200, test_data);
1321   SFIFO_TEST (f->tail_chunk->start_byte == 401, "start byte expected %u is "
1322               "%u", 401, f->tail_chunk->start_byte);
1323
1324   svm_fifo_dequeue (f, 200, data_buf);
1325   SFIFO_TEST (f->head_chunk->start_byte == 401, "start byte expected %u is "
1326               "%u", 401, f->head_chunk->start_byte);
1327
1328   /*
1329    * Simple enqueue/deq and data validation (1)
1330    */
1331   svm_fifo_init_pointers (f, f->nitems / 2, f->nitems / 2);
1332   for (i = 0; i < test_n_bytes; i++)
1333     {
1334       rv = svm_fifo_enqueue (f, sizeof (u8), &test_data[i]);
1335       if (rv < 0)
1336         {
1337           clib_warning ("enqueue returned %d", rv);
1338           goto cleanup;
1339         }
1340     }
1341
1342   SFIFO_TEST (svm_fifo_max_dequeue (f) == test_n_bytes, "max deq expected %u "
1343               "is %u", test_n_bytes, svm_fifo_max_dequeue (f));
1344
1345   for (i = 0; i < test_n_bytes; i++)
1346     svm_fifo_dequeue (f, 1, &data_buf[i]);
1347
1348   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1349                      (u32 *) & j);
1350   if (rv)
1351     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
1352                      test_data[j]);
1353   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
1354
1355   /*
1356    * Simple enqueue/deq and data validation (2)
1357    */
1358   for (i = 0; i <= n_enqs; i++)
1359     {
1360       rv = svm_fifo_enqueue (f, enq_bytes, test_data + i * enq_bytes);
1361       if (rv < 0)
1362         {
1363           clib_warning ("enqueue returned %d", rv);
1364           goto cleanup;
1365         }
1366     }
1367
1368   SFIFO_TEST (svm_fifo_max_dequeue (f) == test_n_bytes, "max deq expected %u "
1369               "is %u", test_n_bytes, svm_fifo_max_dequeue (f));
1370
1371   for (i = 0; i <= n_deqs; i++)
1372     svm_fifo_dequeue (f, deq_bytes, data_buf + i * deq_bytes);
1373
1374   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1375                      (u32 *) & j);
1376   if (rv)
1377     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
1378                      test_data[j]);
1379   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
1380
1381   /*
1382    * OOO enqueues/dequeues and data validation (1)
1383    */
1384   for (i = test_n_bytes - 1; i > 0; i--)
1385     {
1386       rv = svm_fifo_enqueue_with_offset (f, i, sizeof (u8), &test_data[i]);
1387       if (verbose)
1388         vlib_cli_output (vm, "add [%d] [%d, %d]", i, i, i + sizeof (u8));
1389       if (rv)
1390         {
1391           clib_warning ("enqueue returned %d", rv);
1392           goto cleanup;
1393         }
1394     }
1395
1396   SFIFO_TEST (svm_fifo_max_dequeue (f) == 0, "max deq expected %u is %u",
1397               0, svm_fifo_max_dequeue (f));
1398
1399   svm_fifo_enqueue (f, sizeof (u8), &test_data[0]);
1400
1401   memset (data_buf, 0, vec_len (data_buf));
1402   for (i = 0; i <= n_deqs; i++)
1403     svm_fifo_dequeue (f, deq_bytes, data_buf + i * deq_bytes);
1404
1405   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1406                      (u32 *) & j);
1407   if (rv)
1408     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
1409                      test_data[j]);
1410   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
1411
1412   /*
1413    * OOO enqueues/dequeues and data validation (2)
1414    */
1415
1416   for (i = n_enqs; i > 0; i--)
1417     {
1418       u32 enq_now = clib_min (enq_bytes, vec_len (test_data) - i * enq_bytes);
1419       rv = svm_fifo_enqueue_with_offset (f, i * enq_bytes, enq_now,
1420                                          test_data + i * enq_bytes);
1421       if (verbose)
1422         vlib_cli_output (vm, "add [%d, %d]", i * enq_bytes,
1423                          i * enq_bytes + enq_now);
1424       if (rv)
1425         {
1426           clib_warning ("enqueue returned %d", rv);
1427           goto cleanup;
1428         }
1429     }
1430
1431   svm_fifo_enqueue (f, enq_bytes, &test_data[0]);
1432
1433   memset (data_buf, 0, vec_len (data_buf));
1434   for (i = 0; i <= n_deqs; i++)
1435     svm_fifo_dequeue (f, deq_bytes, data_buf + i * deq_bytes);
1436
1437   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1438                      (u32 *) & j);
1439   if (rv)
1440     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
1441                      test_data[j]);
1442   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
1443
1444   /*
1445    * Cleanup
1446    */
1447
1448 cleanup:
1449
1450   c = f->start_chunk->next;
1451   while (c && c != f->start_chunk)
1452     {
1453       next = c->next;
1454       clib_mem_free (c);
1455       c = next;
1456     }
1457
1458   svm_fifo_free (f);
1459   vec_free (test_data);
1460   vec_free (data_buf);
1461   return 0;
1462 }
1463
1464 static int
1465 chunk_list_len (svm_fifo_chunk_t * c)
1466 {
1467   svm_fifo_chunk_t *it;
1468   int count = 0;
1469
1470   if (!c)
1471     return 0;
1472
1473   count = 1;
1474   it = c->next;
1475   while (it && it != c)
1476     {
1477       it = it->next;
1478       count++;
1479     }
1480   return count;
1481 }
1482
1483 static void
1484 chunk_list_free (svm_fifo_chunk_t * c, svm_fifo_chunk_t * stop)
1485 {
1486   svm_fifo_chunk_t *it, *next;
1487
1488   it = c;
1489   while (it && it != stop)
1490     {
1491       next = it->next;
1492       clib_mem_free (it);
1493       it = next;
1494     }
1495 }
1496
1497 static void
1498 chunk_list_splice (svm_fifo_chunk_t * a, svm_fifo_chunk_t * b)
1499 {
1500   svm_fifo_chunk_t *it;
1501
1502   it = a;
1503   while (it->next)
1504     it = it->next;
1505   it->next = b;
1506 }
1507
1508 static int
1509 sfifo_test_fifo_shrink (vlib_main_t * vm, unformat_input_t * input)
1510 {
1511   int __clib_unused verbose = 0, fifo_size = 101, chunk_size = 100;
1512   int i, rv, test_n_bytes, diff, deq_bytes;
1513   svm_fifo_chunk_t *c, *prev, *collected;
1514   u8 *test_data = 0, *data_buf = 0;
1515   svm_fifo_t *f;
1516
1517   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1518     {
1519       if (unformat (input, "verbose"))
1520         verbose = 1;
1521       else
1522         {
1523           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1524                            input);
1525           return -1;
1526         }
1527     }
1528
1529   /*
1530    * Init fifo with multiple chunks
1531    */
1532   f = fifo_prepare (fifo_size);
1533   svm_fifo_init_pointers (f, 0, 0);
1534
1535   prev = 0;
1536   for (i = 0; i < 11; i++)
1537     {
1538       c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + chunk_size);
1539       c->length = 100;
1540       c->start_byte = ~0;
1541       c->next = prev;
1542       prev = c;
1543     }
1544
1545   svm_fifo_add_chunk (f, c);
1546   SFIFO_TEST (f->size == 12 * chunk_size + 1, "size expected %u is %u",
1547               12 * chunk_size + 1, f->size);
1548
1549   /*
1550    * No fifo wrap and no chunk used (one chunk)
1551    */
1552   rv = svm_fifo_reduce_size (f, chunk_size, 0);
1553   SFIFO_TEST (rv == chunk_size, "len expected %u is %u", chunk_size, rv);
1554   SFIFO_TEST (f->size == 12 * chunk_size + 1, "size expected %u is %u",
1555               12 * chunk_size + 1, f->size);
1556   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1557
1558   /* Check enqueue space to force size reduction */
1559   (void) svm_fifo_max_enqueue (f);
1560
1561   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1562               11 * chunk_size + 1, f->size);
1563   SFIFO_TEST (f->flags & SVM_FIFO_F_COLLECT_CHUNKS, "collect flag should"
1564               " be set");
1565   SFIFO_TEST (!(f->flags & SVM_FIFO_F_SHRINK), "shrink flag should not be"
1566               " set");
1567
1568   collected = c = svm_fifo_collect_chunks (f);
1569   rv = chunk_list_len (c);
1570   SFIFO_TEST (rv == 1, "expected %u chunks got %u", 1, rv);
1571   rv = chunk_list_len (f->start_chunk);
1572   SFIFO_TEST (rv == 11, "expected %u chunks got %u", 11, rv);
1573   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1574               " not be set");
1575
1576   /*
1577    * Fifo wrap and multiple chunks used
1578    */
1579
1580   /* Init test data and fifo */
1581   test_n_bytes = f->nitems;
1582   vec_validate (test_data, test_n_bytes - 1);
1583   vec_validate (data_buf, vec_len (test_data));
1584
1585   for (i = 0; i < vec_len (test_data); i++)
1586     test_data[i] = i;
1587
1588   svm_fifo_init_pointers (f, f->size / 2, f->size / 2);
1589   for (i = 0; i < test_n_bytes; i++)
1590     {
1591       rv = svm_fifo_enqueue (f, sizeof (u8), &test_data[i]);
1592       if (rv < 0)
1593         SFIFO_TEST (0, "enqueue returned");
1594     }
1595
1596   /* Try to reduce fifo size with fifo full */
1597   rv = svm_fifo_reduce_size (f, 3.5 * chunk_size, 0);
1598   SFIFO_TEST (rv == 3 * chunk_size, "len expected %u is %u", 3 * chunk_size,
1599               rv);
1600   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1601               11 * chunk_size + 1, f->size);
1602   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1603
1604   /* Check enqueue space to try size reduction. Should not work */
1605   rv = svm_fifo_max_enqueue (f);
1606
1607   SFIFO_TEST (rv == 0, "free space expected %u is %u", 0, rv);
1608   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1609               11 * chunk_size + 1, f->size);
1610   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1611   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1612               " not be set");
1613
1614   /* Dequeue byte-by-byte up to last byte on last chunk */
1615   deq_bytes = f->size - f->size / 2 - 1;
1616   for (i = 0; i < deq_bytes; i++)
1617     {
1618       (void) svm_fifo_max_enqueue (f);
1619       rv = svm_fifo_dequeue (f, 1, &data_buf[i]);
1620       if (rv < 0)
1621         SFIFO_TEST (0, "dequeue returned");
1622     }
1623
1624   rv = svm_fifo_max_enqueue (f);
1625
1626   /* We've dequeued more than 3*chunk_size so nitems should be updated */
1627   SFIFO_TEST (f->nitems == 8 * chunk_size, "nitems expected %u is %u",
1628               8 * chunk_size, f->nitems);
1629   /* Free space should be what was dequeued - 3 * chunk_size, which was
1630    * consumed by shrinking the fifo */
1631   diff = deq_bytes - 3 * chunk_size;
1632   SFIFO_TEST (rv == diff, "free space expected %u is %u", diff, rv);
1633   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1634               11 * chunk_size + 1, f->size);
1635   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1636   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1637               " not be set");
1638
1639   /* Dequeue one more such that head goes beyond last chunk */
1640   rv = svm_fifo_dequeue (f, 1, &data_buf[deq_bytes]);
1641   if (rv < 0)
1642     SFIFO_TEST (0, "dequeue returned");
1643
1644   rv = svm_fifo_max_enqueue (f);
1645   SFIFO_TEST (f->nitems == 8 * chunk_size, "nitems expected %u is %u",
1646               8 * chunk_size, f->nitems);
1647   SFIFO_TEST (rv == diff + 1, "free space expected %u is %u", diff + 1, rv);
1648   SFIFO_TEST (f->size == 8 * chunk_size + 1, "size expected %u is %u",
1649               8 * chunk_size + 1, f->size);
1650   SFIFO_TEST (!(f->flags & SVM_FIFO_F_SHRINK), "shrink flag should not be"
1651               " set");
1652   SFIFO_TEST (f->flags & SVM_FIFO_F_COLLECT_CHUNKS, "collect flag should"
1653               " be set");
1654
1655   /* Dequeue the rest of the data */
1656   deq_bytes += 1;
1657   for (i = 0; i < test_n_bytes - deq_bytes; i++)
1658     {
1659       rv = svm_fifo_dequeue (f, 1, &data_buf[i + deq_bytes]);
1660       if (rv < 0)
1661         SFIFO_TEST (0, "dequeue returned");
1662     }
1663
1664   rv = svm_fifo_max_enqueue (f);
1665
1666   SFIFO_TEST (f->size == 8 * chunk_size + 1, "size expected %u is %u",
1667               8 * chunk_size + 1, f->size);
1668   SFIFO_TEST (rv == 8 * chunk_size, "free space expected %u is %u",
1669               8 * chunk_size, rv);
1670
1671   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1672                      (u32 *) & i);
1673   if (rv)
1674     SFIFO_TEST (0, "[%d] dequeued %u expected %u", i, data_buf[i],
1675                 test_data[i]);
1676
1677   c = svm_fifo_collect_chunks (f);
1678   rv = chunk_list_len (c);
1679   SFIFO_TEST (rv == 3, "expected %u chunks got %u", 3, rv);
1680   rv = chunk_list_len (f->start_chunk);
1681   SFIFO_TEST (rv == 8, "expected %u chunks got %u", 8, rv);
1682   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1683               " not be set");
1684
1685   /*
1686    * OOO segment on chunk that should be removed
1687    */
1688
1689   svm_fifo_add_chunk (f, c);
1690   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1691               11 * chunk_size + 1, f->size);
1692
1693   memset (data_buf, 0, vec_len (data_buf));
1694   svm_fifo_init_pointers (f, f->size / 2, f->size / 2);
1695   svm_fifo_enqueue (f, 200, test_data);
1696   svm_fifo_enqueue_with_offset (f, 50, vec_len (test_data) - 250,
1697                                 &test_data[250]);
1698
1699   /* Free space */
1700   rv = svm_fifo_max_enqueue (f);
1701   SFIFO_TEST (rv == vec_len (test_data) - 200, "free space expected %u is %u",
1702               vec_len (test_data) - 200, rv);
1703
1704   /* Ask to reduce size */
1705   rv = svm_fifo_reduce_size (f, 3.5 * chunk_size, 0);
1706   SFIFO_TEST (rv == 3 * chunk_size, "len expected %u is %u", 3 * chunk_size,
1707               rv);
1708   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1709               11 * chunk_size + 1, f->size);
1710   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1711
1712   /* Try to force size reduction but it should fail */
1713   rv = svm_fifo_max_enqueue (f);
1714
1715   SFIFO_TEST (rv == vec_len (test_data) - 200, "free space expected %u is %u",
1716               vec_len (test_data) - 200, rv);
1717   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1718               11 * chunk_size + 1, f->size);
1719   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1720   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1721               " not be set");
1722
1723   /* Dequeue the in order data. This should shrink nitems */
1724   rv = svm_fifo_dequeue (f, 200, data_buf);
1725   if (rv < 0)
1726     SFIFO_TEST (0, "dequeue returned");
1727
1728   rv = svm_fifo_max_enqueue (f);
1729   SFIFO_TEST (rv == vec_len (test_data) - 200, "free space expected %u is %u",
1730               vec_len (test_data) - 200, rv);
1731   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1732               11 * chunk_size + 1, f->size);
1733   SFIFO_TEST (f->nitems == 11 * chunk_size - 200, "nitems expected %u is %u",
1734               11 * chunk_size - 200, f->nitems);
1735   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1736   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1737               " not be set");
1738
1739   /* Enqueue the missing 50 bytes. Fifo will become full */
1740   rv = svm_fifo_enqueue (f, 50, &test_data[200]);
1741   SFIFO_TEST (rv == vec_len (test_data) - 200, "free space expected %u is %u",
1742               vec_len (test_data) - 200, rv);
1743
1744   rv = svm_fifo_max_enqueue (f);
1745
1746   SFIFO_TEST (rv == 0, "free space expected %u is %u", 0, rv);
1747   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1748               11 * chunk_size + 1, f->size);
1749   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1750   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1751               " not be set");
1752
1753
1754   /* Dequeue a chunk and check nitems shrink but fifo still full */
1755   svm_fifo_dequeue (f, 100, &data_buf[200]);
1756
1757   rv = svm_fifo_max_enqueue (f);
1758
1759   SFIFO_TEST (rv == 0, "free space expected %u is %u", 0, rv);
1760   SFIFO_TEST (f->size == 11 * chunk_size + 1, "size expected %u is %u",
1761               11 * chunk_size + 1, f->size);
1762   SFIFO_TEST (f->nitems == 11 * chunk_size - 300, "nitems expected %u is %u",
1763               11 * chunk_size - 300, f->nitems);
1764   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1765   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1766               " not be set");
1767
1768   /* Dequeue enough to unwrap the fifo */
1769   deq_bytes = f->size - f->size / 2 - 300;
1770   svm_fifo_dequeue (f, deq_bytes, &data_buf[300]);
1771   rv = svm_fifo_max_enqueue (f);
1772
1773   /* Overall we've dequeued deq_bytes + 300, but fifo size shrunk 300 */
1774   SFIFO_TEST (rv == 300 + deq_bytes - 300, "free space expected %u is %u",
1775               300 + deq_bytes - 300, rv);
1776   SFIFO_TEST (f->size == 8 * chunk_size + 1, "size expected %u is %u",
1777               8 * chunk_size + 1, f->size);
1778   SFIFO_TEST (f->nitems == 8 * chunk_size, "nitems expected %u is %u",
1779               8 * chunk_size, f->nitems);
1780   SFIFO_TEST (!(f->flags & SVM_FIFO_F_SHRINK), "shrink flag should not be"
1781               " set");
1782   SFIFO_TEST (f->flags & SVM_FIFO_F_COLLECT_CHUNKS, "collect flag should"
1783               " be set");
1784
1785   /* Dequeue the rest */
1786   svm_fifo_dequeue (f, test_n_bytes / 2, &data_buf[300 + deq_bytes]);
1787   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1788                      (u32 *) & i);
1789   if (rv)
1790     SFIFO_TEST (0, "[%d] dequeued %u expected %u", i, data_buf[i],
1791                 test_data[i]);
1792
1793   c = svm_fifo_collect_chunks (f);
1794   rv = chunk_list_len (c);
1795   SFIFO_TEST (rv == 3, "expected %u chunks got %u", 3, rv);
1796   rv = chunk_list_len (f->start_chunk);
1797   SFIFO_TEST (rv == 8, "expected %u chunks got %u", 8, rv);
1798   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1799               " not be set");
1800
1801   chunk_list_splice (collected, c);
1802
1803   /*
1804    * Remove all chunks possible
1805    */
1806   svm_fifo_init_pointers (f, 601, 601);
1807   rv = svm_fifo_reduce_size (f, 8 * chunk_size, 1);
1808   SFIFO_TEST (rv == 7 * chunk_size, "actual len expected %u is %u",
1809               7 * chunk_size, rv);
1810   SFIFO_TEST (f->size == 6 * chunk_size + 1, "size expected %u is %u",
1811               6 * chunk_size + 1, f->size);
1812   SFIFO_TEST (f->nitems == 1 * chunk_size, "nitems expected %u is %u",
1813               1 * chunk_size, f->nitems);
1814   SFIFO_TEST (f->flags & SVM_FIFO_F_SHRINK, "shrink flag should be set");
1815   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1816               " not be set");
1817
1818   rv = svm_fifo_max_enqueue (f);
1819   SFIFO_TEST (rv == chunk_size, "free space expected %u is %u", chunk_size,
1820               rv);
1821
1822   /* Force head/tail to move to first chunk */
1823   svm_fifo_enqueue (f, 1, test_data);
1824   svm_fifo_dequeue (f, 1, data_buf);
1825   rv = svm_fifo_max_enqueue (f);
1826
1827   SFIFO_TEST (rv == chunk_size, "free space expected %u is %u", chunk_size,
1828               rv);
1829   SFIFO_TEST (f->size == chunk_size + 1, "size expected %u is %u",
1830               chunk_size + 1, f->size);
1831   SFIFO_TEST (!(f->flags & SVM_FIFO_F_SHRINK), "shrink flag should not be"
1832               " set");
1833   SFIFO_TEST (f->flags & SVM_FIFO_F_COLLECT_CHUNKS, "collect flag should"
1834               " be set");
1835
1836   c = svm_fifo_collect_chunks (f);
1837   rv = chunk_list_len (c);
1838   SFIFO_TEST (rv == 7, "expected %u chunks got %u", 7, rv);
1839   SFIFO_TEST (!(f->flags & SVM_FIFO_F_COLLECT_CHUNKS), "collect flag should"
1840               " not be set");
1841   SFIFO_TEST (!(f->flags & SVM_FIFO_F_MULTI_CHUNK), "multi-chunk flag should"
1842               " not be set");
1843
1844   chunk_list_splice (collected, c);
1845
1846   /*
1847    * Cleanup
1848    */
1849
1850   chunk_list_free (f->start_chunk->next, f->start_chunk);
1851   chunk_list_free (collected, 0);
1852   svm_fifo_free (f);
1853   vec_free (test_data);
1854   vec_free (data_buf);
1855
1856   return 0;
1857 }
1858
1859 /* *INDENT-OFF* */
1860 svm_fifo_trace_elem_t fifo_trace[] = {};
1861 /* *INDENT-ON* */
1862
1863 static int
1864 sfifo_test_fifo_replay (vlib_main_t * vm, unformat_input_t * input)
1865 {
1866   svm_fifo_t f;
1867   int verbose = 0;
1868   u8 no_read = 0, *str = 0;
1869
1870   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1871     {
1872       if (unformat (input, "verbose"))
1873         verbose = 1;
1874       else if (unformat (input, "no-read"))
1875         no_read = 1;
1876       else
1877         {
1878           clib_error_t *e = clib_error_return
1879             (0, "unknown input `%U'", format_unformat_error, input);
1880           clib_error_report (e);
1881           return -1;
1882         }
1883     }
1884
1885 #if SVMF_FIFO_TRACE
1886   f.trace = fifo_trace;
1887 #endif
1888
1889   str = svm_fifo_replay (str, &f, no_read, verbose);
1890   vlib_cli_output (vm, "%v", str);
1891   return 0;
1892 }
1893
1894 static fifo_segment_main_t segment_main;
1895
1896 static int
1897 sfifo_test_fifo_segment_hello_world (int verbose)
1898 {
1899   fifo_segment_create_args_t _a, *a = &_a;
1900   fifo_segment_main_t *sm = &segment_main;
1901   u8 *test_data, *retrieved_data = 0;
1902   fifo_segment_t *fs;
1903   svm_fifo_t *f;
1904   int rv;
1905
1906   clib_memset (a, 0, sizeof (*a));
1907   a->segment_name = "fifo-test1";
1908   a->segment_size = 256 << 10;
1909
1910   rv = fifo_segment_create (sm, a);
1911
1912   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
1913
1914   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
1915   f = fifo_segment_alloc_fifo (fs, 4096, FIFO_SEGMENT_RX_FIFO);
1916
1917   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo");
1918
1919   test_data = format (0, "Hello world%c", 0);
1920   vec_validate (retrieved_data, vec_len (test_data) - 1);
1921
1922   while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
1923     svm_fifo_enqueue (f, vec_len (test_data), test_data);
1924
1925   while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
1926     svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
1927
1928   while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
1929     svm_fifo_enqueue (f, vec_len (test_data), test_data);
1930
1931   while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
1932     svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
1933
1934   SFIFO_TEST (!memcmp (retrieved_data, test_data, vec_len (test_data)),
1935               "data should be identical");
1936
1937   vec_free (test_data);
1938   vec_free (retrieved_data);
1939   vec_free (a->new_segment_indices);
1940   fifo_segment_free_fifo (fs, f);
1941   fifo_segment_delete (sm, fs);
1942   return 0;
1943 }
1944
1945 static int
1946 sfifo_test_fifo_segment_fifo_grow (int verbose)
1947 {
1948   fifo_segment_main_t *sm = &segment_main;
1949   fifo_segment_create_args_t _a, *a = &_a;
1950   int rv, fifo_size = 4096, n_chunks;
1951   fifo_segment_t *fs;
1952   svm_fifo_t *f;
1953
1954   clib_memset (a, 0, sizeof (*a));
1955   a->segment_name = "fifo-test1";
1956   a->segment_size = 256 << 10;
1957
1958   rv = fifo_segment_create (sm, a);
1959
1960   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
1961
1962   /*
1963    * Alloc and grow fifo
1964    */
1965   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
1966   f = fifo_segment_alloc_fifo (fs, fifo_size, FIFO_SEGMENT_RX_FIFO);
1967
1968   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo");
1969
1970   fifo_segment_grow_fifo (fs, f, fifo_size);
1971   SFIFO_TEST (f->size == 2 * fifo_size, "fifo size should be %u is %u",
1972               2 * fifo_size, f->size);
1973
1974   fifo_segment_grow_fifo (fs, f, 16 * fifo_size);
1975   SFIFO_TEST (f->size == 18 * fifo_size, "fifo size should be %u is %u",
1976               18 * fifo_size, f->size);
1977
1978   /*
1979    * Free and test free list size
1980    */
1981   fifo_segment_free_fifo (fs, f);
1982
1983   n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
1984   SFIFO_TEST (n_chunks == 1, "free 2^10B chunks should be %u is %u", 1,
1985               n_chunks);
1986   n_chunks = fifo_segment_num_free_chunks (fs, 16 * fifo_size);
1987   SFIFO_TEST (n_chunks == 1, "free 2^14B chunks should be %u is %u", 1,
1988               n_chunks);
1989   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
1990   SFIFO_TEST (n_chunks == 2, "free chunks should be %u is %u", 2, n_chunks);
1991
1992   /*
1993    * Realloc fifo
1994    */
1995   f = fifo_segment_alloc_fifo (fs, fifo_size, FIFO_SEGMENT_RX_FIFO);
1996
1997   fifo_segment_grow_fifo (fs, f, fifo_size);
1998   n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
1999   SFIFO_TEST (n_chunks == 0, "free 2^10B chunks should be %u is %u", 0,
2000               n_chunks);
2001
2002   fifo_segment_grow_fifo (fs, f, 16 * fifo_size);
2003   SFIFO_TEST (n_chunks == 0, "free 2^14B chunks should be %u is %u", 0,
2004               n_chunks);
2005   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
2006   SFIFO_TEST (n_chunks == 0, "free chunks should be %u is %u", 0, n_chunks);
2007
2008   /*
2009    * Free again
2010    */
2011   fifo_segment_free_fifo (fs, f);
2012   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
2013   SFIFO_TEST (n_chunks == 2, "free chunks should be %u is %u", 2, n_chunks);
2014
2015   /*
2016    * Cleanup
2017    */
2018   fifo_segment_delete (sm, fs);
2019   vec_free (a->new_segment_indices);
2020   return 0;
2021 }
2022
2023 static int
2024 sfifo_test_fifo_segment_fifo_shrink (int verbose)
2025 {
2026   fifo_segment_main_t *sm = &segment_main;
2027   fifo_segment_create_args_t _a, *a = &_a;
2028   int i, rv, chunk_size = 4096, n_chunks;
2029   fifo_segment_t *fs;
2030   svm_fifo_t *f;
2031
2032   clib_memset (a, 0, sizeof (*a));
2033   a->segment_name = "fifo-test1";
2034   a->segment_size = 256 << 10;
2035
2036   rv = fifo_segment_create (sm, a);
2037
2038   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2039
2040   /*
2041    * Alloc and grow fifo
2042    */
2043   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2044   f = fifo_segment_alloc_fifo (fs, chunk_size, FIFO_SEGMENT_RX_FIFO);
2045
2046   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo");
2047
2048   for (i = 0; i < 9; i++)
2049     {
2050       fifo_segment_grow_fifo (fs, f, chunk_size);
2051       if (f->size != (i + 2) * chunk_size)
2052         SFIFO_TEST (0, "fifo size should be %u is %u",
2053                     (i + 2) * chunk_size, f->size);
2054     }
2055
2056   rv = svm_fifo_reduce_size (f, 3.5 * chunk_size, 1 /* is producer */ );
2057   SFIFO_TEST (rv == 3 * chunk_size, "len expected %u is %u", 3 * chunk_size,
2058               rv);
2059
2060   n_chunks = fifo_segment_num_free_chunks (fs, chunk_size);
2061   SFIFO_TEST (n_chunks == 0, "free chunks should be %u is %u", 0, n_chunks);
2062
2063   fifo_segment_collect_fifo_chunks (fs, f);
2064
2065   n_chunks = fifo_segment_num_free_chunks (fs, chunk_size);
2066   SFIFO_TEST (n_chunks == 3, "free chunks should be %u is %u", 3, n_chunks);
2067
2068   rv = svm_fifo_reduce_size (f, 7 * chunk_size - 1, 1 /* is producer */ );
2069   SFIFO_TEST (rv == 6 * chunk_size, "len expected %u is %u", 6 * chunk_size,
2070               rv);
2071
2072   fifo_segment_collect_fifo_chunks (fs, f);
2073
2074   n_chunks = fifo_segment_num_free_chunks (fs, chunk_size);
2075   SFIFO_TEST (n_chunks == 9, "free chunks should be %u is %u", 9, n_chunks);
2076   /*
2077    * Free
2078    */
2079   fifo_segment_free_fifo (fs, f);
2080   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
2081   SFIFO_TEST (n_chunks == 9, "free chunks should be %u is %u", 9, n_chunks);
2082
2083   /*
2084    * Cleanup
2085    */
2086   fifo_segment_delete (sm, fs);
2087   vec_free (a->new_segment_indices);
2088   return 0;
2089 }
2090
2091 static int
2092 sfifo_test_fifo_segment_slave (int verbose)
2093 {
2094   fifo_segment_create_args_t _a, *a = &_a;
2095   fifo_segment_main_t *sm = &segment_main;
2096   u8 *test_data, *retrieved_data = 0;
2097   fifo_segment_t *sp;
2098   fifo_segment_header_t *fsh;
2099   ssvm_shared_header_t *sh;
2100   svm_fifo_t *f;
2101   u32 *result;
2102   int rv, i;
2103
2104   sleep (2);
2105
2106   sm->timeout_in_seconds = 5;
2107   clib_memset (a, 0, sizeof (*a));
2108   a->segment_name = "fifo-test1";
2109
2110   rv = fifo_segment_attach (sm, a);
2111
2112   SFIFO_TEST (!rv, "svm_fifo_segment_attach returned %d", rv);
2113
2114   sp = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2115   vec_free (a->new_segment_indices);
2116   sh = sp->ssvm.sh;
2117   fsh = (fifo_segment_header_t *) sh->opaque[0];
2118
2119   /* might wanna wait.. */
2120   f = fsh->fifos;
2121
2122   /* Lazy bastards united */
2123   test_data = format (0, "Hello world%c", 0);
2124   vec_validate (retrieved_data, vec_len (test_data) - 1);
2125
2126   for (i = 0; i < 1000; i++)
2127     {
2128       svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
2129       if (memcmp (retrieved_data, test_data, vec_len (retrieved_data)))
2130         {
2131           result = (u32 *) f->head_chunk->data;
2132           *result = 1;
2133           _exit (0);
2134         }
2135     }
2136
2137   result = (u32 *) f->head_chunk->data;
2138   *result = 0;
2139
2140   vec_free (test_data);
2141   vec_free (retrieved_data);
2142   _exit (0);
2143 }
2144
2145 static int
2146 sfifo_test_fifo_segment_master_slave (int verbose)
2147 {
2148   fifo_segment_create_args_t _a, *a = &_a;
2149   fifo_segment_main_t *sm = &segment_main;
2150   fifo_segment_t *sp;
2151   svm_fifo_t *f;
2152   u8 *test_data;
2153   u32 *result;
2154   int rv, i;
2155   pid_t pid;
2156
2157   pid = fork ();
2158   if (pid < 0)
2159     SFIFO_TEST (0, "fork failed");
2160
2161   if (!pid)
2162     sfifo_test_fifo_segment_slave (verbose);
2163
2164   clib_memset (a, 0, sizeof (*a));
2165   a->segment_name = "fifo-test1";
2166   a->segment_size = 256 << 10;
2167
2168   rv = fifo_segment_create (sm, a);
2169
2170   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2171
2172   sp = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2173   f = fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FIFO);
2174
2175   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo alloc");
2176
2177   test_data = format (0, "Hello world%c", 0);
2178
2179   usleep (200e3);
2180
2181   for (i = 0; i < 1000; i++)
2182     svm_fifo_enqueue (f, vec_len (test_data), test_data);
2183
2184   /* Wait for slave */
2185   i = 0;
2186   while (svm_fifo_max_dequeue (f) && i++ < 1e10)
2187     ;
2188
2189   usleep (1e3);
2190
2191   result = (u32 *) f->head_chunk->data;
2192   SFIFO_TEST (*result == 0, "slave reported no error");
2193
2194   vec_free (a->new_segment_indices);
2195   vec_free (test_data);
2196   fifo_segment_free_fifo (sp, f);
2197   fifo_segment_delete (sm, sp);
2198   return 0;
2199 }
2200
2201 static int
2202 sfifo_test_fifo_segment_mempig (int verbose)
2203 {
2204   fifo_segment_create_args_t _a, *a = &_a;
2205   fifo_segment_main_t *sm = &segment_main;
2206   fifo_segment_t *sp;
2207   svm_fifo_t *f;
2208   svm_fifo_t **flist = 0;
2209   int rv;
2210   int i;
2211
2212   clib_memset (a, 0, sizeof (*a));
2213
2214   a->segment_name = "fifo-test1";
2215   a->segment_size = 256 << 10;
2216
2217   rv = fifo_segment_create (sm, a);
2218
2219   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
2220
2221   sp = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
2222
2223   for (i = 0; i < 1000; i++)
2224     {
2225       f = fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FIFO);
2226       if (f == 0)
2227         break;
2228       vec_add1 (flist, f);
2229     }
2230
2231   SFIFO_TEST (vec_len (flist), "created %d fifos", vec_len (flist));
2232
2233   for (i = 0; i < vec_len (flist); i++)
2234     {
2235       f = flist[i];
2236       fifo_segment_free_fifo (sp, f);
2237     }
2238
2239   _vec_len (flist) = 0;
2240
2241   for (i = 0; i < 1000; i++)
2242     {
2243       f = fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FIFO);
2244       if (f == 0)
2245         break;
2246       vec_add1 (flist, f);
2247     }
2248
2249   SFIFO_TEST (vec_len (flist), "second try created %d fifos",
2250               vec_len (flist));
2251   for (i = 0; i < vec_len (flist); i++)
2252     {
2253       f = flist[i];
2254       fifo_segment_free_fifo (sp, f);
2255     }
2256
2257   fifo_segment_delete (sm, sp);
2258   return 0;
2259 }
2260
2261 static int
2262 sfifo_test_fifo_segment (vlib_main_t * vm, unformat_input_t * input)
2263 {
2264   int rv, verbose = 0;
2265
2266   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2267     {
2268       if (unformat (input, "verbose"))
2269         verbose = 1;
2270       else if (unformat (input, "masterslave"))
2271         {
2272           if ((rv = sfifo_test_fifo_segment_master_slave (verbose)))
2273             return -1;
2274         }
2275       else if (unformat (input, "basic"))
2276         {
2277           if ((rv = sfifo_test_fifo_segment_hello_world (verbose)))
2278             return -1;
2279         }
2280       else if (unformat (input, "mempig"))
2281         {
2282           if ((rv = sfifo_test_fifo_segment_mempig (verbose)))
2283             return -1;
2284         }
2285       else if (unformat (input, "grow fifo"))
2286         {
2287           if ((rv = sfifo_test_fifo_segment_fifo_grow (verbose)))
2288             return -1;
2289         }
2290       else if (unformat (input, "shrink fifo"))
2291         {
2292           if ((rv = sfifo_test_fifo_segment_fifo_shrink (verbose)))
2293             return -1;
2294         }
2295       else if (unformat (input, "all"))
2296         {
2297           if ((rv = sfifo_test_fifo_segment_hello_world (verbose)))
2298             return -1;
2299           if ((rv = sfifo_test_fifo_segment_mempig (verbose)))
2300             return -1;
2301           if ((rv = sfifo_test_fifo_segment_fifo_grow (verbose)))
2302             return -1;
2303           if ((rv = sfifo_test_fifo_segment_fifo_shrink (verbose)))
2304             return -1;
2305           /* Pretty slow so avoid running it always
2306              if ((rv = sfifo_test_fifo_segment_master_slave (verbose)))
2307              return -1;
2308            */
2309         }
2310       else
2311         {
2312           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
2313                            input);
2314           return -1;
2315         }
2316     }
2317   return 0;
2318 }
2319
2320 static clib_error_t *
2321 svm_fifo_test (vlib_main_t * vm, unformat_input_t * input,
2322                vlib_cli_command_t * cmd_arg)
2323 {
2324   int res = 0;
2325   char *str;
2326
2327   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2328     {
2329       if (unformat (input, "fifo1"))
2330         res = sfifo_test_fifo1 (vm, input);
2331       else if (unformat (input, "fifo2"))
2332         res = sfifo_test_fifo2 (vm);
2333       else if (unformat (input, "fifo3"))
2334         res = sfifo_test_fifo3 (vm, input);
2335       else if (unformat (input, "fifo4"))
2336         res = sfifo_test_fifo4 (vm, input);
2337       else if (unformat (input, "fifo5"))
2338         res = sfifo_test_fifo5 (vm, input);
2339       else if (unformat (input, "fifo6"))
2340         res = sfifo_test_fifo6 (vm, input);
2341       else if (unformat (input, "fifo7"))
2342         res = sfifo_test_fifo7 (vm, input);
2343       else if (unformat (input, "large"))
2344         res = sfifo_test_fifo_large (vm, input);
2345       else if (unformat (input, "replay"))
2346         res = sfifo_test_fifo_replay (vm, input);
2347       else if (unformat (input, "grow"))
2348         res = sfifo_test_fifo_grow (vm, input);
2349       else if (unformat (input, "shrink"))
2350         res = sfifo_test_fifo_shrink (vm, input);
2351       else if (unformat (input, "segment"))
2352         res = sfifo_test_fifo_segment (vm, input);
2353       else if (unformat (input, "all"))
2354         {
2355           if ((res = sfifo_test_fifo1 (vm, input)))
2356             goto done;
2357
2358           if ((res = sfifo_test_fifo2 (vm)))
2359             goto done;
2360
2361           /*
2362            * Run a number of fifo3 configs
2363            */
2364           str = "nsegs 10 overlap seed 123";
2365           unformat_init_cstring (input, str);
2366           if ((res = sfifo_test_fifo3 (vm, input)))
2367             goto done;
2368           unformat_free (input);
2369
2370           str = "nsegs 10 overlap seed 123 in-seq-all";
2371           unformat_init_cstring (input, str);
2372           if ((res = sfifo_test_fifo3 (vm, input)))
2373             goto done;
2374           unformat_free (input);
2375
2376           str = "nsegs 10 overlap seed 123 initial-offset 3917";
2377           unformat_init_cstring (input, str);
2378           if ((res = sfifo_test_fifo3 (vm, input)))
2379             goto done;
2380           unformat_free (input);
2381
2382           str = "nsegs 10 overlap seed 123 initial-offset 3917 drop";
2383           unformat_init_cstring (input, str);
2384           if ((res = sfifo_test_fifo3 (vm, input)))
2385             goto done;
2386           unformat_free (input);
2387
2388           str = "nsegs 10 seed 123 initial-offset 3917 drop no-randomize";
2389           unformat_init_cstring (input, str);
2390           if ((res = sfifo_test_fifo3 (vm, input)))
2391             goto done;
2392           unformat_free (input);
2393
2394           if ((res = sfifo_test_fifo4 (vm, input)))
2395             goto done;
2396
2397           if ((res = sfifo_test_fifo5 (vm, input)))
2398             goto done;
2399
2400           if ((res = sfifo_test_fifo6 (vm, input)))
2401             goto done;
2402
2403           if ((res = sfifo_test_fifo7 (vm, input)))
2404             goto done;
2405
2406           if ((res = sfifo_test_fifo_grow (vm, input)))
2407             goto done;
2408
2409           if ((res = sfifo_test_fifo_shrink (vm, input)))
2410             goto done;
2411
2412           str = "all";
2413           unformat_init_cstring (input, str);
2414           if ((res = sfifo_test_fifo_segment (vm, input)))
2415             goto done;
2416         }
2417       else
2418         {
2419           vlib_cli_output (vm, "unknown input `%U'", format_unformat_error,
2420                            input);
2421           res = -1;
2422           goto done;
2423         }
2424
2425     }
2426
2427 done:
2428   if (res)
2429     return clib_error_return (0, "svm fifo unit test failed");
2430   return 0;
2431 }
2432
2433 /* *INDENT-OFF* */
2434 VLIB_CLI_COMMAND (svm_fifo_test_command, static) =
2435 {
2436   .path = "test svm fifo",
2437   .short_help = "internal svm fifo unit tests",
2438   .function = svm_fifo_test,
2439 };
2440 /* *INDENT-ON* */
2441
2442 /*
2443  * fd.io coding-style-patch-verification: ON
2444  *
2445  * Local Variables:
2446  * eval: (c-set-style "gnu")
2447  * End:
2448  */