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