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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 #include "svm_fifo_segment.h"
18 svm_fifo_segment_main_t segment_main;
21 hello_world (int verbose)
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;
29 u8 *retrieved_data = 0;
30 clib_error_t *error = 0;
32 clib_memset (a, 0, sizeof (*a));
34 a->segment_name = "fifo-test1";
35 a->segment_size = 256 << 10;
37 rv = svm_fifo_segment_create (sm, a);
40 return clib_error_return (0, "svm_fifo_segment_create returned %d", rv);
42 sp = svm_fifo_segment_get_segment (sm, a->new_segment_indices[0]);
44 f = svm_fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FREELIST);
47 return clib_error_return (0, "svm_fifo_segment_alloc_fifo failed");
49 test_data = format (0, "Hello world%c", 0);
50 vec_validate (retrieved_data, vec_len (test_data) - 1);
52 while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
53 svm_fifo_enqueue_nowait (f, vec_len (test_data), test_data);
55 while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
56 svm_fifo_dequeue_nowait (f, vec_len (retrieved_data), retrieved_data);
58 while (svm_fifo_max_enqueue (f) >= vec_len (test_data))
59 svm_fifo_enqueue_nowait (f, vec_len (test_data), test_data);
61 while (svm_fifo_max_dequeue (f) >= vec_len (test_data))
62 svm_fifo_dequeue_nowait (f, vec_len (retrieved_data), retrieved_data);
64 if (!memcmp (retrieved_data, test_data, vec_len (test_data)))
65 error = clib_error_return (0, "data test OK, got '%s'", retrieved_data);
67 error = clib_error_return (0, "data test FAIL!");
69 svm_fifo_segment_free_fifo (sp, f, FIFO_SEGMENT_RX_FREELIST);
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;
83 u8 *retrieved_data = 0;
86 clib_memset (a, 0, sizeof (*a));
88 a->segment_name = "fifo-test1";
89 a->segment_size = 256 << 10;
91 rv = svm_fifo_segment_create (sm, a);
94 return clib_error_return (0, "svm_fifo_segment_create returned %d", rv);
96 sp = svm_fifo_segment_get_segment (sm, a->new_segment_indices[0]);
98 f = svm_fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FREELIST);
101 return clib_error_return (0, "svm_fifo_segment_alloc_fifo failed");
103 test_data = format (0, "Hello world%c", 0);
104 vec_validate (retrieved_data, vec_len (test_data) - 1);
106 for (i = 0; i < 1000; i++)
107 svm_fifo_enqueue_nowait (f, vec_len (test_data), test_data);
109 return clib_error_return (0, "master (enqueue) done");
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;
119 svm_fifo_t **flist = 0;
123 clib_memset (a, 0, sizeof (*a));
125 a->segment_name = "fifo-test1";
126 a->segment_size = 256 << 10;
128 rv = svm_fifo_segment_create (sm, a);
131 return clib_error_return (0, "svm_fifo_segment_create returned %d", rv);
133 sp = svm_fifo_segment_get_segment (sm, a->new_segment_indices[0]);
135 for (i = 0; i < 1000; i++)
137 f = svm_fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FREELIST);
143 fformat (stdout, "Try #1: created %d fifos...\n", vec_len (flist));
144 for (i = 0; i < vec_len (flist); i++)
147 svm_fifo_segment_free_fifo (sp, f, FIFO_SEGMENT_RX_FREELIST);
150 _vec_len (flist) = 0;
152 for (i = 0; i < 1000; i++)
154 f = svm_fifo_segment_alloc_fifo (sp, 4096, FIFO_SEGMENT_RX_FREELIST);
160 fformat (stdout, "Try #2: created %d fifos...\n", vec_len (flist));
161 for (i = 0; i < vec_len (flist); i++)
164 svm_fifo_segment_free_fifo (sp, f, FIFO_SEGMENT_RX_FREELIST);
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;
179 u32 *recovered_data = 0;
182 clib_memset (a, 0, sizeof (*a));
184 a->segment_name = "fifo-test1";
185 a->segment_size = 256 << 10;
187 rv = svm_fifo_segment_create (sm, a);
190 return clib_error_return (0, "svm_fifo_segment_create returned %d", rv);
192 sp = svm_fifo_segment_get_segment (sm, a->new_segment_indices[0]);
194 f = svm_fifo_segment_alloc_fifo (sp, 200 << 10, FIFO_SEGMENT_RX_FREELIST);
197 return clib_error_return (0, "svm_fifo_segment_alloc_fifo failed");
199 for (i = 0; i < (3 * 1024); i++)
200 vec_add1 (test_data, i);
202 /* Enqueue the first 1024 u32's */
203 svm_fifo_enqueue_nowait (f, 4096 /* bytes to enqueue */ ,
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]);
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]);
213 vec_validate (recovered_data, (3 * 1024) - 1);
215 svm_fifo_dequeue_nowait (f, 3 * 4096, (u8 *) recovered_data);
217 for (i = 0; i < (3 * 1024); i++)
219 if (recovered_data[i] != test_data[i])
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");
227 return clib_error_return (0, "offset test OK");
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;
237 ssvm_shared_header_t *sh;
238 svm_fifo_segment_header_t *fsh;
241 u8 *retrieved_data = 0;
244 clib_memset (a, 0, sizeof (*a));
246 a->segment_name = "fifo-test1";
248 rv = svm_fifo_segment_attach (a);
251 return clib_error_return (0, "svm_fifo_segment_attach returned %d", rv);
253 sp = svm_fifo_segment_get_segment (sm, a->new_segment_indices[0]);
255 fsh = (svm_fifo_segment_header_t *) sh->opaque[0];
257 /* might wanna wait.. */
260 /* Lazy bastards united */
261 test_data = format (0, "Hello world%c", 0);
262 vec_validate (retrieved_data, vec_len (test_data) - 1);
264 for (i = 0; i < 1000; i++)
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'",
272 return clib_error_return (0, "slave (dequeue) done");
277 test_ssvm_fifo1 (unformat_input_t * input)
279 svm_fifo_segment_main_t *sm = &segment_main;
280 clib_error_t *error = 0;
284 svm_fifo_segment_main_init (sm, 0x200000000ULL, 20);
286 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
288 if (unformat (input, "verbose %d", &verbose))
290 else if (unformat (input, "verbose"))
292 else if (unformat (input, "master"))
294 else if (unformat (input, "slave"))
296 else if (unformat (input, "mempig"))
298 else if (unformat (input, "offset"))
302 error = clib_error_create ("unknown input `%U'\n",
303 format_unformat_error, input);
311 error = hello_world (verbose);
315 error = master (verbose);
319 error = slave (verbose);
323 error = mempig (verbose);
327 error = offset (verbose);
331 error = clib_error_return (0, "test id %d unknown", test_id);
337 clib_error_report (error);
345 main (int argc, char *argv[])
350 unformat_init_command_line (&i, argv);
351 r = test_ssvm_fifo1 (&i);
357 * fd.io coding-style-patch-verification: ON
360 * eval: (c-set-style "gnu")