src/plugins/unittest/svm_fifo_test.c

   1 /*
   2  * Copyright (c) 2019 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 #include <svm/svm_fifo.h>
  16 #include <vlib/vlib.h>
  17 #include <svm/fifo_segment.h>
  18
  19 #define SFIFO_TEST_I(_cond, _comment, _args...)                 \
  20 ({                                                              \
  21   int _evald = (_cond);                                         \
  22   if (!(_evald)) {                                              \
  23     fformat(stderr, "FAIL:%d: " _comment "\n",                  \
  24             __LINE__, ##_args);                                 \
  25   } else {                                                      \
  26     fformat(stderr, "PASS:%d: " _comment "\n",                  \
  27             __LINE__, ##_args);                                 \
  28   }                                                             \
  29   _evald;                                                       \
  30 })
  31
  32 #define SFIFO_TEST(_cond, _comment, _args...)                   \
  33 {                                                               \
  34     if (!SFIFO_TEST_I(_cond, _comment, ##_args)) {              \
  35         return 1;                                               \
  36     }                                                           \
  37 }
  38
  39 typedef struct
  40 {
  41   u32 offset;
  42   u32 len;
  43 } test_pattern_t;
  44
  45 /* *INDENT-OFF* */
  46 test_pattern_t test_pattern[] = {
  47   {380, 8}, {768, 8}, {1156, 8}, {1544, 8}, {1932, 8}, {2320, 8}, {2708, 8},
  48   {2992, 8}, {372, 8}, {760, 8}, {1148, 8}, {1536, 8}, {1924, 8}, {2312, 8},
  49   {2700, 8}, {2984, 8}, {364, 8}, {752, 8}, {1140, 8}, {1528, 8}, {1916, 8},
  50   {2304, 8}, {2692, 8}, {2976, 8}, {356, 8}, {744, 8}, {1132, 8}, {1520, 8},
  51   {1908, 8}, {2296, 8}, {2684, 8}, {2968, 8}, {348, 8}, {736, 8}, {1124, 8},
  52   {1512, 8}, {1900, 8}, {2288, 8}, {2676, 8}, {2960, 8}, {340, 8}, {728, 8},
  53   {1116, 8}, {1504, 8}, {1892, 8}, {2280, 8}, {2668, 8}, {2952, 8}, {332, 8},
  54   {720, 8}, {1108, 8}, {1496, 8}, {1884, 8}, {2272, 8}, {2660, 8}, {2944, 8},
  55   {324, 8}, {712, 8}, {1100, 8}, {1488, 8}, {1876, 8}, {2264, 8}, {2652, 8},
  56   {2936, 8}, {316, 8}, {704, 8}, {1092, 8}, {1480, 8}, {1868, 8}, {2256, 8},
  57   {2644, 8}, {2928, 8}, {308, 8}, {696, 8}, {1084, 8}, {1472, 8}, {1860, 8},
  58   {2248, 8}, {2636, 8}, {2920, 8}, {300, 8}, {688, 8}, {1076, 8}, {1464, 8},
  59   {1852, 8}, {2240, 8}, {2628, 8}, {2912, 8}, {292, 8}, {680, 8}, {1068, 8},
  60   {1456, 8}, {1844, 8}, {2232, 8}, {2620, 8}, {2904, 8}, {284, 8}, {672, 8},
  61   {1060, 8}, {1448, 8}, {1836, 8}, {2224, 8}, {2612, 8}, {2896, 8}, {276, 8},
  62   {664, 8}, {1052, 8}, {1440, 8}, {1828, 8},  {2216, 8}, {2604, 8}, {2888, 8},
  63   {268, 8}, {656, 8}, {1044, 8}, {1432, 8}, {1820, 8}, {2208, 8}, {2596, 8},
  64   {2880, 8}, {260, 8}, {648, 8}, {1036, 8}, {1424, 8}, {1812, 8}, {2200, 8},
  65   {2588, 8}, {2872, 8}, {252, 8}, {640, 8}, {1028, 8}, {1416, 8}, {1804, 8},
  66   {2192, 8}, {2580, 8}, {2864, 8}, {244, 8}, {632, 8}, {1020, 8}, {1408, 8},
  67   {1796, 8}, {2184, 8}, {2572, 8}, {2856, 8}, {236, 8}, {624, 8}, {1012, 8},
  68   {1400, 8}, {1788, 8}, {2176, 8}, {2564, 8}, {2848, 8}, {228, 8}, {616, 8},
  69   {1004, 8}, {1392, 8}, {1780, 8}, {2168, 8}, {2556, 8}, {2840, 8}, {220, 8},
  70   {608, 8}, {996, 8}, {1384, 8}, {1772, 8}, {2160, 8}, {2548, 8}, {2832, 8},
  71   {212, 8}, {600, 8}, {988, 8}, {1376, 8}, {1764, 8}, {2152, 8}, {2540, 8},
  72   {2824, 8}, {204, 8}, {592, 8}, {980, 8}, {1368, 8}, {1756, 8}, {2144, 8},
  73   {2532, 8}, {2816, 8}, {196, 8}, {584, 8}, {972, 8}, {1360, 8}, {1748, 8},
  74   {2136, 8}, {2524, 8}, {2808, 8}, {188, 8}, {576, 8}, {964, 8}, {1352, 8},
  75   {1740, 8}, {2128, 8}, {2516, 8}, {2800, 8}, {180, 8}, {568, 8}, {956, 8},
  76   {1344, 8}, {1732, 8}, {2120, 8}, {2508, 8}, {2792, 8}, {172, 8}, {560, 8},
  77   {948, 8}, {1336, 8}, {1724, 8}, {2112, 8}, {2500, 8}, {2784, 8}, {164, 8},
  78   {552, 8}, {940, 8}, {1328, 8}, {1716, 8}, {2104, 8}, {2492, 8}, {2776, 8},
  79   {156, 8}, {544, 8}, {932, 8}, {1320, 8}, {1708, 8}, {2096, 8}, {2484, 8},
  80   {2768, 8}, {148, 8}, {536, 8}, {924, 8}, {1312, 8}, {1700, 8}, {2088, 8},
  81   {2476, 8}, {2760, 8}, {140, 8}, {528, 8}, {916, 8}, {1304, 8}, {1692, 8},
  82   {2080, 8}, {2468, 8}, {2752, 8}, {132, 8}, {520, 8}, {908, 8}, {1296, 8},
  83   {1684, 8}, {2072, 8}, {2460, 8}, {2744, 8}, {124, 8}, {512, 8}, {900, 8},
  84   {1288, 8}, {1676, 8}, {2064, 8}, {2452, 8}, {2736, 8}, {116, 8}, {504, 8},
  85   {892, 8}, {1280, 8}, {1668, 8}, {2056, 8}, {2444, 8}, {2728, 8}, {108, 8},
  86   {496, 8}, {884, 8}, {1272, 8}, {1660, 8}, {2048, 8}, {2436, 8}, {2720, 8},
  87   {100, 8}, {488, 8}, {876, 8}, {1264, 8}, {1652, 8}, {2040, 8}, {2428, 8},
  88   {2716, 4}, {92, 8}, {480, 8}, {868, 8}, {1256, 8}, {1644, 8}, {2032, 8},
  89   {2420, 8}, {84, 8}, {472, 8}, {860, 8}, {1248, 8}, {1636, 8}, {2024, 8},
  90   {2412, 8}, {76, 8}, {464, 8}, {852, 8}, {1240, 8}, {1628, 8}, {2016, 8},
  91   {2404, 8}, {68, 8}, {456, 8}, {844, 8}, {1232, 8}, {1620, 8}, {2008, 8},
  92   {2396, 8}, {60, 8}, {448, 8}, {836, 8}, {1224, 8}, {1612, 8}, {2000, 8},
  93   {2388, 8}, {52, 8}, {440, 8}, {828, 8}, {1216, 8}, {1604, 8}, {1992, 8},
  94   {2380, 8}, {44, 8}, {432, 8}, {820, 8}, {1208, 8}, {1596, 8}, {1984, 8},
  95   {2372, 8}, {36, 8}, {424, 8}, {812, 8}, {1200, 8}, {1588, 8}, {1976, 8},
  96   {2364, 8}, {28, 8}, {416, 8}, {804, 8}, {1192, 8}, {1580, 8}, {1968, 8},
  97   {2356, 8}, {20, 8}, {408, 8}, {796, 8}, {1184, 8}, {1572, 8}, {1960, 8},
  98   {2348, 8}, {12, 8}, {400, 8}, {788, 8}, {1176, 8}, {1564, 8}, {1952, 8},
  99   {2340, 8}, {4, 8}, {392, 8}, {780, 8}, {1168, 8}, {1556, 8}, {1944, 8},
 100   {2332, 8},
 101   /* missing from original data set */
 102   {388, 4}, {776, 4}, {1164, 4}, {1552, 4}, {1940, 4}, {2328, 4},
 103 };
 104 /* *INDENT-ON* */
 105
 106 int
 107 pattern_cmp (const void *arg1, const void *arg2)
 108 {
 109   test_pattern_t *a1 = (test_pattern_t *) arg1;
 110   test_pattern_t *a2 = (test_pattern_t *) arg2;
 111
 112   if (a1->offset < a2->offset)
 113     return -1;
 114   else if (a1->offset > a2->offset)
 115     return 1;
 116   return 0;
 117 }
 118
 119 static u8
 120 fifo_validate_pattern (vlib_main_t * vm, test_pattern_t * pattern,
 121                        u32 pattern_length)
 122 {
 123   test_pattern_t *tp = pattern;
 124   int i;
 125
 126   /* Go through the pattern and make 100% sure it's sane */
 127   for (i = 0; i < pattern_length - 1; i++)
 128     {
 129       if (tp->offset + tp->len != (tp + 1)->offset)
 130         {
 131           vlib_cli_output (vm, "[%d] missing {%d, %d}", i,
 132                            (tp->offset + tp->len),
 133                            (tp + 1)->offset - (tp->offset + tp->len));
 134           return 0;
 135         }
 136       tp++;
 137     }
 138   return 1;
 139 }
 140
 141 static test_pattern_t *
 142 fifo_get_validate_pattern (vlib_main_t * vm, test_pattern_t * test_data,
 143                            u32 test_data_len)
 144 {
 145   test_pattern_t *validate_pattern = 0;
 146
 147   /* Validate, and try segments in order... */
 148   vec_validate (validate_pattern, test_data_len - 1);
 149   memcpy (validate_pattern, test_data,
 150           test_data_len * sizeof (test_pattern_t));
 151   qsort ((u8 *) validate_pattern, test_data_len, sizeof (test_pattern_t),
 152          pattern_cmp);
 153
 154   if (fifo_validate_pattern (vm, validate_pattern, test_data_len) == 0)
 155     return 0;
 156
 157   return validate_pattern;
 158 }
 159
 160 static svm_fifo_t *
 161 fifo_prepare (u32 fifo_size)
 162 {
 163   svm_fifo_t *f;
 164   f = svm_fifo_create (fifo_size);
 165
 166   /* Paint fifo data vector with -1's */
 167   clib_memset (f->head_chunk->data, 0xFF, fifo_size);
 168
 169   return f;
 170 }
 171
 172 static int
 173 compare_data (u8 * data1, u8 * data2, u32 start, u32 len, u32 * index)
 174 {
 175   int i;
 176
 177   for (i = start; i < start + len; i++)
 178     {
 179       if (data1[i] != data2[i])
 180         {
 181           *index = i;
 182           return 1;
 183         }
 184     }
 185   return 0;
 186 }
 187
 188 int
 189 sfifo_test_fifo1 (vlib_main_t * vm, unformat_input_t * input)
 190 {
 191   svm_fifo_t *f;
 192   u32 fifo_size = 1 << 20;
 193   u32 *test_data = 0;
 194   u32 offset;
 195   int i, rv, verbose = 0;
 196   u32 data_word, test_data_len, j;
 197   ooo_segment_t *ooo_seg;
 198   u8 *data, *s, *data_buf = 0;
 199
 200   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 201     {
 202       if (unformat (input, "verbose"))
 203         verbose = 1;
 204     }
 205
 206   test_data_len = fifo_size / sizeof (u32);
 207   vec_validate (test_data, test_data_len - 1);
 208
 209   for (i = 0; i < vec_len (test_data); i++)
 210     test_data[i] = i;
 211
 212   f = fifo_prepare (fifo_size);
 213
 214   /*
 215    * Enqueue an initial (un-dequeued) chunk
 216    */
 217   rv = svm_fifo_enqueue (f, sizeof (u32), (u8 *) test_data);
 218   SFIFO_TEST ((rv == sizeof (u32)), "enqueued %d", rv);
 219   SFIFO_TEST ((f->tail == 4), "fifo tail %u", f->tail);
 220
 221   /*
 222    * Create 3 chunks in the future. The offsets are relative
 223    * to the current fifo tail
 224    */
 225   for (i = 0; i < 3; i++)
 226     {
 227       offset = (2 * i + 1) * sizeof (u32) - f->tail;
 228       data = (u8 *) (test_data + (2 * i + 1));
 229       if (i == 0)
 230         {
 231           rv = svm_fifo_enqueue (f, sizeof (u32), data);
 232           rv = rv > 0 ? 0 : rv;
 233         }
 234       else
 235         rv = svm_fifo_enqueue_with_offset (f, offset, sizeof (u32), data);
 236       if (verbose)
 237         vlib_cli_output (vm, "add [%d] [%d, %d]", 2 * i + 1, offset,
 238                          offset + sizeof (u32));
 239       if (rv)
 240         {
 241           clib_warning ("enqueue returned %d", rv);
 242           goto err;
 243         }
 244     }
 245
 246   if (verbose)
 247     vlib_cli_output (vm, "fifo after odd segs: %U", format_svm_fifo, f, 1);
 248
 249   SFIFO_TEST ((f->tail == 8), "fifo tail %u", f->tail);
 250   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 2),
 251               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 252
 253   /*
 254    * Try adding a completely overlapped segment
 255    */
 256   offset = 3 * sizeof (u32) - f->tail;
 257   data = (u8 *) (test_data + 3);
 258   rv = svm_fifo_enqueue_with_offset (f, offset, sizeof (u32), data);
 259   if (rv)
 260     {
 261       clib_warning ("enqueue returned %d", rv);
 262       goto err;
 263     }
 264
 265   if (verbose)
 266     vlib_cli_output (vm, "fifo after overlap seg: %U", format_svm_fifo, f, 1);
 267
 268   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 2),
 269               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 270
 271   /*
 272    * Make sure format functions are not buggy
 273    */
 274   s = format (0, "%U", format_svm_fifo, f, 2);
 275   vec_free (s);
 276
 277   /*
 278    * Paint some of missing data backwards
 279    */
 280   for (i = 3; i > 1; i--)
 281     {
 282       offset = (2 * i + 0) * sizeof (u32) - f->tail;
 283       data = (u8 *) (test_data + (2 * i + 0));
 284       rv = svm_fifo_enqueue_with_offset (f, offset, sizeof (u32), data);
 285       if (verbose)
 286         vlib_cli_output (vm, "add [%d] [%d, %d]", 2 * i, offset,
 287                          offset + sizeof (u32));
 288       if (rv)
 289         {
 290           clib_warning ("enqueue returned %d", rv);
 291           goto err;
 292         }
 293     }
 294
 295   if (verbose)
 296     vlib_cli_output (vm, "fifo before missing link: %U", format_svm_fifo, f,
 297                      1);
 298   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
 299               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 300   ooo_seg = svm_fifo_first_ooo_segment (f);
 301   SFIFO_TEST ((ooo_seg->start == 12),
 302               "first ooo seg position %u", ooo_seg->start);
 303   SFIFO_TEST ((ooo_seg->length == 16),
 304               "first ooo seg length %u", ooo_seg->length);
 305
 306   /*
 307    * Enqueue the missing u32
 308    */
 309   rv = svm_fifo_enqueue (f, sizeof (u32), (u8 *) (test_data + 2));
 310   if (verbose)
 311     vlib_cli_output (vm, "fifo after missing link: %U", format_svm_fifo, f,
 312                      1);
 313   SFIFO_TEST ((rv == 20), "bytes to be enqueued %u", rv);
 314   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
 315               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 316
 317   /*
 318    * Collect results
 319    */
 320   for (i = 0; i < 7; i++)
 321     {
 322       rv = svm_fifo_dequeue (f, sizeof (u32), (u8 *) & data_word);
 323       if (rv != sizeof (u32))
 324         {
 325           clib_warning ("bytes dequeues %u", rv);
 326           goto err;
 327         }
 328       if (data_word != test_data[i])
 329         {
 330           clib_warning ("recovered [%d] %d not %d", i, data_word,
 331                         test_data[i]);
 332           goto err;
 333         }
 334     }
 335
 336   /*
 337    * Test segment overlaps: last ooo segment overlaps all
 338    */
 339   svm_fifo_free (f);
 340   f = fifo_prepare (fifo_size);
 341
 342   for (i = 0; i < 4; i++)
 343     {
 344       offset = (2 * i + 1) * sizeof (u32) - f->tail;
 345       data = (u8 *) (test_data + (2 * i + 1));
 346       rv = svm_fifo_enqueue_with_offset (f, offset, sizeof (u32), data);
 347       if (verbose)
 348         vlib_cli_output (vm, "add [%d] [%d, %d]", 2 * i + 1, offset,
 349                          offset + sizeof (u32));
 350       if (rv)
 351         {
 352           clib_warning ("enqueue returned %d", rv);
 353           goto err;
 354         }
 355     }
 356
 357   rv = svm_fifo_enqueue_with_offset (f, 8 - f->tail, 21, data);
 358   SFIFO_TEST ((rv == 0), "ooo enqueued %u", rv);
 359   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
 360               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 361
 362   /* add missing data to be able to dequeue something */
 363   rv = svm_fifo_enqueue (f, 4, data);
 364   SFIFO_TEST ((rv == 32), "enqueued %u", rv);
 365   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
 366               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 367
 368   vec_validate (data_buf, vec_len (test_data));
 369   svm_fifo_peek (f, 0, 4, data_buf);
 370   if (compare_data (data_buf, data, 0, 4, &j))
 371     SFIFO_TEST (0, "[%d] peeked %u expected %u", j, data_buf[j], data[j]);
 372   svm_fifo_peek (f, 8, 21, data_buf);
 373   if (compare_data (data_buf, data, 0, 21, &j))
 374     SFIFO_TEST (0, "[%d] peeked %u expected %u", j, data_buf[j], data[j]);
 375   vec_reset_length (data_buf);
 376
 377   /*
 378    * Test segment overlaps: enqueue and overlap ooo segments
 379    */
 380   svm_fifo_free (f);
 381   f = fifo_prepare (fifo_size);
 382
 383   for (i = 0; i < 4; i++)
 384     {
 385       offset = (2 * i + 1) * sizeof (u32) - f->tail;
 386       data = (u8 *) (test_data + (2 * i + 1));
 387       rv = svm_fifo_enqueue_with_offset (f, offset, sizeof (u32), data);
 388       if (verbose)
 389         vlib_cli_output (vm, "add [%d] [%d, %d]", 2 * i + 1, offset,
 390                          offset + sizeof (u32));
 391       if (rv)
 392         {
 393           clib_warning ("enqueue returned %d", rv);
 394           goto err;
 395         }
 396     }
 397
 398   if (verbose)
 399     vlib_cli_output (vm, "fifo after enqueue: %U", format_svm_fifo, f, 1);
 400
 401   rv = svm_fifo_enqueue (f, 29, data);
 402   if (verbose)
 403     vlib_cli_output (vm, "fifo after enqueueing 29: %U", format_svm_fifo, f,
 404                      1);
 405   SFIFO_TEST ((rv == 32), "ooo enqueued %u", rv);
 406   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
 407               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 408
 409   vec_validate (data_buf, vec_len (data));
 410   svm_fifo_peek (f, 0, vec_len (data), data_buf);
 411   if (compare_data (data_buf, data, 0, vec_len (data), &j))
 412     {
 413       SFIFO_TEST (0, "[%d] peeked %u expected %u", j, data_buf[j], data[j]);
 414     }
 415
 416   /* Try to peek beyond the data */
 417   rv = svm_fifo_peek (f, svm_fifo_max_dequeue (f), vec_len (data), data_buf);
 418   SFIFO_TEST ((rv == 0), "peeked %u expected 0", rv);
 419
 420   vec_free (data_buf);
 421   svm_fifo_free (f);
 422   vec_free (test_data);
 423
 424   return 0;
 425
 426 err:
 427   svm_fifo_free (f);
 428   vec_free (test_data);
 429   return -1;
 430 }
 431
 432 static int
 433 sfifo_test_fifo2 (vlib_main_t * vm)
 434 {
 435   svm_fifo_t *f;
 436   u32 fifo_size = (1 << 20) + 1;
 437   int i, rv, test_data_len;
 438   u64 data64;
 439   test_pattern_t *tp, *vp, *test_data;
 440   ooo_segment_t *ooo_seg;
 441
 442   test_data = test_pattern;
 443   test_data_len = ARRAY_LEN (test_pattern);
 444
 445   vp = fifo_get_validate_pattern (vm, test_data, test_data_len);
 446
 447   /* Create a fifo */
 448   f = fifo_prepare (fifo_size);
 449
 450   /*
 451    * Try with sorted data
 452    */
 453   for (i = 0; i < test_data_len; i++)
 454     {
 455       tp = vp + i;
 456       data64 = tp->offset;
 457       svm_fifo_enqueue_with_offset (f, tp->offset - f->tail, tp->len,
 458                                     (u8 *) & data64);
 459     }
 460
 461   /* Expected result: one big fat chunk at offset 4 */
 462   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
 463               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 464   ooo_seg = svm_fifo_first_ooo_segment (f);
 465   SFIFO_TEST ((ooo_seg->start == 4),
 466               "first ooo seg position %u", ooo_seg->start);
 467   SFIFO_TEST ((ooo_seg->length == 2996),
 468               "first ooo seg length %u", ooo_seg->length);
 469
 470   data64 = 0;
 471   rv = svm_fifo_enqueue (f, sizeof (u32), (u8 *) & data64);
 472   SFIFO_TEST ((rv == 3000), "bytes to be enqueued %u", rv);
 473
 474   svm_fifo_free (f);
 475   vec_free (vp);
 476
 477   /*
 478    * Now try it again w/ unsorted data...
 479    */
 480
 481   f = fifo_prepare (fifo_size);
 482
 483   for (i = 0; i < test_data_len; i++)
 484     {
 485       tp = &test_data[i];
 486       data64 = tp->offset;
 487       rv = svm_fifo_enqueue_with_offset (f, tp->offset - f->tail, tp->len,
 488                                          (u8 *) & data64);
 489       if (rv)
 490         {
 491           clib_warning ("enqueue returned %d", rv);
 492         }
 493     }
 494
 495   /* Expecting the same result: one big fat chunk at offset 4 */
 496   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
 497               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 498   ooo_seg = svm_fifo_first_ooo_segment (f);
 499   SFIFO_TEST ((ooo_seg->start == 4),
 500               "first ooo seg position %u", ooo_seg->start);
 501   SFIFO_TEST ((ooo_seg->length == 2996),
 502               "first ooo seg length %u", ooo_seg->length);
 503
 504   data64 = 0;
 505   rv = svm_fifo_enqueue (f, sizeof (u32), (u8 *) & data64);
 506
 507   SFIFO_TEST ((rv == 3000), "bytes to be enqueued %u", rv);
 508
 509   svm_fifo_free (f);
 510
 511   return 0;
 512 }
 513
 514 static int
 515 sfifo_test_fifo3 (vlib_main_t * vm, unformat_input_t * input)
 516 {
 517   svm_fifo_t *f;
 518   u32 fifo_size = (4 << 10) + 1;
 519   u32 fifo_initial_offset = 0;
 520   u32 total_size = 2 << 10;
 521   int overlap = 0, verbose = 0, randomize = 1, drop = 0, in_seq_all = 0;
 522   u8 *data_pattern = 0, *data_buf = 0;
 523   test_pattern_t *tp, *generate = 0;
 524   u32 nsegs = 2, seg_size, length_so_far;
 525   u32 current_offset, offset_increment, len_this_chunk;
 526   u32 seed = 0xdeaddabe, j;
 527   int i, rv;
 528
 529   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 530     {
 531       if (unformat (input, "fifo-size %d", &fifo_size))
 532         ;
 533       else if (unformat (input, "total-size %d", &total_size))
 534         ;
 535       else if (unformat (input, "verbose"))
 536         verbose = 1;
 537       else if (unformat (input, "overlap"))
 538         overlap = 1;
 539       else if (unformat (input, "initial-offset %d", &fifo_initial_offset))
 540         ;
 541       else if (unformat (input, "seed %d", &seed))
 542         ;
 543       else if (unformat (input, "nsegs %d", &nsegs))
 544         ;
 545       else if (unformat (input, "no-randomize"))
 546         randomize = 0;
 547       else if (unformat (input, "in-seq-all"))
 548         in_seq_all = 1;
 549       else if (unformat (input, "drop"))
 550         drop = 1;
 551       else
 552         {
 553           clib_error_t *e = clib_error_return
 554             (0, "unknown input `%U'", format_unformat_error, input);
 555           clib_error_report (e);
 556           return -1;
 557         }
 558     }
 559
 560   if (total_size > fifo_size)
 561     {
 562       clib_warning ("total_size %d greater than fifo size %d", total_size,
 563                     fifo_size);
 564       return -1;
 565     }
 566   if (overlap && randomize == 0)
 567     {
 568       clib_warning ("Can't enqueue in-order with overlap");
 569       return -1;
 570     }
 571
 572   /*
 573    * Generate data
 574    */
 575   vec_validate (data_pattern, total_size - 1);
 576   for (i = 0; i < vec_len (data_pattern); i++)
 577     data_pattern[i] = i & 0xff;
 578
 579   /*
 580    * Generate segments
 581    */
 582   seg_size = total_size / nsegs;
 583   length_so_far = 0;
 584   current_offset = randomize;
 585   while (length_so_far < total_size)
 586     {
 587       vec_add2 (generate, tp, 1);
 588       len_this_chunk = clib_min (seg_size, total_size - length_so_far);
 589       tp->offset = current_offset;
 590       tp->len = len_this_chunk;
 591
 592       if (overlap && (len_this_chunk == seg_size))
 593         do
 594           {
 595             offset_increment = len_this_chunk
 596               % (1 + (random_u32 (&seed) % len_this_chunk));
 597           }
 598         while (offset_increment == 0);
 599       else
 600         offset_increment = len_this_chunk;
 601
 602       current_offset += offset_increment;
 603       length_so_far = tp->offset + tp->len;
 604     }
 605
 606   /*
 607    * Validate segment list. Only valid for non-overlap cases.
 608    */
 609   if (overlap == 0)
 610     fifo_validate_pattern (vm, generate, vec_len (generate));
 611
 612   if (verbose)
 613     {
 614       vlib_cli_output (vm, "raw data pattern:");
 615       for (i = 0; i < vec_len (generate); i++)
 616         {
 617           vlib_cli_output (vm, "[%d] offset %u len %u", i,
 618                            generate[i].offset, generate[i].len);
 619         }
 620     }
 621
 622   /* Randomize data pattern */
 623   if (randomize)
 624     {
 625       for (i = 0; i < vec_len (generate) / 2; i++)
 626         {
 627           u32 src_index, dst_index;
 628           test_pattern_t _tmp, *tmp = &_tmp;
 629
 630           src_index = random_u32 (&seed) % vec_len (generate);
 631           dst_index = random_u32 (&seed) % vec_len (generate);
 632
 633           tmp[0] = generate[dst_index];
 634           generate[dst_index] = generate[src_index];
 635           generate[src_index] = tmp[0];
 636         }
 637       if (verbose)
 638         {
 639           vlib_cli_output (vm, "randomized data pattern:");
 640           for (i = 0; i < vec_len (generate); i++)
 641             {
 642               vlib_cli_output (vm, "[%d] offset %u len %u", i,
 643                                generate[i].offset, generate[i].len);
 644             }
 645         }
 646     }
 647
 648   /*
 649    * Create a fifo and add segments
 650    */
 651   f = fifo_prepare (fifo_size);
 652
 653   /* manually set head and tail pointers to validate modular arithmetic */
 654   fifo_initial_offset = fifo_initial_offset % fifo_size;
 655   svm_fifo_init_pointers (f, fifo_initial_offset, fifo_initial_offset);
 656
 657   for (i = !randomize; i < vec_len (generate); i++)
 658     {
 659       tp = generate + i;
 660       svm_fifo_enqueue_with_offset (f,
 661                                     fifo_initial_offset + tp->offset -
 662                                     f->tail, tp->len,
 663                                     (u8 *) data_pattern + tp->offset);
 664     }
 665
 666   /* Add the first segment in order for non random data */
 667   if (!randomize)
 668     svm_fifo_enqueue (f, generate[0].len, (u8 *) data_pattern);
 669
 670   /*
 671    * Expected result: one big fat chunk at offset 1 if randomize == 1
 672    */
 673
 674   if (verbose)
 675     vlib_cli_output (vm, "fifo before missing link: %U",
 676                      format_svm_fifo, f, 1 /* verbose */ );
 677
 678   /*
 679    * Add the missing byte if segments were randomized
 680    */
 681   if (randomize)
 682     {
 683       u32 bytes_to_enq = 1;
 684       if (in_seq_all)
 685         bytes_to_enq = total_size;
 686       rv = svm_fifo_enqueue (f, bytes_to_enq, data_pattern + 0);
 687
 688       if (verbose)
 689         vlib_cli_output (vm, "in-order enqueue returned %d", rv);
 690
 691       SFIFO_TEST ((rv == total_size), "enqueued %u expected %u", rv,
 692                   total_size);
 693
 694     }
 695
 696   SFIFO_TEST ((svm_fifo_has_ooo_data (f) == 0), "number of ooo segments %u",
 697               svm_fifo_n_ooo_segments (f));
 698
 699   /*
 700    * Test if peeked data is the same as original data
 701    */
 702   vec_validate (data_buf, vec_len (data_pattern));
 703   svm_fifo_peek (f, 0, vec_len (data_pattern), data_buf);
 704   if (compare_data (data_buf, data_pattern, 0, vec_len (data_pattern), &j))
 705     {
 706       SFIFO_TEST (0, "[%d] peeked %u expected %u", j, data_buf[j],
 707                   data_pattern[j]);
 708     }
 709   vec_reset_length (data_buf);
 710
 711   /*
 712    * Dequeue or drop all data
 713    */
 714   if (drop)
 715     {
 716       svm_fifo_dequeue_drop (f, vec_len (data_pattern));
 717     }
 718   else
 719     {
 720       svm_fifo_dequeue (f, vec_len (data_pattern), data_buf);
 721       if (compare_data
 722           (data_buf, data_pattern, 0, vec_len (data_pattern), &j))
 723         {
 724           SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
 725                       data_pattern[j]);
 726         }
 727     }
 728
 729   SFIFO_TEST ((svm_fifo_max_dequeue (f) == 0), "fifo has %d bytes",
 730               svm_fifo_max_dequeue (f));
 731
 732   svm_fifo_free (f);
 733   vec_free (data_pattern);
 734   vec_free (data_buf);
 735
 736   return 0;
 737 }
 738
 739 static int
 740 sfifo_test_fifo4 (vlib_main_t * vm, unformat_input_t * input)
 741 {
 742   svm_fifo_t *f;
 743   u32 fifo_size = 6 << 10;
 744   u32 fifo_initial_offset = 1000000000;
 745   u32 test_n_bytes = 5000, j;
 746   u8 *test_data = 0, *data_buf = 0;
 747   int i, rv, verbose = 0;
 748
 749   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 750     {
 751       if (unformat (input, "verbose"))
 752         verbose = 1;
 753       else
 754         {
 755           clib_error_t *e = clib_error_return
 756             (0, "unknown input `%U'", format_unformat_error, input);
 757           clib_error_report (e);
 758           return -1;
 759         }
 760     }
 761
 762   /*
 763    * Create a fifo and add segments
 764    */
 765   f = fifo_prepare (fifo_size);
 766
 767   /* Set head and tail pointers */
 768   fifo_initial_offset = fifo_initial_offset % fifo_size;
 769   svm_fifo_init_pointers (f, fifo_initial_offset, fifo_initial_offset);
 770
 771   vec_validate (test_data, test_n_bytes - 1);
 772   for (i = 0; i < vec_len (test_data); i++)
 773     test_data[i] = i;
 774
 775   for (i = test_n_bytes - 1; i > 0; i--)
 776     {
 777       rv = svm_fifo_enqueue_with_offset (f, fifo_initial_offset + i - f->tail,
 778                                          sizeof (u8), &test_data[i]);
 779       if (verbose)
 780         vlib_cli_output (vm, "add [%d] [%d, %d]", i, i, i + sizeof (u8));
 781       if (rv)
 782         {
 783           clib_warning ("enqueue returned %d", rv);
 784           svm_fifo_free (f);
 785           vec_free (test_data);
 786           return -1;
 787         }
 788     }
 789
 790   svm_fifo_enqueue (f, sizeof (u8), &test_data[0]);
 791
 792   vec_validate (data_buf, vec_len (test_data));
 793
 794   svm_fifo_dequeue (f, vec_len (test_data), data_buf);
 795   rv = compare_data (data_buf, test_data, 0, vec_len (test_data), &j);
 796   if (rv)
 797     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
 798                      test_data[j]);
 799   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
 800
 801   svm_fifo_free (f);
 802   vec_free (test_data);
 803   return 0;
 804 }
 805
 806 static u32
 807 fifo_pos (svm_fifo_t * f, u32 pos)
 808 {
 809   return pos;
 810 }
 811
 812 /* Avoids exposing svm_fifo.c internal function */
 813 static ooo_segment_t *
 814 ooo_seg_next (svm_fifo_t * f, ooo_segment_t * s)
 815 {
 816   if (pool_is_free_index (f->ooo_segments, s->next))
 817     return 0;
 818   return pool_elt_at_index (f->ooo_segments, s->next);
 819 }
 820
 821 static int
 822 sfifo_test_fifo5 (vlib_main_t * vm, unformat_input_t * input)
 823 {
 824   svm_fifo_t *f;
 825   u32 fifo_size = 401, j = 0, offset = 200;
 826   int i, rv, verbose = 0;
 827   u8 *test_data = 0, *data_buf = 0;
 828   ooo_segment_t *ooo_seg;
 829
 830   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 831     {
 832       if (unformat (input, "verbose"))
 833         verbose = 1;
 834       else
 835         {
 836           clib_error_t *e = clib_error_return (0, "unknown input `%U'",
 837                                                format_unformat_error, input);
 838           clib_error_report (e);
 839           return -1;
 840         }
 841     }
 842
 843   f = fifo_prepare (fifo_size);
 844   svm_fifo_init_pointers (f, offset, offset);
 845
 846   vec_validate (test_data, 399);
 847   for (i = 0; i < vec_len (test_data); i++)
 848     test_data[i] = i % 0xff;
 849
 850   /*
 851    * Start with [100, 200] and [300, 400]
 852    */
 853   svm_fifo_enqueue_with_offset (f, 100, 100, &test_data[100]);
 854   svm_fifo_enqueue_with_offset (f, 300, 100, &test_data[300]);
 855
 856   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 2),
 857               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 858   SFIFO_TEST ((f->ooos_newest == 1), "newest %u", f->ooos_newest);
 859   if (verbose)
 860     vlib_cli_output (vm, "fifo after [100, 200] and [300, 400] : %U",
 861                      format_svm_fifo, f, 2 /* verbose */ );
 862
 863   /*
 864    * Add [225, 275]
 865    */
 866
 867   rv = svm_fifo_enqueue_with_offset (f, 225, 50, &test_data[225]);
 868   if (verbose)
 869     vlib_cli_output (vm, "fifo after [225, 275] : %U",
 870                      format_svm_fifo, f, 2 /* verbose */ );
 871   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 3),
 872               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 873   ooo_seg = svm_fifo_first_ooo_segment (f);
 874   SFIFO_TEST ((ooo_seg->start == fifo_pos (f, 100 + offset)),
 875               "first seg start %u expected %u", ooo_seg->start,
 876               fifo_pos (f, 100 + offset));
 877   SFIFO_TEST ((ooo_seg->length == 100), "first seg length %u expected %u",
 878               ooo_seg->length, 100);
 879   ooo_seg = ooo_seg_next (f, ooo_seg);
 880   SFIFO_TEST ((ooo_seg->start == fifo_pos (f, 225 + offset)),
 881               "second seg start %u expected %u",
 882               ooo_seg->start, fifo_pos (f, 225 + offset));
 883   SFIFO_TEST ((ooo_seg->length == 50), "second seg length %u expected %u",
 884               ooo_seg->length, 50);
 885   ooo_seg = ooo_seg_next (f, ooo_seg);
 886   SFIFO_TEST ((ooo_seg->start == fifo_pos (f, 300 + offset)),
 887               "third seg start %u expected %u",
 888               ooo_seg->start, fifo_pos (f, 300 + offset));
 889   SFIFO_TEST ((ooo_seg->length == 100), "third seg length %u expected %u",
 890               ooo_seg->length, 100);
 891   SFIFO_TEST ((f->ooos_newest == 2), "newest %u", f->ooos_newest);
 892   /*
 893    * Add [190, 310]
 894    */
 895   rv = svm_fifo_enqueue_with_offset (f, 190, 120, &test_data[190]);
 896   if (verbose)
 897     vlib_cli_output (vm, "fifo after [190, 310] : %U",
 898                      format_svm_fifo, f, 1 /* verbose */ );
 899   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
 900               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 901   ooo_seg = svm_fifo_first_ooo_segment (f);
 902   SFIFO_TEST ((ooo_seg->start == fifo_pos (f, offset + 100)),
 903               "first seg start %u expected %u",
 904               ooo_seg->start, fifo_pos (f, offset + 100));
 905   SFIFO_TEST ((ooo_seg->length == 300), "first seg length %u expected %u",
 906               ooo_seg->length, 300);
 907
 908   /*
 909    * Add [0, 150]
 910    */
 911   rv = svm_fifo_enqueue (f, 150, test_data);
 912
 913   if (verbose)
 914     vlib_cli_output (vm, "fifo after [0 150] : %U", format_svm_fifo, f,
 915                      2 /* verbose */ );
 916
 917   SFIFO_TEST ((rv == 400), "managed to enqueue %u expected %u", rv, 400);
 918   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
 919               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 920
 921   vec_validate (data_buf, 399);
 922   svm_fifo_peek (f, 0, 400, data_buf);
 923   if (compare_data (data_buf, test_data, 0, 400, &j))
 924     {
 925       SFIFO_TEST (0, "[%d] peeked %u expected %u", j, data_buf[j],
 926                   test_data[j]);
 927     }
 928
 929   /*
 930    * Add [100 200] and overlap it with [50 250]
 931    */
 932   svm_fifo_free (f);
 933   f = fifo_prepare (fifo_size);
 934
 935   svm_fifo_enqueue_with_offset (f, 100, 100, &test_data[100]);
 936   svm_fifo_enqueue_with_offset (f, 50, 200, &test_data[50]);
 937   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
 938               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
 939   ooo_seg = svm_fifo_first_ooo_segment (f);
 940   SFIFO_TEST ((ooo_seg->start == 50), "first seg start %u expected %u",
 941               ooo_seg->start, 50);
 942   SFIFO_TEST ((ooo_seg->length == 200), "first seg length %u expected %u",
 943               ooo_seg->length, 200);
 944
 945   svm_fifo_free (f);
 946   vec_free (test_data);
 947   return 0;
 948 }
 949
 950 /*
 951  * Test ooo head/tail u32 wrapping
 952  */
 953 static int
 954 sfifo_test_fifo6 (vlib_main_t * vm, unformat_input_t * input)
 955 {
 956   u32 fifo_size = 101, n_test_bytes = 100;
 957   int i, j, rv, __clib_unused verbose = 0;
 958   u8 *test_data = 0, *data_buf = 0;
 959   ooo_segment_t *ooo_seg;
 960   svm_fifo_t *f;
 961
 962   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 963     {
 964       if (unformat (input, "verbose"))
 965         verbose = 1;
 966       else
 967         {
 968           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
 969                            input);
 970           return -1;
 971         }
 972     }
 973
 974   f = fifo_prepare (fifo_size);
 975   vec_validate (test_data, n_test_bytes - 1);
 976   vec_validate (data_buf, n_test_bytes - 1);
 977   for (i = 0; i < vec_len (test_data); i++)
 978     test_data[i] = i % 0xff;
 979
 980   /*
 981    * Test ooo segment distance to/from tail with u32 wrap
 982    */
 983
 984   /*
 985    * |0|---[start]--(len5)-->|0|--(len6)-->[end]---|0|
 986    */
 987   rv = f_distance_from (f, ~0 - 5, 5);
 988   SFIFO_TEST (rv == 11, "distance to tail should be %u is %u", 11, rv);
 989
 990   rv = f_distance_to (f, ~0 - 5, 5);
 991   SFIFO_TEST (rv == f->size - 11, "distance from tail should be %u is %u",
 992               f->size - 11, rv);
 993
 994   /*
 995    * |0|---[end]--(len5)-->|0|--(len6)-->[start]---|0|
 996    */
 997   rv = f_distance_to (f, 5, ~0 - 5);
 998   SFIFO_TEST (rv == 11, "distance from tail should be %u is %u", 11, rv);
 999
1000   rv = f_distance_from (f, 5, ~0 - 5);
1001   SFIFO_TEST (rv == f->size - 11, "distance to tail should be %u is %u",
1002               f->size - 11, rv);
1003
1004   /*
1005    * Add ooo with tail and ooo segment start u32 wrap
1006    */
1007   svm_fifo_init_pointers (f, ~0, ~0);
1008   svm_fifo_enqueue_with_offset (f, 10, 10, &test_data[10]);
1009   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 1),
1010               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
1011   ooo_seg = svm_fifo_first_ooo_segment (f);
1012   rv = ooo_segment_offset_prod (f, ooo_seg);
1013   SFIFO_TEST (rv == 10, "offset should be %u is %u", 10, rv);
1014
1015   svm_fifo_enqueue (f, 10, test_data);
1016   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
1017               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
1018   SFIFO_TEST (f->ooos_list_head == OOO_SEGMENT_INVALID_INDEX,
1019               "there should be no ooo seg");
1020
1021   svm_fifo_peek (f, 5, 10, &data_buf[5]);
1022   if (compare_data (data_buf, test_data, 5, 10, (u32 *) & j))
1023     SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
1024                 test_data[j]);
1025
1026   svm_fifo_dequeue (f, 20, data_buf);
1027   if (compare_data (data_buf, test_data, 0, 20, (u32 *) & j))
1028     SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
1029                 test_data[j]);
1030
1031   /*
1032    * Force collect with tail u32 wrap and without ooo segment start u32 wrap
1033    */
1034   svm_fifo_init_pointers (f, ~0 - 10, ~0 - 10);
1035   svm_fifo_enqueue_with_offset (f, 5, 15, &test_data[5]);
1036   svm_fifo_enqueue (f, 12, test_data);
1037
1038   SFIFO_TEST ((svm_fifo_n_ooo_segments (f) == 0),
1039               "number of ooo segments %u", svm_fifo_n_ooo_segments (f));
1040   SFIFO_TEST (f->ooos_list_head == OOO_SEGMENT_INVALID_INDEX,
1041               "there should be no ooo seg");
1042
1043   svm_fifo_dequeue (f, 20, data_buf);
1044   if (compare_data (data_buf, test_data, 0, 20, (u32 *) & j))
1045     SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
1046                 test_data[j]);
1047
1048   /*
1049    * Cleanup
1050    */
1051   vec_free (test_data);
1052   vec_free (data_buf);
1053   svm_fifo_free (f);
1054   return 0;
1055 }
1056
1057 /*
1058  * Multiple ooo enqueues and dequeues that force fifo tail/head wrap
1059  */
1060 static int
1061 sfifo_test_fifo7 (vlib_main_t * vm, unformat_input_t * input)
1062 {
1063   u32 fifo_size = 101, n_iterations = 100;
1064   int i, j, rv, __clib_unused verbose = 0;
1065   u8 *test_data = 0, *data_buf = 0;
1066   u64 n_test_bytes = 100;
1067   svm_fifo_t *f;
1068
1069   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1070     {
1071       if (unformat (input, "verbose"))
1072         verbose = 1;
1073       else
1074         {
1075           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1076                            input);
1077           return -1;
1078         }
1079     }
1080
1081   /*
1082    * Prepare data structures
1083    */
1084   f = fifo_prepare (fifo_size);
1085   svm_fifo_init_pointers (f, ~0, ~0);
1086
1087   vec_validate (test_data, n_test_bytes - 1);
1088   vec_validate (data_buf, n_test_bytes - 1);
1089   for (i = 0; i < vec_len (test_data); i++)
1090     test_data[i] = i % 0xff;
1091
1092   /*
1093    * Run n iterations of test
1094    */
1095   for (i = 0; i < n_iterations; i++)
1096     {
1097       for (j = n_test_bytes - 1; j > 0; j -= 2)
1098         {
1099           svm_fifo_enqueue_with_offset (f, j, 1, &test_data[j]);
1100           rv = svm_fifo_n_ooo_segments (f);
1101           if (rv != (n_test_bytes - j) / 2 + 1)
1102             SFIFO_TEST (0, "number of ooo segments expected %u is %u",
1103                         (n_test_bytes - j) / 2 + 1, rv);
1104         }
1105
1106       svm_fifo_enqueue_with_offset (f, 1, n_test_bytes - 1, &test_data[1]);
1107       rv = svm_fifo_n_ooo_segments (f);
1108       if (rv != 1)
1109         SFIFO_TEST (0, "number of ooo segments %u", rv);
1110
1111       svm_fifo_enqueue (f, 1, test_data);
1112       rv = svm_fifo_n_ooo_segments (f);
1113       if (rv != 0)
1114         SFIFO_TEST (0, "number of ooo segments %u", rv);
1115
1116       svm_fifo_dequeue (f, n_test_bytes, data_buf);
1117       if (compare_data (data_buf, test_data, 0, n_test_bytes, (u32 *) & j))
1118         SFIFO_TEST (0, "[%d] dequeued %u expected %u", j, data_buf[j],
1119                     test_data[j]);
1120       svm_fifo_init_pointers (f, ~0 - i, ~0 - i);
1121     }
1122   SFIFO_TEST (1, "passed multiple ooo enqueue/dequeue");
1123
1124   /*
1125    * Cleanup
1126    */
1127   vec_free (test_data);
1128   vec_free (data_buf);
1129   svm_fifo_free (f);
1130   return 0;
1131 }
1132
1133 /*
1134  * Enqueue more than 4GB
1135  */
1136 static int
1137 sfifo_test_fifo_large (vlib_main_t * vm, unformat_input_t * input)
1138 {
1139   u32 n_iterations = 100, n_bytes_per_iter, half;
1140   int i, j, rv, __clib_unused verbose = 0;
1141   u8 *test_data = 0, *data_buf = 0;
1142   u64 n_test_bytes = 100;
1143   svm_fifo_t *f;
1144
1145   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1146     {
1147       if (unformat (input, "verbose"))
1148         verbose = 1;
1149       else
1150         {
1151           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1152                            input);
1153           return -1;
1154         }
1155     }
1156
1157
1158   n_test_bytes = 5ULL << 30;
1159   n_iterations = 1 << 10;
1160   n_bytes_per_iter = n_test_bytes / n_iterations;
1161
1162   f = fifo_prepare (n_bytes_per_iter + 1);
1163   svm_fifo_init_pointers (f, ~0, ~0);
1164
1165   vec_validate (test_data, n_bytes_per_iter - 1);
1166   vec_validate (data_buf, n_bytes_per_iter - 1);
1167   for (i = 0; i < vec_len (test_data); i++)
1168     test_data[i] = i % 0xff;
1169
1170   half = n_bytes_per_iter / 2;
1171   for (i = 0; i < n_iterations; i++)
1172     {
1173       svm_fifo_enqueue_with_offset (f, half, half, &test_data[half]);
1174       svm_fifo_enqueue (f, half, test_data);
1175       rv = svm_fifo_n_ooo_segments (f);
1176       if (rv != 0)
1177         SFIFO_TEST (0, "number of ooo segments %u", rv);
1178       svm_fifo_dequeue (f, n_bytes_per_iter, data_buf);
1179       if (compare_data (data_buf, test_data, 0, n_bytes_per_iter,
1180                         (u32 *) & j))
1181         SFIFO_TEST (0, "[%d][%d] dequeued %u expected %u", i, j, data_buf[j],
1182                     test_data[j]);
1183     }
1184   SFIFO_TEST (1, "passed large transfer");
1185
1186   return 0;
1187 }
1188
1189 static int
1190 sfifo_test_fifo_grow (vlib_main_t * vm, unformat_input_t * input)
1191 {
1192   int verbose = 0, fifo_size = 201, start_offset = 100, i, j, rv;
1193   int test_n_bytes, deq_bytes, enq_bytes, n_deqs, n_enqs;
1194   svm_fifo_chunk_t *c, *next, *prev;
1195   u8 *test_data = 0, *data_buf = 0;
1196   svm_fifo_t *f;
1197
1198   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1199     {
1200       if (unformat (input, "verbose"))
1201         verbose = 1;
1202       else
1203         {
1204           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1205                            input);
1206           return -1;
1207         }
1208     }
1209
1210   f = fifo_prepare (fifo_size);
1211   svm_fifo_init_pointers (f, start_offset, start_offset);
1212
1213   /*
1214    * Add with fifo not wrapped
1215    */
1216   c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + 100);
1217   c->length = 100;
1218   c->start_byte = ~0;
1219   c->next = 0;
1220
1221   svm_fifo_add_chunk (f, c);
1222
1223   SFIFO_TEST (f->size == fifo_size + 100, "size expected %u is %u",
1224               fifo_size + 100, f->size);
1225   SFIFO_TEST (c->start_byte == fifo_size, "start byte expected %u is %u",
1226               fifo_size, c->start_byte);
1227
1228   /*
1229    *  Add with fifo wrapped
1230    */
1231
1232   svm_fifo_init_pointers (f, f->nitems - 100, f->nitems + 100);
1233   c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + 100);
1234   c->length = 100;
1235   c->start_byte = ~0;
1236   c->next = 0;
1237
1238   svm_fifo_add_chunk (f, c);
1239
1240   SFIFO_TEST (f->end_chunk != c, "tail chunk should not be updated");
1241   SFIFO_TEST (f->size == fifo_size + 100, "size expected %u is %u",
1242               fifo_size + 100, f->size);
1243   SFIFO_TEST (c->start_byte == fifo_size + 100, "start byte expected %u is "
1244               " %u", fifo_size + 100, c->start_byte);
1245
1246   /*
1247    * Unwrap fifo
1248    */
1249   vec_validate (data_buf, 200);
1250   svm_fifo_dequeue (f, 201, data_buf);
1251
1252   SFIFO_TEST (f->end_chunk == c, "tail chunk should be updated");
1253   SFIFO_TEST (f->size == fifo_size + 200, "size expected %u is %u",
1254               fifo_size + 200, f->size);
1255   SFIFO_TEST (c->start_byte == fifo_size + 100, "start byte expected %u is "
1256               "%u", fifo_size + 100, c->start_byte);
1257
1258   /*
1259    * Add N chunks
1260    */
1261   svm_fifo_init_pointers (f, f->nitems - 100, f->nitems + 100);
1262
1263   prev = 0;
1264   for (i = 0; i < 5; i++)
1265     {
1266       c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + 100);
1267       c->length = 100;
1268       c->start_byte = ~0;
1269       c->next = prev;
1270       prev = c;
1271     }
1272
1273   svm_fifo_add_chunk (f, c);
1274   SFIFO_TEST (f->size == fifo_size + 200, "size expected %u is %u",
1275               fifo_size + 200, f->size);
1276
1277   prev = 0;
1278   for (i = 0; i < 5; i++)
1279     {
1280       c = clib_mem_alloc (sizeof (svm_fifo_chunk_t) + 100);
1281       c->length = 100;
1282       c->start_byte = ~0;
1283       c->next = prev;
1284       prev = c;
1285     }
1286
1287   svm_fifo_add_chunk (f, c);
1288   SFIFO_TEST (f->size == fifo_size + 200, "size expected %u is %u",
1289               fifo_size + 200, f->size);
1290
1291   svm_fifo_dequeue (f, 201, data_buf);
1292
1293   SFIFO_TEST (f->size == fifo_size + 200 + 10 * 100, "size expected %u is %u",
1294               fifo_size + 200 + 10 * 100, f->size);
1295   /*
1296    * Enqueue/dequeue tests
1297    */
1298
1299   test_n_bytes = f->nitems;
1300   vec_validate (test_data, test_n_bytes - 1);
1301   vec_validate (data_buf, vec_len (test_data));
1302   n_deqs = n_enqs = 6;
1303   deq_bytes = enq_bytes = vec_len (test_data) / n_deqs;
1304
1305   for (i = 0; i < vec_len (test_data); i++)
1306     test_data[i] = i;
1307
1308   /*
1309    * Enqueue/deq boundary conditions
1310    */
1311   svm_fifo_init_pointers (f, 201, 201);
1312   SFIFO_TEST (f->tail_chunk->start_byte == 201, "start byte expected %u is "
1313               "%u", 201, f->tail_chunk->start_byte);
1314
1315   svm_fifo_enqueue (f, 200, test_data);
1316   SFIFO_TEST (f->tail_chunk->start_byte == 401, "start byte expected %u is "
1317               "%u", 401, f->tail_chunk->start_byte);
1318
1319   svm_fifo_dequeue (f, 200, data_buf);
1320   SFIFO_TEST (f->head_chunk->start_byte == 401, "start byte expected %u is "
1321               "%u", 401, f->head_chunk->start_byte);
1322
1323   /*
1324    * Simple enqueue/deq and data validation (1)
1325    */
1326   svm_fifo_init_pointers (f, f->nitems / 2, f->nitems / 2);
1327   for (i = 0; i < test_n_bytes; i++)
1328     {
1329       rv = svm_fifo_enqueue (f, sizeof (u8), &test_data[i]);
1330       if (rv < 0)
1331         {
1332           clib_warning ("enqueue returned %d", rv);
1333           goto cleanup;
1334         }
1335     }
1336
1337   SFIFO_TEST (svm_fifo_max_dequeue (f) == test_n_bytes, "max deq expected %u "
1338               "is %u", test_n_bytes, svm_fifo_max_dequeue (f));
1339
1340   for (i = 0; i < test_n_bytes; i++)
1341     svm_fifo_dequeue (f, 1, &data_buf[i]);
1342
1343   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1344                      (u32 *) & j);
1345   if (rv)
1346     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
1347                      test_data[j]);
1348   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
1349
1350   /*
1351    * Simple enqueue/deq and data validation (2)
1352    */
1353   for (i = 0; i <= n_enqs; i++)
1354     {
1355       rv = svm_fifo_enqueue (f, enq_bytes, test_data + i * enq_bytes);
1356       if (rv < 0)
1357         {
1358           clib_warning ("enqueue returned %d", rv);
1359           goto cleanup;
1360         }
1361     }
1362
1363   SFIFO_TEST (svm_fifo_max_dequeue (f) == test_n_bytes, "max deq expected %u "
1364               "is %u", test_n_bytes, svm_fifo_max_dequeue (f));
1365
1366   for (i = 0; i <= n_deqs; i++)
1367     svm_fifo_dequeue (f, deq_bytes, data_buf + i * deq_bytes);
1368
1369   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1370                      (u32 *) & j);
1371   if (rv)
1372     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
1373                      test_data[j]);
1374   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
1375
1376   /*
1377    * OOO enqueues/dequeues and data validation (1)
1378    */
1379   for (i = test_n_bytes - 1; i > 0; i--)
1380     {
1381       rv = svm_fifo_enqueue_with_offset (f, i, sizeof (u8), &test_data[i]);
1382       if (verbose)
1383         vlib_cli_output (vm, "add [%d] [%d, %d]", i, i, i + sizeof (u8));
1384       if (rv)
1385         {
1386           clib_warning ("enqueue returned %d", rv);
1387           goto cleanup;
1388         }
1389     }
1390
1391   SFIFO_TEST (svm_fifo_max_dequeue (f) == 0, "max deq expected %u is %u",
1392               0, svm_fifo_max_dequeue (f));
1393
1394   svm_fifo_enqueue (f, sizeof (u8), &test_data[0]);
1395
1396   memset (data_buf, 0, vec_len (data_buf));
1397   for (i = 0; i <= n_deqs; i++)
1398     svm_fifo_dequeue (f, deq_bytes, data_buf + i * deq_bytes);
1399
1400   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1401                      (u32 *) & j);
1402   if (rv)
1403     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
1404                      test_data[j]);
1405   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
1406
1407   /*
1408    * OOO enqueues/dequeues and data validation (2)
1409    */
1410
1411   for (i = n_enqs; i > 0; i--)
1412     {
1413       u32 enq_now = clib_min (enq_bytes, vec_len (test_data) - i * enq_bytes);
1414       rv = svm_fifo_enqueue_with_offset (f, i * enq_bytes, enq_now,
1415                                          test_data + i * enq_bytes);
1416       if (verbose)
1417         vlib_cli_output (vm, "add [%d, %d]", i * enq_bytes,
1418                          i * enq_bytes + enq_now);
1419       if (rv)
1420         {
1421           clib_warning ("enqueue returned %d", rv);
1422           goto cleanup;
1423         }
1424     }
1425
1426   svm_fifo_enqueue (f, enq_bytes, &test_data[0]);
1427
1428   memset (data_buf, 0, vec_len (data_buf));
1429   for (i = 0; i <= n_deqs; i++)
1430     svm_fifo_dequeue (f, deq_bytes, data_buf + i * deq_bytes);
1431
1432   rv = compare_data (data_buf, test_data, 0, vec_len (test_data),
1433                      (u32 *) & j);
1434   if (rv)
1435     vlib_cli_output (vm, "[%d] dequeued %u expected %u", j, data_buf[j],
1436                      test_data[j]);
1437   SFIFO_TEST ((rv == 0), "dequeued compared to original returned %d", rv);
1438
1439   /*
1440    * Cleanup
1441    */
1442
1443 cleanup:
1444
1445   c = f->start_chunk->next;
1446   while (c && c != f->start_chunk)
1447     {
1448       next = c->next;
1449       clib_mem_free (c);
1450       c = next;
1451     }
1452
1453   svm_fifo_free (f);
1454
1455   vec_free (data_buf);
1456   return 0;
1457 }
1458
1459 /* *INDENT-OFF* */
1460 svm_fifo_trace_elem_t fifo_trace[] = {};
1461 /* *INDENT-ON* */
1462
1463 static int
1464 sfifo_test_fifo_replay (vlib_main_t * vm, unformat_input_t * input)
1465 {
1466   svm_fifo_t f;
1467   int verbose = 0;
1468   u8 no_read = 0, *str = 0;
1469
1470   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1471     {
1472       if (unformat (input, "verbose"))
1473         verbose = 1;
1474       else if (unformat (input, "no-read"))
1475         no_read = 1;
1476       else
1477         {
1478           clib_error_t *e = clib_error_return
1479             (0, "unknown input `%U'", format_unformat_error, input);
1480           clib_error_report (e);
1481           return -1;
1482         }
1483     }
1484
1485 #if SVMF_FIFO_TRACE
1486   f.trace = fifo_trace;
1487 #endif
1488
1489   str = svm_fifo_replay (str, &f, no_read, verbose);
1490   vlib_cli_output (vm, "%v", str);
1491   return 0;
1492 }
1493
1494 static fifo_segment_main_t segment_main;
1495
1496 static int
1497 sfifo_test_fifo_segment_hello_world (int verbose)
1498 {
1499   fifo_segment_create_args_t _a, *a = &_a;
1500   fifo_segment_main_t *sm = &segment_main;
1501   u8 *test_data, *retrieved_data = 0;
1502   fifo_segment_t *fs;
1503   svm_fifo_t *f;
1504   int rv;
1505
1506   clib_memset (a, 0, sizeof (*a));
1507   a->segment_name = "fifo-test1";
1508   a->segment_size = 256 << 10;
1509
1510   rv = fifo_segment_create (sm, a);
1511
1512   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
1513
1514   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
1515   f = fifo_segment_alloc_fifo (fs, 4096, FIFO_SEGMENT_RX_FIFO);
1516
1517   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo");
1518
1519   test_data = format (0, "Hello world%c", 0);
1520   vec_validate (retrieved_data, vec_len (test_data) - 1);
1521
1522   while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
1523     svm_fifo_enqueue (f, vec_len (test_data), test_data);
1524
1525   while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
1526     svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
1527
1528   while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
1529     svm_fifo_enqueue (f, vec_len (test_data), test_data);
1530
1531   while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
1532     svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
1533
1534   SFIFO_TEST (!memcmp (retrieved_data, test_data, vec_len (test_data)),
1535               "data should be identical");
1536
1537   vec_free (test_data);
1538   vec_free (retrieved_data);
1539   vec_free (a->new_segment_indices);
1540   fifo_segment_free_fifo (fs, f);
1541   fifo_segment_delete (sm, fs);
1542   return 0;
1543 }
1544
1545 static int
1546 sfifo_test_fifo_segment_fifo_grow (int verbose)
1547 {
1548   fifo_segment_main_t *sm = &segment_main;
1549   fifo_segment_create_args_t _a, *a = &_a;
1550   int rv, fifo_size = 4096, n_chunks;
1551   fifo_segment_t *fs;
1552   svm_fifo_t *f;
1553
1554   clib_memset (a, 0, sizeof (*a));
1555   a->segment_name = "fifo-test1";
1556   a->segment_size = 256 << 10;
1557
1558   rv = fifo_segment_create (sm, a);
1559
1560   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
1561
1562   /*
1563    * Alloc and grow fifo
1564    */
1565   fs = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
1566   f = fifo_segment_alloc_fifo (fs, fifo_size, FIFO_SEGMENT_RX_FIFO);
1567
1568   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo");
1569
1570   fifo_segment_grow_fifo (fs, f, fifo_size);
1571   SFIFO_TEST (f->size == 2 * fifo_size, "fifo size should be %u is %u",
1572               2 * fifo_size, f->size);
1573
1574   fifo_segment_grow_fifo (fs, f, 16 * fifo_size);
1575   SFIFO_TEST (f->size == 18 * fifo_size, "fifo size should be %u is %u",
1576               18 * fifo_size, f->size);
1577
1578   /*
1579    * Free and test free list size
1580    */
1581   fifo_segment_free_fifo (fs, f);
1582
1583   n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
1584   SFIFO_TEST (n_chunks == 1, "free 2^10B chunks should be %u is %u", 1,
1585               n_chunks);
1586   n_chunks = fifo_segment_num_free_chunks (fs, 16 * fifo_size);
1587   SFIFO_TEST (n_chunks == 1, "free 2^14B chunks should be %u is %u", 1,
1588               n_chunks);
1589   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
1590   SFIFO_TEST (n_chunks == 2, "free chunks should be %u is %u", 2, n_chunks);
1591
1592   /*
1593    * Realloc fifo
1594    */
1595   f = fifo_segment_alloc_fifo (fs, fifo_size, FIFO_SEGMENT_RX_FIFO);
1596
1597   fifo_segment_grow_fifo (fs, f, fifo_size);
1598   n_chunks = fifo_segment_num_free_chunks (fs, fifo_size);
1599   SFIFO_TEST (n_chunks == 0, "free 2^10B chunks should be %u is %u", 0,
1600               n_chunks);
1601
1602   fifo_segment_grow_fifo (fs, f, 16 * fifo_size);
1603   SFIFO_TEST (n_chunks == 0, "free 2^14B chunks should be %u is %u", 0,
1604               n_chunks);
1605   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
1606   SFIFO_TEST (n_chunks == 0, "free chunks should be %u is %u", 0, n_chunks);
1607
1608   /*
1609    * Free again
1610    */
1611   fifo_segment_free_fifo (fs, f);
1612   n_chunks = fifo_segment_num_free_chunks (fs, ~0);
1613   SFIFO_TEST (n_chunks == 2, "free chunks should be %u is %u", 2, n_chunks);
1614
1615   /*
1616    * Cleanup
1617    */
1618   fifo_segment_delete (sm, fs);
1619   vec_free (a->new_segment_indices);
1620   return 0;
1621 }
1622
1623 static int
1624 sfifo_test_fifo_segment_slave (int verbose)
1625 {
1626   fifo_segment_create_args_t _a, *a = &_a;
1627   fifo_segment_main_t *sm = &segment_main;
1628   u8 *test_data, *retrieved_data = 0;
1629   fifo_segment_t *sp;
1630   fifo_segment_header_t *fsh;
1631   ssvm_shared_header_t *sh;
1632   svm_fifo_t *f;
1633   u32 *result;
1634   int rv, i;
1635
1636   sleep (2);
1637
1638   sm->timeout_in_seconds = 5;
1639   clib_memset (a, 0, sizeof (*a));
1640   a->segment_name = "fifo-test1";
1641
1642   rv = fifo_segment_attach (sm, a);
1643
1644   SFIFO_TEST (!rv, "svm_fifo_segment_attach returned %d", rv);
1645
1646   sp = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
1647   vec_free (a->new_segment_indices);
1648   sh = sp->ssvm.sh;
1649   fsh = (fifo_segment_header_t *) sh->opaque[0];
1650
1651   /* might wanna wait.. */
1652   f = fsh->fifos;
1653
1654   /* Lazy bastards united */
1655   test_data = format (0, "Hello world%c", 0);
1656   vec_validate (retrieved_data, vec_len (test_data) - 1);
1657
1658   for (i = 0; i < 1000; i++)
1659     {
1660       svm_fifo_dequeue (f, vec_len (retrieved_data), retrieved_data);
1661       if (memcmp (retrieved_data, test_data, vec_len (retrieved_data)))
1662         {
1663           result = (u32 *) f->head_chunk->data;
1664           *result = 1;
1665           _exit (0);
1666         }
1667     }
1668
1669   result = (u32 *) f->head_chunk->data;
1670   *result = 0;
1671
1672   vec_free (test_data);
1673   vec_free (retrieved_data);
1674   _exit (0);
1675 }
1676
1677 static int
1678 sfifo_test_fifo_segment_master_slave (int verbose)
1679 {
1680   fifo_segment_create_args_t _a, *a = &_a;
1681   fifo_segment_main_t *sm = &segment_main;
1682   fifo_segment_t *sp;
1683   svm_fifo_t *f;
1684   u8 *test_data;
1685   u32 *result;
1686   int rv, i;
1687   pid_t pid;
1688
1689   pid = fork ();
1690   if (pid < 0)
1691     SFIFO_TEST (0, "fork failed");
1692
1693   if (!pid)
1694     sfifo_test_fifo_segment_slave (verbose);
1695
1696   clib_memset (a, 0, sizeof (*a));
1697   a->segment_name = "fifo-test1";
1698   a->segment_size = 256 << 10;
1699
1700   rv = fifo_segment_create (sm, a);
1701
1702   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
1703
1704   sp = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
1705   f = fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FIFO);
1706
1707   SFIFO_TEST (f != 0, "svm_fifo_segment_alloc_fifo alloc");
1708
1709   test_data = format (0, "Hello world%c", 0);
1710
1711   usleep (200e3);
1712
1713   for (i = 0; i < 1000; i++)
1714     svm_fifo_enqueue (f, vec_len (test_data), test_data);
1715
1716   /* Wait for slave */
1717   i = 0;
1718   while (svm_fifo_max_dequeue (f) && i++ < 1e10)
1719     ;
1720
1721   usleep (1e3);
1722
1723   result = (u32 *) f->head_chunk->data;
1724   SFIFO_TEST (*result == 0, "slave reported no error");
1725
1726   vec_free (a->new_segment_indices);
1727   vec_free (test_data);
1728   fifo_segment_free_fifo (sp, f);
1729   fifo_segment_delete (sm, sp);
1730   return 0;
1731 }
1732
1733 static int
1734 sfifo_test_fifo_segment_mempig (int verbose)
1735 {
1736   fifo_segment_create_args_t _a, *a = &_a;
1737   fifo_segment_main_t *sm = &segment_main;
1738   fifo_segment_t *sp;
1739   svm_fifo_t *f;
1740   svm_fifo_t **flist = 0;
1741   int rv;
1742   int i;
1743
1744   clib_memset (a, 0, sizeof (*a));
1745
1746   a->segment_name = "fifo-test1";
1747   a->segment_size = 256 << 10;
1748
1749   rv = fifo_segment_create (sm, a);
1750
1751   SFIFO_TEST (!rv, "svm_fifo_segment_create returned %d", rv);
1752
1753   sp = fifo_segment_get_segment (sm, a->new_segment_indices[0]);
1754
1755   for (i = 0; i < 1000; i++)
1756     {
1757       f = fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FIFO);
1758       if (f == 0)
1759         break;
1760       vec_add1 (flist, f);
1761     }
1762
1763   SFIFO_TEST (vec_len (flist), "created %d fifos", vec_len (flist));
1764
1765   for (i = 0; i < vec_len (flist); i++)
1766     {
1767       f = flist[i];
1768       fifo_segment_free_fifo (sp, f);
1769     }
1770
1771   _vec_len (flist) = 0;
1772
1773   for (i = 0; i < 1000; i++)
1774     {
1775       f = fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FIFO);
1776       if (f == 0)
1777         break;
1778       vec_add1 (flist, f);
1779     }
1780
1781   SFIFO_TEST (vec_len (flist), "second try created %d fifos",
1782               vec_len (flist));
1783   for (i = 0; i < vec_len (flist); i++)
1784     {
1785       f = flist[i];
1786       fifo_segment_free_fifo (sp, f);
1787     }
1788
1789   fifo_segment_delete (sm, sp);
1790   return 0;
1791 }
1792
1793 static int
1794 sfifo_test_fifo_segment (vlib_main_t * vm, unformat_input_t * input)
1795 {
1796   int rv, verbose = 0;
1797
1798   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1799     {
1800       if (unformat (input, "verbose"))
1801         verbose = 1;
1802       else if (unformat (input, "masterslave"))
1803         {
1804           if ((rv = sfifo_test_fifo_segment_master_slave (verbose)))
1805             return -1;
1806         }
1807       else if (unformat (input, "basic"))
1808         {
1809           if ((rv = sfifo_test_fifo_segment_hello_world (verbose)))
1810             return -1;
1811         }
1812       else if (unformat (input, "mempig"))
1813         {
1814           if ((rv = sfifo_test_fifo_segment_mempig (verbose)))
1815             return -1;
1816         }
1817       else if (unformat (input, "grow fifo"))
1818         {
1819           if ((rv = sfifo_test_fifo_segment_fifo_grow (verbose)))
1820             return -1;
1821         }
1822       else if (unformat (input, "all"))
1823         {
1824           if ((rv = sfifo_test_fifo_segment_hello_world (verbose)))
1825             return -1;
1826           if ((rv = sfifo_test_fifo_segment_mempig (verbose)))
1827             return -1;
1828           if ((rv = sfifo_test_fifo_segment_fifo_grow (verbose)))
1829             return -1;
1830           /* Pretty slow so avoid running it always
1831              if ((rv = sfifo_test_fifo_segment_master_slave (verbose)))
1832              return -1;
1833            */
1834         }
1835       else
1836         {
1837           vlib_cli_output (vm, "parse error: '%U'", format_unformat_error,
1838                            input);
1839           return -1;
1840         }
1841     }
1842   return 0;
1843 }
1844
1845 static clib_error_t *
1846 svm_fifo_test (vlib_main_t * vm, unformat_input_t * input,
1847                vlib_cli_command_t * cmd_arg)
1848 {
1849   int res = 0;
1850   char *str;
1851
1852   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1853     {
1854       if (unformat (input, "fifo1"))
1855         res = sfifo_test_fifo1 (vm, input);
1856       else if (unformat (input, "fifo2"))
1857         res = sfifo_test_fifo2 (vm);
1858       else if (unformat (input, "fifo3"))
1859         res = sfifo_test_fifo3 (vm, input);
1860       else if (unformat (input, "fifo4"))
1861         res = sfifo_test_fifo4 (vm, input);
1862       else if (unformat (input, "fifo5"))
1863         res = sfifo_test_fifo5 (vm, input);
1864       else if (unformat (input, "fifo6"))
1865         res = sfifo_test_fifo6 (vm, input);
1866       else if (unformat (input, "fifo7"))
1867         res = sfifo_test_fifo7 (vm, input);
1868       else if (unformat (input, "large"))
1869         res = sfifo_test_fifo_large (vm, input);
1870       else if (unformat (input, "replay"))
1871         res = sfifo_test_fifo_replay (vm, input);
1872       else if (unformat (input, "grow"))
1873         res = sfifo_test_fifo_grow (vm, input);
1874       else if (unformat (input, "segment"))
1875         res = sfifo_test_fifo_segment (vm, input);
1876       else if (unformat (input, "all"))
1877         {
1878           if ((res = sfifo_test_fifo1 (vm, input)))
1879             goto done;
1880
1881           if ((res = sfifo_test_fifo2 (vm)))
1882             goto done;
1883
1884           /*
1885            * Run a number of fifo3 configs
1886            */
1887           str = "nsegs 10 overlap seed 123";
1888           unformat_init_cstring (input, str);
1889           if ((res = sfifo_test_fifo3 (vm, input)))
1890             goto done;
1891           unformat_free (input);
1892
1893           str = "nsegs 10 overlap seed 123 in-seq-all";
1894           unformat_init_cstring (input, str);
1895           if ((res = sfifo_test_fifo3 (vm, input)))
1896             goto done;
1897           unformat_free (input);
1898
1899           str = "nsegs 10 overlap seed 123 initial-offset 3917";
1900           unformat_init_cstring (input, str);
1901           if ((res = sfifo_test_fifo3 (vm, input)))
1902             goto done;
1903           unformat_free (input);
1904
1905           str = "nsegs 10 overlap seed 123 initial-offset 3917 drop";
1906           unformat_init_cstring (input, str);
1907           if ((res = sfifo_test_fifo3 (vm, input)))
1908             goto done;
1909           unformat_free (input);
1910
1911           str = "nsegs 10 seed 123 initial-offset 3917 drop no-randomize";
1912           unformat_init_cstring (input, str);
1913           if ((res = sfifo_test_fifo3 (vm, input)))
1914             goto done;
1915           unformat_free (input);
1916
1917           if ((res = sfifo_test_fifo4 (vm, input)))
1918             goto done;
1919
1920           if ((res = sfifo_test_fifo5 (vm, input)))
1921             goto done;
1922
1923           if ((res = sfifo_test_fifo6 (vm, input)))
1924             goto done;
1925
1926           if ((res = sfifo_test_fifo7 (vm, input)))
1927             goto done;
1928
1929           if ((res = sfifo_test_fifo_grow (vm, input)))
1930             goto done;
1931
1932           str = "all";
1933           unformat_init_cstring (input, str);
1934           if ((res = sfifo_test_fifo_segment (vm, input)))
1935             goto done;
1936         }
1937       else
1938         {
1939           vlib_cli_output (vm, "unknown input `%U'", format_unformat_error,
1940                            input);
1941           res = -1;
1942           goto done;
1943         }
1944
1945     }
1946
1947 done:
1948   if (res)
1949     return clib_error_return (0, "svm fifo unit test failed");
1950   return 0;
1951 }
1952
1953 /* *INDENT-OFF* */
1954 VLIB_CLI_COMMAND (svm_fifo_test_command, static) =
1955 {
1956   .path = "test svm fifo",
1957   .short_help = "internal svm fifo unit tests",
1958   .function = svm_fifo_test,
1959 };
1960 /* *INDENT-ON* */
1961
1962 /*
1963  * fd.io coding-style-patch-verification: ON
1964  *
1965  * Local Variables:
1966  * eval: (c-set-style "gnu")
1967  * End:
1968  */