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