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