2 * Copyright (c) 2015 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 Copyright (c) 2001, 2002, 2003 Eliot Dresselhaus
17 Written by Fred Delley <fdelley@cisco.com> .
19 Permission is hereby granted, free of charge, to any person obtaining
20 a copy of this software and associated documentation files (the
21 "Software"), to deal in the Software without restriction, including
22 without limitation the rights to use, copy, modify, merge, publish,
23 distribute, sublicense, and/or sell copies of the Software, and to
24 permit persons to whom the Software is furnished to do so, subject to
25 the following conditions:
27 The above copyright notice and this permission notice shall be
28 included in all copies or substantial portions of the Software.
30 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
31 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
32 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
33 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
34 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
35 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
36 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
39 #ifdef CLIB_LINUX_KERNEL
40 #include <linux/unistd.h>
49 #include <vppinfra/clib.h>
50 #include <vppinfra/format.h>
51 #include <vppinfra/error.h>
52 #include <vppinfra/random.h>
53 #include <vppinfra/time.h>
58 #define if_verbose(format,args...) \
59 if (verbose) { clib_warning(format, ## args); }
61 #define MAX_CHANGE 100
66 /* Values have to be sequential and start with 0. */
72 OP_IS_VEC_INSERT_ELTS,
84 /* Operations on vectors with custom headers. */
91 #define FIRST_VEC_OP OP_IS_VEC_RESIZE
92 #define LAST_VEC_OP OP_IS_VEC_PREPEND
93 #define FIRST_VEC_HDR_OP OP_IS_VEC_INIT_H
94 #define LAST_VEC_HDR_OP OP_IS_VEC_FREE_H
96 uword g_prob_ratio[] = {
97 [OP_IS_VEC_RESIZE] = 5,
101 [OP_IS_VEC_INSERT] = 5,
102 [OP_IS_VEC_INSERT_ELTS] = 5,
103 [OP_IS_VEC_DELETE] = 30,
105 [OP_IS_VEC_IS_EQUAL] = 5,
106 [OP_IS_VEC_ZERO] = 2,
108 [OP_IS_VEC_VALIDATE] = 5,
109 [OP_IS_VEC_FREE] = 5,
110 [OP_IS_VEC_INIT] = 5,
111 [OP_IS_VEC_CLONE] = 5,
112 [OP_IS_VEC_APPEND] = 5,
113 [OP_IS_VEC_PREPEND] = 5,
114 /* Operations on vectors with custom headers. */
115 [OP_IS_VEC_INIT_H] = 5,
116 [OP_IS_VEC_RESIZE_H] = 5,
117 [OP_IS_VEC_FREE_H] = 5,
123 uword g_call_stats[OP_MAX];
126 /* A structure for both vector headers and vector elements might be useful to
127 uncover potential alignement issues. */
132 CLIB_PACKED (u32 field2);
138 CLIB_PACKED (u32 field2);
142 u32 g_seed = 0xdeadbabe;
147 uword g_set_verbose_at = ~0;
148 uword g_dump_period = ~0;
152 format_vec_op_type (u8 * s, va_list * args)
154 op_t op = va_arg (*args, int);
160 s = format (s, "OP_IS_" #n); \
185 s = format (s, "Unknown vec op (%d)", op);
195 dump_call_stats (uword * stats)
199 fformat (stdout, "Call Stats\n----------\n");
201 for (i = 0; i < OP_MAX; i++)
202 fformat (stdout, "%-8d %U\n", stats[i], format_vec_op_type, i);
206 /* XXX - Purposely low value for debugging the validator. Will be set it to a
207 more sensible value later. */
208 #define MAX_VEC_LEN 10
210 #define create_random_vec_wh(elt_type, len, hdr_bytes, seed) \
212 elt_type * _v(v) = NULL; \
213 uword _v(l) = (len); \
214 uword _v(h) = (hdr_bytes); \
220 /* ~0 means select random length between 0 and MAX_VEC_LEN. */ \
222 _v(l) = bounded_random_u32 (&(seed), 0, MAX_VEC_LEN); \
224 _v(v) = _vec_resize (NULL, _v(l), _v(l) * sizeof (elt_type), _v(h), 0); \
225 fill_with_random_data (_v(v), vec_bytes (_v(v)), (seed)); \
227 /* Fill header with random data as well. */ \
230 _v(hdr) = vec_header (_v(v), _v(h)); \
231 fill_with_random_data (_v(hdr), _v(h), (seed)); \
238 #define create_random_vec(elt_type, len, seed) \
239 create_random_vec_wh (elt_type, len, 0, seed)
241 #define compute_vec_hash(hash, vec) \
243 u8 * _v(v) = (u8 *) (vec); \
244 uword _v(n) = vec_len (vec) * sizeof ((vec)[0]); \
245 u8 _v(hh) = (u8) (hash); \
247 compute_mem_hash (_v(hh), _v(v), _v(n)); \
251 validate_vec_free (elt_t * vec)
254 ASSERT (vec == NULL);
259 validate_vec_free_h (elt_t * vec, uword hdr_bytes)
261 vec_free_h (vec, hdr_bytes);
262 ASSERT (vec == NULL);
267 validate_vec_hdr (elt_t * vec, uword hdr_bytes)
276 vh = _vec_find (vec);
277 hdr = vec_header (vec, hdr_bytes);
278 hdr_end = vec_header_end (hdr, hdr_bytes);
280 ASSERT (hdr_end == (u8 *) vec);
281 ASSERT ((u8 *) vh - (u8 *) hdr >= hdr_bytes);
285 validate_vec_len (elt_t * vec)
298 end = (u8 *) vec_end (vec);
300 bytes = sizeof (vec[0]) * len;
302 ASSERT (bytes == vec_bytes (vec));
303 ASSERT ((ptr + bytes) == end);
307 /* XXX - TODO: confirm that auto-incrementing in vec_is_member() would not
308 have the expected result. */
309 while (vec_is_member (vec, (__typeof__ (vec[0]) *) ptr))
320 vec_foreach (elt, vec) i++;
326 validate_vec (elt_t * vec, uword hdr_bytes)
328 validate_vec_hdr (vec, hdr_bytes);
329 validate_vec_len (vec);
331 if (!vec || vec_len (vec) == 0)
333 VERBOSE3 ("Vector at %p has zero elements.\n\n", vec);
338 VERBOSE3 ("Header: %U\n",
339 format_hex_bytes, vec_header (vec, sizeof (vec[0])),
343 format_hex_bytes, vec, vec_len (vec) * sizeof (vec[0]));
348 validate_vec_resize (elt_t * vec, uword num_elts)
350 uword len1 = vec_len (vec);
352 u8 hash = compute_vec_hash (0, vec);
354 vec_resize (vec, num_elts);
355 len2 = vec_len (vec);
357 ASSERT (len2 == len1 + num_elts);
358 ASSERT (compute_vec_hash (hash, vec) == 0);
359 validate_vec (vec, 0);
364 validate_vec_resize_h (elt_t * vec, uword num_elts, uword hdr_bytes)
371 len1 = vec_len (vec);
374 hdr = vec_header (vec, hdr_bytes);
376 hash = compute_vec_hash (0, vec);
377 hdr_hash = compute_mem_hash (0, hdr, hdr_bytes);
379 vec_resize_ha (vec, num_elts, hdr_bytes, 0);
380 len2 = vec_len (vec);
382 ASSERT (len2 == len1 + num_elts);
384 end1 = (u8 *) (vec + len1);
385 end2 = (u8 *) vec_end (vec);
394 hdr = vec_header (vec, hdr_bytes);
396 ASSERT (compute_vec_hash (hash, vec) == 0);
397 ASSERT (compute_mem_hash (hdr_hash, hdr, hdr_bytes) == 0);
398 validate_vec (vec, 1);
403 generic_validate_vec_add (elt_t * vec, uword num_elts, uword is_add2)
405 uword len1 = vec_len (vec);
407 u8 hash = compute_vec_hash (0, vec);
412 vec_add2 (vec, new, num_elts);
416 new = create_random_vec (elt_t, num_elts, g_seed);
418 VERBOSE3 ("%U\n", format_hex_bytes, new,
419 vec_len (new) * sizeof (new[0]));
421 /* Add the hash value of the new elements to that of the old vector. */
422 hash = compute_vec_hash (hash, new);
425 vec_add1 (vec, new[0]);
426 else if (num_elts > 1)
427 vec_add (vec, new, num_elts);
432 len2 = vec_len (vec);
433 ASSERT (len2 == len1 + num_elts);
435 ASSERT (compute_vec_hash (hash, vec) == 0);
436 validate_vec (vec, 0);
441 validate_vec_add1 (elt_t * vec)
443 return generic_validate_vec_add (vec, 1, 0);
447 validate_vec_add2 (elt_t * vec, uword num_elts)
449 return generic_validate_vec_add (vec, num_elts, 1);
453 validate_vec_add (elt_t * vec, uword num_elts)
455 return generic_validate_vec_add (vec, num_elts, 0);
459 validate_vec_insert (elt_t * vec, uword num_elts, uword start_elt)
461 uword len1 = vec_len (vec);
465 /* vec_insert() would not handle it properly. */
466 if (start_elt > len1 || num_elts == 0)
469 hash = compute_vec_hash (0, vec);
470 vec_insert (vec, num_elts, start_elt);
471 len2 = vec_len (vec);
473 ASSERT (len2 == len1 + num_elts);
474 ASSERT (compute_vec_hash (hash, vec) == 0);
475 validate_vec (vec, 0);
480 validate_vec_insert_elts (elt_t * vec, uword num_elts, uword start_elt)
482 uword len1 = vec_len (vec);
487 /* vec_insert_elts() would not handle it properly. */
488 if (start_elt > len1 || num_elts == 0)
491 new = create_random_vec (elt_t, num_elts, g_seed);
493 VERBOSE3 ("%U\n", format_hex_bytes, new, vec_len (new) * sizeof (new[0]));
495 /* Add the hash value of the new elements to that of the old vector. */
496 hash = compute_vec_hash (0, vec);
497 hash = compute_vec_hash (hash, new);
499 vec_insert_elts (vec, new, num_elts, start_elt);
500 len2 = vec_len (vec);
504 ASSERT (len2 == len1 + num_elts);
505 ASSERT (compute_vec_hash (hash, vec) == 0);
506 validate_vec (vec, 0);
511 validate_vec_delete (elt_t * vec, uword num_elts, uword start_elt)
513 uword len1 = vec_len (vec);
519 /* vec_delete() would not handle it properly. */
520 if (start_elt + num_elts > len1)
523 start = (u8 *) vec + (start_elt * sizeof (vec[0]));
525 hash = compute_vec_hash (0, vec);
526 hash_del = compute_mem_hash (0, start, num_elts * sizeof (vec[0]));
529 vec_delete (vec, num_elts, start_elt);
530 len2 = vec_len (vec);
532 ASSERT (len2 == len1 - num_elts);
533 ASSERT (compute_vec_hash (hash, vec) == 0);
534 validate_vec (vec, 0);
539 validate_vec_dup (elt_t * vec)
544 hash = compute_vec_hash (0, vec);
547 ASSERT (compute_vec_hash (hash, new) == 0);
549 validate_vec (new, 0);
554 validate_vec_zero (elt_t * vec)
562 end = (u8 *) (vec + vec_len (vec));
566 ASSERT (ptr < (u8 *) vec_end (vec));
567 ASSERT (ptr[0] == 0);
571 validate_vec (vec, 0);
576 validate_vec_is_equal (elt_t * vec)
580 if (vec_len (vec) <= 0)
584 ASSERT (vec_is_equal (new, vec));
589 validate_vec_set (elt_t * vec)
592 uword len = vec_len (vec);
598 new = create_random_vec (elt_t, 1, g_seed);
600 VERBOSE3 ("%U\n", format_hex_bytes, new, vec_len (new) * sizeof (new[0]));
602 vec_set (vec, new[0]);
604 for (i = 0; i < len; i++)
605 ASSERT (memcmp (&vec[i], &new[0], sizeof (vec[0])) == 0);
608 validate_vec (vec, 0);
613 validate_vec_validate (elt_t * vec, uword index)
615 uword len = vec_len (vec);
616 word num_new = index - len + 1;
619 u8 hash = compute_vec_hash (0, vec);
624 vec_validate (vec, index);
626 /* Old len but new vec pointer! */
627 ptr = (u8 *) (vec + len);
628 end = (u8 *) (vec + len + num_new);
630 ASSERT (len + num_new == vec_len (vec));
631 ASSERT (compute_vec_hash (hash, vec) == 0);
635 ASSERT (ptr < (u8 *) vec_end (vec));
636 ASSERT (ptr[0] == 0);
640 validate_vec (vec, 0);
645 validate_vec_init (uword num_elts)
652 new = vec_new (elt_t, num_elts);
655 ASSERT (len == num_elts);
658 end = (u8 *) (new + len);
662 ASSERT (ptr < (u8 *) vec_end (new));
663 ASSERT (ptr[0] == 0);
667 validate_vec (new, 0);
672 validate_vec_init_h (uword num_elts, uword hdr_bytes)
680 new = vec_new_ha (elt_t, num_elts, hdr_bytes, 0);
683 ASSERT (len == num_elts);
685 /* We have 2 zero-regions to check: header & vec data (skip _VEC struct). */
686 for (i = 0; i < 2; i++)
690 ptr = (u8 *) vec_header (new, hdr_bytes);
691 end = ptr + hdr_bytes;
696 end = (u8 *) (new + len);
701 ASSERT (ptr < (u8 *) vec_end (new));
702 ASSERT (ptr[0] == 0);
707 validate_vec (new, 1);
711 /* XXX - I don't understand the purpose of the vec_clone() call. */
713 validate_vec_clone (elt_t * vec)
717 vec_clone (new, vec);
719 ASSERT (vec_len (new) == vec_len (vec));
720 ASSERT (compute_vec_hash (0, new) == 0);
721 validate_vec (new, 0);
726 validate_vec_append (elt_t * vec)
729 uword num_elts = bounded_random_u32 (&g_seed, 0, MAX_CHANGE);
733 new = create_random_vec (elt_t, num_elts, g_seed);
735 len = vec_len (vec) + vec_len (new);
736 hash = compute_vec_hash (0, vec);
737 hash = compute_vec_hash (hash, new);
739 vec_append (vec, new);
742 ASSERT (vec_len (vec) == len);
743 ASSERT (compute_vec_hash (hash, vec) == 0);
744 validate_vec (vec, 0);
749 validate_vec_prepend (elt_t * vec)
752 uword num_elts = bounded_random_u32 (&g_seed, 0, MAX_CHANGE);
756 new = create_random_vec (elt_t, num_elts, g_seed);
758 len = vec_len (vec) + vec_len (new);
759 hash = compute_vec_hash (0, vec);
760 hash = compute_vec_hash (hash, new);
762 vec_prepend (vec, new);
765 ASSERT (vec_len (vec) == len);
766 ASSERT (compute_vec_hash (hash, vec) == 0);
767 validate_vec (vec, 0);
772 run_validator_wh (uword iter)
780 f64 time[3]; /* [0]: start, [1]: last, [2]: current */
782 vec = create_random_vec_wh (elt_t, ~0, sizeof (hdr_t), g_seed);
783 validate_vec (vec, 0);
784 VERBOSE2 ("Start with len %d\n", vec_len (vec));
786 time[0] = unix_time_now ();
788 dump_time = g_dump_period;
790 for (i = 1; i <= iter; i++)
792 if (i >= g_set_verbose_at)
795 op = bounded_random_u32 (&g_seed, 0, vec_len (g_prob_wh) - 1);
800 case OP_IS_VEC_INIT_H:
801 num_elts = bounded_random_u32 (&g_seed, 0, MAX_CHANGE);
802 vec_free_h (vec, sizeof (hdr_t));
803 VERBOSE2 ("vec_init_h(), new elts %d\n", num_elts);
804 vec = validate_vec_init_h (num_elts, sizeof (hdr_t));
807 case OP_IS_VEC_RESIZE_H:
809 num_elts = bounded_random_u32 (&g_seed, len, len + MAX_CHANGE);
810 VERBOSE2 ("vec_resize_h(), %d new elts.\n", num_elts);
811 vec = validate_vec_resize_h (vec, num_elts, sizeof (hdr_t));
814 case OP_IS_VEC_FREE_H:
815 VERBOSE2 ("vec_free_h()\n");
816 vec = validate_vec_free_h (vec, sizeof (hdr_t));
828 time[2] = unix_time_now ();
829 VERBOSE1 ("%d vec ops in %f secs. (last %d in %f secs.).\n",
830 i, time[2] - time[0], g_dump_period, time[2] - time[1]);
832 dump_time += g_dump_period;
834 VERBOSE1 ("vec len %d\n", vec_len (vec));
836 format_hex_bytes, vec, vec_len (vec) * sizeof (vec[0]));
839 VERBOSE2 ("len %d\n", vec_len (vec));
842 validate_vec (vec, sizeof (hdr_t));
843 vec_free_h (vec, sizeof (hdr_t));
847 run_validator (uword iter)
857 f64 time[3]; /* [0]: start, [1]: last, [2]: current */
859 vec = create_random_vec (elt_t, ~0, g_seed);
860 validate_vec (vec, 0);
861 VERBOSE2 ("Start with len %d\n", vec_len (vec));
863 time[0] = unix_time_now ();
865 dump_time = g_dump_period;
867 for (i = 1; i <= iter; i++)
869 if (i >= g_set_verbose_at)
872 op = bounded_random_u32 (&g_seed, 0, vec_len (g_prob) - 1);
877 case OP_IS_VEC_RESIZE:
879 num_elts = bounded_random_u32 (&g_seed, len, len + MAX_CHANGE);
880 VERBOSE2 ("vec_resize(), %d new elts.\n", num_elts);
881 vec = validate_vec_resize (vec, num_elts);
885 VERBOSE2 ("vec_add1()\n");
886 vec = validate_vec_add1 (vec);
890 num_elts = bounded_random_u32 (&g_seed, 0, MAX_CHANGE);
891 VERBOSE2 ("vec_add2(), %d new elts.\n", num_elts);
892 vec = validate_vec_add2 (vec, num_elts);
896 num_elts = bounded_random_u32 (&g_seed, 0, MAX_CHANGE);
897 VERBOSE2 ("vec_add(), %d new elts.\n", num_elts);
898 vec = validate_vec_add (vec, num_elts);
901 case OP_IS_VEC_INSERT:
903 num_elts = bounded_random_u32 (&g_seed, 0, MAX_CHANGE);
904 index = bounded_random_u32 (&g_seed, 0,
905 (len > 0) ? (len - 1) : (0));
906 VERBOSE2 ("vec_insert(), %d new elts, index %d.\n", num_elts,
908 vec = validate_vec_insert (vec, num_elts, index);
911 case OP_IS_VEC_INSERT_ELTS:
913 num_elts = bounded_random_u32 (&g_seed, 0, MAX_CHANGE);
914 index = bounded_random_u32 (&g_seed, 0,
915 (len > 0) ? (len - 1) : (0));
916 VERBOSE2 ("vec_insert_elts(), %d new elts, index %d.\n",
918 vec = validate_vec_insert_elts (vec, num_elts, index);
921 case OP_IS_VEC_DELETE:
923 index = bounded_random_u32 (&g_seed, 0, len - 1);
924 num_elts = bounded_random_u32 (&g_seed, 0,
925 (len > index) ? (len - index) : (0));
926 VERBOSE2 ("vec_delete(), %d elts, index %d.\n", num_elts, index);
927 vec = validate_vec_delete (vec, num_elts, index);
931 VERBOSE2 ("vec_dup()\n");
932 new = validate_vec_dup (vec);
936 case OP_IS_VEC_IS_EQUAL:
937 VERBOSE2 ("vec_is_equal()\n");
938 validate_vec_is_equal (vec);
942 VERBOSE2 ("vec_zero()\n");
943 vec = validate_vec_zero (vec);
947 VERBOSE2 ("vec_set()\n");
948 vec = validate_vec_set (vec);
951 case OP_IS_VEC_VALIDATE:
953 index = bounded_random_u32 (&g_seed, 0, len - 1 + MAX_CHANGE);
954 VERBOSE2 ("vec_validate(), index %d\n", index);
955 vec = validate_vec_validate (vec, index);
959 VERBOSE2 ("vec_free()\n");
960 vec = validate_vec_free (vec);
964 num_elts = bounded_random_u32 (&g_seed, 0, MAX_CHANGE);
966 VERBOSE2 ("vec_init(), new elts %d\n", num_elts);
967 vec = validate_vec_init (num_elts);
970 case OP_IS_VEC_CLONE:
971 VERBOSE2 ("vec_clone()\n");
972 new = validate_vec_clone (vec);
976 case OP_IS_VEC_APPEND:
977 VERBOSE2 ("vec_append()\n");
978 vec = validate_vec_append (vec);
981 case OP_IS_VEC_PREPEND:
982 VERBOSE2 ("vec_prepend()\n");
983 vec = validate_vec_prepend (vec);
995 time[2] = unix_time_now ();
996 VERBOSE1 ("%d vec ops in %f secs. (last %d in %f secs.).\n",
997 i, time[2] - time[0], g_dump_period, time[2] - time[1]);
999 dump_time += g_dump_period;
1001 VERBOSE1 ("vec len %d\n", vec_len (vec));
1003 format_hex_bytes, vec, vec_len (vec) * sizeof (vec[0]));
1006 VERBOSE2 ("len %d\n", vec_len (vec));
1009 validate_vec (vec, 0);
1016 uword i, j, ratio, len, index;
1018 /* Create the vector to implement the statistical profile:
1019 vec [ op1 op1 op1 op2 op3 op3 op3 op4 op4 .... ] */
1020 for (i = FIRST_VEC_OP; i <= LAST_VEC_OP; i++)
1022 ratio = g_prob_ratio[i];
1026 len = vec_len (g_prob);
1027 index = len - 1 + ratio;
1028 ASSERT (index >= 0);
1030 /* Pre-allocate new elements. */
1031 vec_validate (g_prob, index);
1033 for (j = len; j <= index; j++)
1037 /* Operations on vectors with headers. */
1038 for (i = FIRST_VEC_HDR_OP; i <= LAST_VEC_HDR_OP; i++)
1040 ratio = g_prob_ratio[i];
1044 len = vec_len (g_prob_wh);
1045 index = len - 1 + ratio;
1046 ASSERT (index >= 0);
1048 /* Pre-allocate new elements. */
1049 vec_validate (g_prob_wh, index);
1051 for (j = len; j <= index; j++)
1055 VERBOSE3 ("prob_vec, len %d\n%U\n", vec_len (g_prob),
1056 format_hex_bytes, g_prob, vec_len (g_prob) * sizeof (g_prob[0]));
1057 VERBOSE3 ("prob_vec_wh, len %d\n%U\n", vec_len (g_prob_wh),
1058 format_hex_bytes, g_prob_wh,
1059 vec_len (g_prob_wh) * sizeof (g_prob_wh[0]));
1066 vec_free (g_prob_wh);
1076 test_vec_main (unformat_input_t * input)
1084 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1086 if (0 == unformat (input, "iter %d", &iter)
1087 && 0 == unformat (input, "seed %d", &g_seed)
1088 && 0 == unformat (input, "verbose %d", &g_verbose)
1089 && 0 == unformat (input, "set %d", &g_set_verbose_at)
1090 && 0 == unformat (input, "dump %d", &g_dump_period)
1091 && 0 == unformat (input, "help %=", &help, 1)
1092 && 0 == unformat (input, "big %=", &big, 1)
1093 && 0 == unformat (input, "ugly %d", &ugly)
1094 && 0 == unformat (input, "align %=", &align, 1))
1096 clib_error ("unknown input `%U'", format_unformat_error, input);
1101 /* Cause a deliberate heap botch */
1107 vec_validate (overrun_me, 31);
1108 for (i = 0; i < vec_len (overrun_me) + ugly; i++)
1111 vec_free (overrun_me);
1117 u64 one_gig = (1 << 30);
1121 fformat (stdout, "giant vector test...");
1122 size = 5ULL * one_gig;
1124 vec_validate (bigboy, size);
1126 for (index = size; index >= 0; index--)
1127 bigboy[index] = index & 0xff;
1135 vec_validate_aligned (v, 9, CLIB_CACHE_LINE_BYTES);
1136 fformat (stdout, "v = 0x%llx, aligned %llx\n",
1137 v, ((uword) v) & ~(CLIB_CACHE_LINE_BYTES - 1));
1146 run_validator (iter);
1147 run_validator_wh (iter);
1149 dump_call_stats (g_call_stats);
1159 fformat (stdout, "Usage: test_vec iter <N> seed <N> verbose <N> "
1160 "set <N> dump <N>\n");
1169 main (int argc, char *argv[])
1174 clib_mem_init (0, 3ULL << 30);
1176 verbose = (argc > 1);
1177 unformat_init_command_line (&i, argv);
1178 ret = test_vec_main (&i);
1183 #endif /* CLIB_UNIX */
1186 * fd.io coding-style-patch-verification: ON
1189 * eval: (c-set-style "gnu")