src/svm/test_svm_fifo1.c

   1 /*
   2  * Copyright (c) 2016-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
  16 #include "svm_fifo_segment.h"
  17
  18 svm_fifo_segment_main_t segment_main;
  19
  20 clib_error_t *
  21 hello_world (int verbose)
  22 {
  23   svm_fifo_segment_create_args_t _a, *a = &_a;
  24   svm_fifo_segment_main_t *sm = &segment_main;
  25   svm_fifo_segment_private_t *sp;
  26   svm_fifo_t *f;
  27   int rv;
  28   u8 *test_data;
  29   u8 *retrieved_data = 0;
  30   clib_error_t *error = 0;
  31
  32   clib_memset (a, 0, sizeof (*a));
  33
  34   a->segment_name = "fifo-test1";
  35   a->segment_size = 256 << 10;
  36
  37   rv = svm_fifo_segment_create (sm, a);
  38
  39   if (rv)
  40     return clib_error_return (0, "svm_fifo_segment_create returned %d", rv);
  41
  42   sp = svm_fifo_segment_get_segment (sm, a->new_segment_indices[0]);
  43
  44   f = svm_fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FREELIST);
  45
  46   if (f == 0)
  47     return clib_error_return (0, "svm_fifo_segment_alloc_fifo failed");
  48
  49   test_data = format (0, "Hello world%c", 0);
  50   vec_validate (retrieved_data, vec_len (test_data) - 1);
  51
  52   while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
  53     svm_fifo_enqueue_nowait (f, vec_len (test_data), test_data);
  54
  55   while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
  56     svm_fifo_dequeue_nowait (f, vec_len (retrieved_data), retrieved_data);
  57
  58   while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
  59     svm_fifo_enqueue_nowait (f, vec_len (test_data), test_data);
  60
  61   while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
  62     svm_fifo_dequeue_nowait (f, vec_len (retrieved_data), retrieved_data);
  63
  64   if (!memcmp (retrieved_data, test_data, vec_len (test_data)))
  65     error = clib_error_return (0, "data test OK, got '%s'", retrieved_data);
  66   else
  67     error = clib_error_return (0, "data test FAIL!");
  68
  69   svm_fifo_segment_free_fifo (sp, f, FIFO_SEGMENT_RX_FREELIST);
  70
  71   return error;
  72 }
  73
  74 clib_error_t *
  75 master (int verbose)
  76 {
  77   svm_fifo_segment_create_args_t _a, *a = &_a;
  78   svm_fifo_segment_main_t *sm = &segment_main;
  79   svm_fifo_segment_private_t *sp;
  80   svm_fifo_t *f;
  81   int rv;
  82   u8 *test_data;
  83   u8 *retrieved_data = 0;
  84   int i;
  85
  86   clib_memset (a, 0, sizeof (*a));
  87
  88   a->segment_name = "fifo-test1";
  89   a->segment_size = 256 << 10;
  90
  91   rv = svm_fifo_segment_create (sm, a);
  92
  93   if (rv)
  94     return clib_error_return (0, "svm_fifo_segment_create returned %d", rv);
  95
  96   sp = svm_fifo_segment_get_segment (sm, a->new_segment_indices[0]);
  97
  98   f = svm_fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FREELIST);
  99
 100   if (f == 0)
 101     return clib_error_return (0, "svm_fifo_segment_alloc_fifo failed");
 102
 103   test_data = format (0, "Hello world%c", 0);
 104   vec_validate (retrieved_data, vec_len (test_data) - 1);
 105
 106   for (i = 0; i < 1000; i++)
 107     svm_fifo_enqueue_nowait (f, vec_len (test_data), test_data);
 108
 109   return clib_error_return (0, "master (enqueue) done");
 110 }
 111
 112 clib_error_t *
 113 mempig (int verbose)
 114 {
 115   svm_fifo_segment_create_args_t _a, *a = &_a;
 116   svm_fifo_segment_main_t *sm = &segment_main;
 117   svm_fifo_segment_private_t *sp;
 118   svm_fifo_t *f;
 119   svm_fifo_t **flist = 0;
 120   int rv;
 121   int i;
 122
 123   clib_memset (a, 0, sizeof (*a));
 124
 125   a->segment_name = "fifo-test1";
 126   a->segment_size = 256 << 10;
 127
 128   rv = svm_fifo_segment_create (sm, a);
 129
 130   if (rv)
 131     return clib_error_return (0, "svm_fifo_segment_create returned %d", rv);
 132
 133   sp = svm_fifo_segment_get_segment (sm, a->new_segment_indices[0]);
 134
 135   for (i = 0; i < 1000; i++)
 136     {
 137       f = svm_fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FREELIST);
 138       if (f == 0)
 139         break;
 140       vec_add1 (flist, f);
 141     }
 142
 143   fformat (stdout, "Try #1: created %d fifos...\n", vec_len (flist));
 144   for (i = 0; i < vec_len (flist); i++)
 145     {
 146       f = flist[i];
 147       svm_fifo_segment_free_fifo (sp, f, FIFO_SEGMENT_RX_FREELIST);
 148     }
 149
 150   _vec_len (flist) = 0;
 151
 152   for (i = 0; i < 1000; i++)
 153     {
 154       f = svm_fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FREELIST);
 155       if (f == 0)
 156         break;
 157       vec_add1 (flist, f);
 158     }
 159
 160   fformat (stdout, "Try #2: created %d fifos...\n", vec_len (flist));
 161   for (i = 0; i < vec_len (flist); i++)
 162     {
 163       f = flist[i];
 164       svm_fifo_segment_free_fifo (sp, f, FIFO_SEGMENT_RX_FREELIST);
 165     }
 166
 167   return 0;
 168 }
 169
 170 clib_error_t *
 171 offset (int verbose)
 172 {
 173   svm_fifo_segment_create_args_t _a, *a = &_a;
 174   svm_fifo_segment_main_t *sm = &segment_main;
 175   svm_fifo_segment_private_t *sp;
 176   svm_fifo_t *f;
 177   int rv;
 178   u32 *test_data = 0;
 179   u32 *recovered_data = 0;
 180   int i;
 181
 182   clib_memset (a, 0, sizeof (*a));
 183
 184   a->segment_name = "fifo-test1";
 185   a->segment_size = 256 << 10;
 186
 187   rv = svm_fifo_segment_create (sm, a);
 188
 189   if (rv)
 190     return clib_error_return (0, "svm_fifo_segment_create returned %d", rv);
 191
 192   sp = svm_fifo_segment_get_segment (sm, a->new_segment_indices[0]);
 193
 194   f = svm_fifo_segment_alloc_fifo (sp, 200 << 10, FIFO_SEGMENT_RX_FREELIST);
 195
 196   if (f == 0)
 197     return clib_error_return (0, "svm_fifo_segment_alloc_fifo failed");
 198
 199   for (i = 0; i < (3 * 1024); i++)
 200     vec_add1 (test_data, i);
 201
 202   /* Enqueue the first 1024 u32's */
 203   svm_fifo_enqueue_nowait (f, 4096 /* bytes to enqueue */ ,
 204                            (u8 *) test_data);
 205
 206   /* Enqueue the third 1024 u32's 2048 ahead of the current tail */
 207   svm_fifo_enqueue_with_offset (f, 4096, 4096, (u8 *) & test_data[2048]);
 208
 209   /* Enqueue the second 1024 u32's at the current tail */
 210   svm_fifo_enqueue_nowait (f, 4096 /* bytes to enqueue */ ,
 211                            (u8 *) & test_data[1024]);
 212
 213   vec_validate (recovered_data, (3 * 1024) - 1);
 214
 215   svm_fifo_dequeue_nowait (f, 3 * 4096, (u8 *) recovered_data);
 216
 217   for (i = 0; i < (3 * 1024); i++)
 218     {
 219       if (recovered_data[i] != test_data[i])
 220         {
 221           clib_warning ("[%d] expected %d recovered %d", i,
 222                         test_data[i], recovered_data[i]);
 223           return clib_error_return (0, "offset test FAILED");
 224         }
 225     }
 226
 227   return clib_error_return (0, "offset test OK");
 228 }
 229
 230 clib_error_t *
 231 slave (int verbose)
 232 {
 233   svm_fifo_segment_create_args_t _a, *a = &_a;
 234   svm_fifo_segment_main_t *sm = &segment_main;
 235   svm_fifo_segment_private_t *sp;
 236   svm_fifo_t *f;
 237   ssvm_shared_header_t *sh;
 238   svm_fifo_segment_header_t *fsh;
 239   int rv;
 240   u8 *test_data;
 241   u8 *retrieved_data = 0;
 242   int i;
 243
 244   clib_memset (a, 0, sizeof (*a));
 245
 246   a->segment_name = "fifo-test1";
 247
 248   rv = svm_fifo_segment_attach (a);
 249
 250   if (rv)
 251     return clib_error_return (0, "svm_fifo_segment_attach returned %d", rv);
 252
 253   sp = svm_fifo_segment_get_segment (sm, a->new_segment_indices[0]);
 254   sh = sp->ssvm.sh;
 255   fsh = (svm_fifo_segment_header_t *) sh->opaque[0];
 256
 257   /* might wanna wait.. */
 258   f = fsh->fifos;
 259
 260   /* Lazy bastards united */
 261   test_data = format (0, "Hello world%c", 0);
 262   vec_validate (retrieved_data, vec_len (test_data) - 1);
 263
 264   for (i = 0; i < 1000; i++)
 265     {
 266       svm_fifo_dequeue_nowait (f, vec_len (retrieved_data), retrieved_data);
 267       if (memcmp (retrieved_data, test_data, vec_len (retrieved_data)))
 268         return clib_error_return (0, "retrieved data incorrect, '%s'",
 269                                   retrieved_data);
 270     }
 271
 272   return clib_error_return (0, "slave (dequeue) done");
 273 }
 274
 275
 276 int
 277 test_ssvm_fifo1 (unformat_input_t * input)
 278 {
 279   svm_fifo_segment_main_t *sm = &segment_main;
 280   clib_error_t *error = 0;
 281   int verbose = 0;
 282   int test_id = 0;
 283
 284   svm_fifo_segment_main_init (sm, HIGH_SEGMENT_BASEVA, 20);
 285
 286   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 287     {
 288       if (unformat (input, "verbose %d", &verbose))
 289         ;
 290       else if (unformat (input, "verbose"))
 291         verbose = 1;
 292       else if (unformat (input, "master"))
 293         test_id = 1;
 294       else if (unformat (input, "slave"))
 295         test_id = 2;
 296       else if (unformat (input, "mempig"))
 297         test_id = 3;
 298       else if (unformat (input, "offset"))
 299         test_id = 4;
 300       else
 301         {
 302           error = clib_error_create ("unknown input `%U'\n",
 303                                      format_unformat_error, input);
 304           goto out;
 305         }
 306     }
 307
 308   switch (test_id)
 309     {
 310     case 0:
 311       error = hello_world (verbose);
 312       break;
 313
 314     case 1:
 315       error = master (verbose);
 316       break;
 317
 318     case 2:
 319       error = slave (verbose);
 320       break;
 321
 322     case 3:
 323       error = mempig (verbose);
 324       break;
 325
 326     case 4:
 327       error = offset (verbose);
 328       break;
 329
 330     default:
 331       error = clib_error_return (0, "test id %d unknown", test_id);
 332       break;
 333     }
 334
 335 out:
 336   if (error)
 337     clib_error_report (error);
 338
 339   return 0;
 340 }
 341
 342
 343
 344 int
 345 main (int argc, char *argv[])
 346 {
 347   unformat_input_t i;
 348   int r;
 349
 350   unformat_init_command_line (&i, argv);
 351   r = test_ssvm_fifo1 (&i);
 352   unformat_free (&i);
 353   return r;
 354 }
 355
 356 /*
 357  * fd.io coding-style-patch-verification: ON
 358  *
 359  * Local Variables:
 360  * eval: (c-set-style "gnu")
 361  * End:
 362  */