int
main (int argc, char *argv[])
{
word i, n = atoi (argv[1]);
word run_foo = argc > 2;
bar_t b = { limit:10 };
if (run_foo)
{
f64 time_limit;
time_limit = atof (argv[2]);
vec_resize (foos, n);
for (i = 0; i < n; i++)
{
foos[i].time_requested = time_limit * random_f64 ();
foos[i].time_called = 1e100;
}
foo_base_time = unix_time_now ();
for (i = 0; i < n; i++)
timer_call (foo, i, foos[i].time_requested);
}
else
timer_call (bar, (any) & b, random_f64 ());
while (vec_len (timers) > 0)
os_sched_yield ();
if (vec_len (foos) > 0)
{
f64 min = 1e100, max = -min;
f64 ave = 0, rms = 0;
for (i = 0; i < n; i++)
{
f64 dt = foos[i].time_requested - foos[i].time_called;
if (dt < min)
min = dt;
if (dt > max)
max = dt;
ave += dt;
rms += dt * dt;
}
ave /= n;
rms = sqrt (rms / n - ave * ave);
fformat (stdout, "error min %g max %g ave %g +- %g\n", min, max, ave,
rms);
}
fformat (stdout, "%d function calls, ave. timer delay %g secs\n",
ave_delay_count, ave_delay / ave_delay_count);
return 0;
}
static void
dump_closure (test_main_t * tm, char *s, u8 ** orig)
{
int i, j;
fformat (stdout, "--------- %s --------------\n", s);
for (i = 0; i < vec_len (orig); i++)
{
for (j = 0; j < vec_len (orig); j++)
if (orig[i][j])
{
fformat (stdout, "%s <before> %s\n", items[i], items[j]);
}
}
}
static void assert_strlen (uword iter)
{
u8 * s;
void * s_orig;
uword i, size, unalign, offset, len;
u8 c;
for (i = 0; i < iter; i++)
{
size = bounded_random_u32 (&g_seed, 0, g_bytes);
size++;
unalign = bounded_random_u32 (&g_seed, 0, 1);
if (unalign)
{
offset = bounded_random_u32 (&g_seed, 0, 7);
s = alloc_unaligned (size, offset, &s_orig);
}
else
{
s = alloc_aligned (size, g_align, &s_orig);
}
c = bounded_random_u32 (&g_seed, 0, 255);
memset (s, c, size - 1);
s[size - 1] = '\0';
len = strlen8 (s);
ASSERT (len == strlen (s));
clib_mem_free_safe (s_orig);
}
fformat (stdout, "strlen() validation successful!\n");
}
int
test1 (void)
{
clib_time_t clib_time;
void *h_mem = clib_mem_alloc (2ULL << 30);
void *h;
uword *objects = 0;
int i;
f64 before, after;
clib_time_init (&clib_time);
vec_validate (objects, 2000000 - 1);
h = mheap_alloc (h_mem, (uword) (2 << 30));
before = clib_time_now (&clib_time);
for (i = 0; i < vec_len (objects); i++)
{
h = mheap_get_aligned (h, 24 /* size */ ,
64 /* align */ ,
16 /* align at offset */ , &objects[i]);
}
after = clib_time_now (&clib_time);
fformat (stdout, "alloc: %u objects in %.2f seconds, %.2f objects/second\n",
vec_len (objects), (after - before),
((f64) vec_len (objects)) / (after - before));
return 0;
}
int main (int argc, char **argv)
{
svm_region_t *root_rp, *rp;
svm_map_region_args_t *a = 0;
vec_validate (a, 0);
root_rp = svm_region_init();
ASSERT (root_rp);
a->name = "/qvnet";
a->size = (4<<10);
rp = svm_region_find_or_create (root_rp, a);
ASSERT (rp);
*((u32 *)rp->data_base) = 0xdeadbeef;
svm_region_unmap (root_rp, rp);
fformat(stdout, "exiting...\n");
exit (0);
}
static void assert_memcpy (uword iter)
{
u8 * s, * d;
void * s_orig, * d_orig;
uword i, j;
uword size;
for (i = 0; i < iter; i++)
{
void * avoid_warnings_s, * avoid_warnings_d;
size = bounded_random_u32 (&g_seed, 0, g_bytes);
get_random_pointer (size + 1, &avoid_warnings_d, &d_orig);
get_random_pointer (size + 1, &avoid_warnings_s, &s_orig);
s = avoid_warnings_s;
d = avoid_warnings_d;
memset (d, 0, size + 1);
memset (s, 0xba, size + 1);
d[size] = MAGIC_GUARD;
memcpy8 (d, s, size);
for (j = 0; j < size; j++)
ASSERT (d[j] == s[j]);
ASSERT (d[size] == MAGIC_GUARD);
clib_mem_free_safe (d_orig);
clib_mem_free_safe (s_orig);
}
fformat (stdout, "memcpy() validation successful!\n");
}
/*----------------------------------------------------------------------------
* Format a Flash Memory Card
*---------------------------------------------------------------------------*/
static void cmd_format (char *par) {
char *label,*next,*opt;
char arg[20];
U32 retv;
label = get_entry (par, &next);
if (label == NULL) {
label = "KEIL";
}
strcpy (arg, label);
opt = get_entry (next, &next);
if (opt != NULL) {
if ((strcmp (opt, "/FAT32") == 0) ||(strcmp (opt, "/fat32") == 0)) {
strcat (arg, "/FAT32");
}
}
printf ("\nFormat Flash Memory Card? [Y/N]\n");
retv = getkey();
if (retv == 'y' || retv == 'Y') {
/* Format the Card with Label "KEIL". "*/
if (fformat (arg) == 0) {
printf ("Memory Card Formatted.\n");
printf ("Card Label is %s\n",label);
}
else {
printf ("Formatting failed.\n");
}
}
}
static int
api_stn_rules_dump (vat_main_t * vam)
{
stn_test_main_t *sm = &stn_test_main;
vl_api_stn_rules_dump_t *mp;
vl_api_control_ping_t *mp_ping;
int ret;
if (!vam->json_output)
{
print (vam->ofp, "%=20s", "STN Rules");
}
M (STN_RULES_DUMP, mp);
/* send it... */
S (mp);
/* Use a control ping for synchronization */
mp_ping = vl_msg_api_alloc_as_if_client (sizeof (*mp_ping));
mp_ping->_vl_msg_id = htons (sm->ping_id);
mp_ping->client_index = vam->my_client_index;
fformat (vam->ofp, "Sending ping id=%d\n", sm->ping_id);
vam->result_ready = 0;
S (mp_ping);
/* Wait for a reply... */
W (ret);
return ret;
}
static int
api_vmxnet3_dump (vat_main_t * vam)
{
vmxnet3_test_main_t *vxm = &vmxnet3_test_main;
vl_api_vmxnet3_dump_t *mp;
vl_api_control_ping_t *mp_ping;
int ret;
if (vam->json_output)
{
clib_warning ("JSON output not supported for vmxnet3_dump");
return -99;
}
M (VMXNET3_DUMP, mp);
S (mp);
/* Use a control ping for synchronization */
mp_ping = vl_msg_api_alloc_as_if_client (sizeof (*mp_ping));
mp_ping->_vl_msg_id = htons (vxm->ping_id);
mp_ping->client_index = vam->my_client_index;
fformat (vam->ofp, "Sending ping id=%d\n", vxm->ping_id);
vam->result_ready = 0;
S (mp_ping);
W (ret);
return ret;
}
static INT8S fs_init (void)
{
INT32U retv;
retv = finit ();
spi_hi_speed (__TRUE);
if (retv == 0) {
retv = fcheck ("S:");
}
else
{
retv = fformat ("S:");
if (retv == 0)
{
return 0;
}
else
{
return -1;
}
}
return 0;
}
static void
vl_api_stn_rules_details_t_handler (vl_api_stn_rules_details_t * mp)
{
vat_main_t *vam = stn_test_main.vat_main;
fformat (vam->ofp, "addr: %U sw_if_index: %u\n",
mp->is_ip4 ? format_ip4_address : format_ip6_address,
mp->ip_address, clib_net_to_host_u32 (mp->sw_if_index));
}
static void vl_api_control_ping_reply_t_handler
(vl_api_control_ping_reply_t * mp)
{
test_main_t *tm = &test_main;
fformat (stdout, "control ping reply from pid %d\n", ntohl (mp->vpe_pid));
tm->pings_replied++;
}
static void assert_memset (uword iter)
{
u8 * s;
void * orig;
uword i, j, k;
uword count, size;
u64 val = 0xbabababababababaLL;
for (i = 0; i < iter; i++)
{
size = bounded_random_u32 (&g_seed, 0, g_bytes);
for (k = 1; k <= 8; k *= 2)
{
count = size / k;
size = (count * k) + 1;
if (k == 1)
{
void * avoid_warnings_s;
get_random_pointer (size, &avoid_warnings_s, &orig);
s = avoid_warnings_s;
}
else
s = alloc_aligned (size, min_log2 (k), &orig);
memset (s, 0, size);
s[size - 1] = MAGIC_GUARD;
switch (k)
{
#define _(type, func) \
{ \
type * ptr = (type *) s; \
\
func (ptr, val, count); \
\
for (j = 0; j < count; j++) \
ASSERT (ptr[j] == (type) val); \
}
case 1: _(u8 , memset8); break;
case 2: _(u16, memset16); break;
case 4: _(u32, memset32); break;
case 8: _(u64, memset64); break;
#undef _
}
ASSERT (s[size - 1] == MAGIC_GUARD);
clib_mem_free_safe (orig);
}
}
fformat (stdout, "memset() validation successful!\n");
}
void bar (any arg, f64 delay)
{
bar_t * b = (bar_t *) arg;
fformat (stdout, "bar %d delay %g\n", b->count++, delay);
update (delay);
if (b->count < b->limit)
timer_call (bar, arg, random_f64 ());
}
int test_macros_main (unformat_input_t * input)
{
macro_main_t * mm = ¯o_main;
clib_macro_init(mm);
fformat (stdout, "hostname: %s\n",
clib_macro_eval_dollar (mm, "hostname", 1 /* complain */));
clib_macro_set_value (mm, "foo", "this is foo which contains $(bar)");
clib_macro_set_value (mm, "bar", "bar");
fformat (stdout, "evaluate: %s\n",
clib_macro_eval (mm, "returns '$(foo)'", 1 /* complain */));
clib_macro_free (mm);
return 0;
}
always_inline void
msg_handler_internal (api_main_t * am,
void *the_msg, int trace_it, int do_it, int free_it)
{
u16 id = ntohs (*((u16 *) the_msg));
u8 *(*print_fp) (void *, void *);
if (id < vec_len (am->msg_handlers) && am->msg_handlers[id])
{
if (trace_it)
vl_msg_api_trace (am, am->rx_trace, the_msg);
if (am->msg_print_flag)
{
fformat (stdout, "[%d]: %s\n", id, am->msg_names[id]);
print_fp = (void *) am->msg_print_handlers[id];
if (print_fp == 0)
{
fformat (stdout, " [no registered print fn]\n");
}
else
{
(*print_fp) (the_msg, stdout);
}
}
if (do_it)
{
if (!am->is_mp_safe[id])
vl_msg_api_barrier_sync ();
(*am->msg_handlers[id]) (the_msg);
if (!am->is_mp_safe[id])
vl_msg_api_barrier_release ();
}
}
else
{
clib_warning ("no handler for msg id %d", id);
}
if (free_it)
vl_msg_api_free (the_msg);
}
static void assert_memmove (uword iter)
{
u8 * d, * s;
u8 * dpguard = NULL, * epguard = NULL;
uword i;
uword size;
u8 hash = 0;
u8 dguard = 0, eguard = 0;
for (i = 0; i < iter; i++)
{
void * d_orig, * s_orig;
void * avoid_warnings_s, * avoid_warnings_d;
size = bounded_random_u32 (&g_seed, 0, g_bytes);
get_random_two_pointers (size, size,
&avoid_warnings_d, &avoid_warnings_s,
&d_orig, &s_orig);
s = avoid_warnings_s;
d = avoid_warnings_d;
memset (d, 0, size);
fill_with_random_data (s, size, g_seed);
hash = compute_mem_hash (0, s, size);
if (d)
{
dpguard = d - 1;
dguard = *dpguard;
epguard = d + size;
eguard = *epguard;
}
memmove8 (d, s, size);
ASSERT (compute_mem_hash (hash, d, size) == 0);
if (d)
{
ASSERT (dguard == *dpguard);
ASSERT (eguard == *epguard);
}
clib_mem_free_safe (d_orig);
clib_mem_free_safe (s_orig);
}
fformat (stdout, "memmove() validation successful!\n");
}
/**
* Dump a trajectory trace, reasonably easy to call from gdb
*/
void
vnet_dump_trajectory_trace (vlib_main_t * vm, u32 bi)
{
#if VLIB_BUFFER_TRACE_TRAJECTORY > 0
vlib_node_main_t *vnm = &vm->node_main;
vlib_buffer_t *b;
u16 *trace;
u8 i;
b = vlib_get_buffer (vm, bi);
trace = vnet_buffer2 (b)->trajectory_trace;
fformat (stderr, "Context trace for bi %d b 0x%llx, visited %d\n",
bi, b, vec_len (trace));
for (i = 0; i < vec_len (trace); i++)
{
u32 node_index;
node_index = trace[i];
if (node_index >= vec_len (vnm->nodes))
{
fformat (stderr, "Skip bogus node index %d\n", node_index);
continue;
}
fformat (stderr, "%v (%d)\n", vnm->nodes[node_index]->name, node_index);
}
#else
fformat (stderr, "in vlib/buffers.h, "
"#define VLIB_BUFFER_TRACE_TRAJECTORY 1\n");
#endif
}
/* vmxnet3-create reply handler */
static void
vl_api_vmxnet3_create_reply_t_handler (vl_api_vmxnet3_create_reply_t * mp)
{
vat_main_t *vam = vmxnet3_test_main.vat_main;
i32 retval = ntohl (mp->retval);
if (retval == 0)
{
fformat (vam->ofp, "created vmxnet3 with sw_if_index %d\n",
ntohl (mp->sw_if_index));
}
vam->retval = retval;
vam->result_ready = 1;
vam->regenerate_interface_table = 1;
}
static void assert_memcmp (uword iter)
{
u8 * s, * d;
void * s_orig, * d_orig;
uword i;
uword size, change;
word res1, res2;
for (i = 0; i < iter; i++)
{
size = bounded_random_u32 (&g_seed, 1, g_bytes);
d = alloc_aligned (size, g_align, &d_orig);
s = alloc_aligned (size, g_align, &s_orig);
memset (d, 0xba, size);
memset (s, 0xba, size);
if (size && i % 2 == 0)
{
change = bounded_random_u32 (&g_seed, 0, size - 1);
d[change] = 0;
}
res1 = memcmp8 (d, s, size);
res2 = kmemcmp (d, s, size);
if (res1 < 0)
ASSERT (res2 < 0);
else if (res1 > 0)
ASSERT (res2 > 0);
else
ASSERT (res2 == 0);
clib_mem_free_safe (d_orig);
clib_mem_free_safe (s_orig);
}
fformat (stdout, "memcmp() validation successful!\n");
}
int main (int argc, char * argv[])
{
int i;
uword next;
u32 *tp = 0;
u32 *junk;
for (i = 0; i < 70; i++)
pool_get (tp, junk);
(void) junk; /* compiler warning */
pool_put_index (tp, 1);
pool_put_index (tp, 65);
next = ~0;
do {
next = pool_next_index (tp, next);
fformat (stdout, "next index %d\n", next);
} while (next != ~0);
return 0;
}
int test_random_main (unformat_input_t * input)
{
uword n_iterations;
uword i, repeat_count;
uword * bitmap = 0;
uword print;
u32 seed;
u32 *seedp = &seed;
/* first, check known sequence from Numerical Recipes in C, 2nd ed.
page 284 */
seed = known_random_sequence[0];
for (i = 0; i < ARRAY_LEN(known_random_sequence)-1; i++)
{
u32 rv;
rv = random_u32 (seedp);
if (rv != known_random_sequence[i+1])
{
fformat(stderr, "known sequence check FAILS at index %d", i+1);
break;
}
}
clib_warning ("known sequence check passes");
n_iterations = 1000;
seed = 0;
print = 1 << 24;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (0 == unformat (input, "iter %d", &n_iterations)
&& 0 == unformat (input, "print %d", &print)
&& 0 == unformat (input, "seed %d", &seed))
clib_error ("unknown input `%U'", format_unformat_error, input);
}
if (! seed)
seed = random_default_seed ();
if (n_iterations == 0)
n_iterations = random_u32_max ();
clib_warning ("%d iterations, seed %d\n", n_iterations, seed);
repeat_count = 0;
for (i = 0; i < n_iterations; i++)
{
uword r = random_u32 (&seed);
uword b, ri, rj;
ri = r / BITS (bitmap[0]);
rj = (uword) 1 << (r % BITS (bitmap[0]));
vec_validate (bitmap, ri);
b = bitmap[ri];
if (b & rj)
goto repeat;
b |= rj;
bitmap[ri] = b;
if (0 == (i & (print - 1)))
fformat (stderr, "0x%08x iterations %d repeats\n", i, repeat_count);
continue;
repeat:
fformat (stderr, "repeat found at iteration %d/%d\n", i, n_iterations);
repeat_count++;
continue;
}
return 0;
}
int main (int argc, char * argv[])
{
word i, j, k, n, seed, check_mask;
u32 * h = 0;
uword * objects = 0;
uword * handles = 0;
uword objects_used;
uword align, fixed_size;
n = 10;
seed = getpid ();
check_mask = 0;
fixed_size = 0;
if (argc > 1)
{
n = atoi (argv[1]);
verbose = 1;
}
if (argc > 2)
{
word i = atoi (argv[2]);
if (i)
seed = i;
}
if (argc > 3)
check_mask = atoi (argv[3]);
align = 0;
if (argc > 4)
align = 1 << atoi (argv[4]);
if_verbose ("testing %wd iterations seed %wd\n", n, seed);
srandom (seed);
if (verbose) fformat (stderr, "%U\n", format_clib_mem_usage, /* verbose */ 0);
vec_resize (objects, 1000);
memset (objects, ~0, vec_bytes (objects));
vec_resize (handles, vec_len (objects));
objects_used = 0;
if (fixed_size)
{
uword max_len = 1024 * 1024;
void * memory = clib_mem_alloc (max_len * sizeof (h[0]));
h = heap_create_from_memory (memory, max_len, sizeof (h[0]));
}
for (i = 0; i < n; i++)
{
while (1)
{
j = random () % vec_len (objects);
if (objects[j] != ~0 || i + objects_used < n)
break;
}
if (objects[j] != ~0)
{
heap_dealloc (h, handles[j]);
objects_used--;
objects[j] = ~0;
}
else
{
u32 * data;
uword size;
size = 1 + (random () % 100);
objects[j] = heap_alloc_aligned (h, size, align, handles[j]);
objects_used++;
if (align)
ASSERT (0 == (objects[j] & (align - 1)));
ASSERT (objects[j] < vec_len (h));
ASSERT (size <= heap_len (h, handles[j]));
/* Set newly allocated object with test data. */
if (check_mask & 2)
{
data = h + objects[j];
for (k = 0; k < size; k++)
data[k] = objects[j] + k;
}
}
if (check_mask & 1)
heap_validate (h);
if (check_mask & 4)
{
/* Duplicate heap at each iteration. */
u32 * h1 = heap_dup (h);
heap_free (h);
h = h1;
}
/* Verify that all used objects have correct test data. */
if (check_mask & 2)
{
for (j = 0; j < vec_len (objects); j++)
if (objects[j] != ~0)
{
u32 * data = h + objects[j];
for (k = 0; k < heap_len (h, handles[j]); k++)
ASSERT(data[k] == objects[j] + k);
}
}
}
if (verbose) fformat (stderr, "%U\n", format_heap, h, 1);
{
u32 * h1 = heap_dup (h);
if (verbose) fformat (stderr, "%U\n", format_heap, h1, 1);
heap_free (h1);
}
heap_free (h);
if (verbose) fformat (stderr, "%U\n", format_heap, h, 1);
ASSERT (objects_used == 0);
vec_free (objects);
vec_free (handles);
if (fixed_size)
vec_free_h (h, sizeof (heap_header_t));
if (verbose) fformat (stderr, "%U\n", format_clib_mem_usage, /* verbose */ 0);
return 0;
}
int
test_ptclosure_main (unformat_input_t * input)
{
test_main_t *tm = &test_main;
u8 *item_name;
int i, j;
u8 **orig;
u8 **closure;
u8 *a_name, *b_name;
int a_index, b_index;
uword *p;
u8 *this_constraint;
int n;
u32 *result = 0;
tm->index_by_name = hash_create_string (0, sizeof (uword));
n = ARRAY_LEN (items);
for (i = 0; i < n; i++)
{
item_name = (u8 *) items[i];
hash_set_mem (tm->index_by_name, item_name, i);
}
orig = clib_ptclosure_alloc (n);
for (i = 0; i < ARRAY_LEN (constraints); i++)
{
this_constraint = format (0, "%s%c", constraints[i], 0);
if (comma_split (this_constraint, &a_name, &b_name))
{
clib_warning ("couldn't split '%s'", constraints[i]);
return 1;
}
p = hash_get_mem (tm->index_by_name, a_name);
if (p == 0)
{
clib_warning ("couldn't find '%s'", a_name);
return 1;
}
a_index = p[0];
p = hash_get_mem (tm->index_by_name, b_name);
if (p == 0)
{
clib_warning ("couldn't find '%s'", b_name);
return 1;
}
b_index = p[0];
orig[a_index][b_index] = 1;
vec_free (this_constraint);
}
dump_closure (tm, "original relation", orig);
closure = clib_ptclosure (orig);
dump_closure (tm, "closure", closure);
/*
* Output partial order
*/
again:
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
if (closure[i][j])
goto item_constrained;
}
/* Item i can be output */
vec_add1 (result, i);
{
int k;
for (k = 0; k < n; k++)
closure[k][i] = 0;
/* "Magic" a before a, to keep from ever outputting it again */
closure[i][i] = 1;
goto again;
}
item_constrained:
;
}
if (vec_len (result) != n)
{
clib_warning ("no partial order exists");
exit (1);
}
fformat (stdout, "Partial order:\n");
for (i = vec_len (result) - 1; i >= 0; i--)
{
fformat (stdout, "%s\n", items[result[i]]);
}
vec_free (result);
clib_ptclosure_free (orig);
clib_ptclosure_free (closure);
return 0;
}
int
test_mheap_main (unformat_input_t * input)
{
int i, j, k, n_iterations;
void *h, *h_mem;
uword *objects = 0;
u32 objects_used, really_verbose, n_objects, max_object_size;
u32 check_mask, seed, trace, use_vm;
u32 print_every = 0;
u32 *data;
mheap_t *mh;
/* Validation flags. */
check_mask = 0;
#define CHECK_VALIDITY 1
#define CHECK_DATA 2
#define CHECK_ALIGN 4
#define TEST1 8
n_iterations = 10;
seed = 0;
max_object_size = 100;
n_objects = 1000;
trace = 0;
really_verbose = 0;
use_vm = 0;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (0 == unformat (input, "iter %d", &n_iterations)
&& 0 == unformat (input, "count %d", &n_objects)
&& 0 == unformat (input, "size %d", &max_object_size)
&& 0 == unformat (input, "seed %d", &seed)
&& 0 == unformat (input, "print %d", &print_every)
&& 0 == unformat (input, "validdata %|",
&check_mask, CHECK_DATA | CHECK_VALIDITY)
&& 0 == unformat (input, "valid %|",
&check_mask, CHECK_VALIDITY)
&& 0 == unformat (input, "verbose %=", &really_verbose, 1)
&& 0 == unformat (input, "trace %=", &trace, 1)
&& 0 == unformat (input, "vm %=", &use_vm, 1)
&& 0 == unformat (input, "align %|", &check_mask, CHECK_ALIGN)
&& 0 == unformat (input, "test1 %|", &check_mask, TEST1))
{
clib_warning ("unknown input `%U'", format_unformat_error, input);
return 1;
}
}
/* Zero seed means use default. */
if (!seed)
seed = random_default_seed ();
if (check_mask & TEST1)
{
return test1 ();
}
if_verbose
("testing %d iterations, %d %saligned objects, max. size %d, seed %d",
n_iterations, n_objects, (check_mask & CHECK_ALIGN) ? "randomly " : "un",
max_object_size, seed);
vec_resize (objects, n_objects);
if (vec_bytes (objects) > 0) /* stupid warning be gone */
clib_memset (objects, ~0, vec_bytes (objects));
objects_used = 0;
/* Allocate initial heap. */
{
uword size =
max_pow2 (2 * n_objects * max_object_size * sizeof (data[0]));
h_mem = clib_mem_alloc (size);
if (!h_mem)
return 0;
h = mheap_alloc (h_mem, size);
}
if (trace)
mheap_trace (h, trace);
mh = mheap_header (h);
if (use_vm)
mh->flags &= ~MHEAP_FLAG_DISABLE_VM;
else
mh->flags |= MHEAP_FLAG_DISABLE_VM;
if (check_mask & CHECK_VALIDITY)
mh->flags |= MHEAP_FLAG_VALIDATE;
for (i = 0; i < n_iterations; i++)
{
while (1)
{
j = random_u32 (&seed) % vec_len (objects);
if (objects[j] != ~0 || i + objects_used < n_iterations)
break;
}
if (objects[j] != ~0)
{
mheap_put (h, objects[j]);
objects_used--;
objects[j] = ~0;
}
else
{
uword size, align, align_offset;
size = (random_u32 (&seed) % max_object_size) * sizeof (data[0]);
align = align_offset = 0;
if (check_mask & CHECK_ALIGN)
{
align = 1 << (random_u32 (&seed) % 10);
align_offset = round_pow2 (random_u32 (&seed) & (align - 1),
sizeof (u32));
}
h = mheap_get_aligned (h, size, align, align_offset, &objects[j]);
if (align > 0)
ASSERT (0 == ((objects[j] + align_offset) & (align - 1)));
ASSERT (objects[j] != ~0);
objects_used++;
/* Set newly allocated object with test data. */
if (check_mask & CHECK_DATA)
{
uword len;
data = (void *) h + objects[j];
len = mheap_len (h, data);
ASSERT (size <= mheap_data_bytes (h, objects[j]));
data[0] = len;
for (k = 1; k < len; k++)
data[k] = objects[j] + k;
}
}
/* Verify that all used objects have correct test data. */
if (check_mask & 2)
{
for (j = 0; j < vec_len (objects); j++)
if (objects[j] != ~0)
{
u32 *data = h + objects[j];
uword len = data[0];
for (k = 1; k < len; k++)
ASSERT (data[k] == objects[j] + k);
}
}
if (print_every != 0 && i > 0 && (i % print_every) == 0)
fformat (stderr, "iteration %d: %U\n", i, format_mheap, h,
really_verbose);
}
if (verbose)
fformat (stderr, "%U\n", format_mheap, h, really_verbose);
mheap_free (h);
clib_mem_free (h_mem);
vec_free (objects);
return 0;
}
int test_standalone_string_main (unformat_input_t * input)
{
uword iter = 0;
uword help = 0;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (0 == unformat (input, "iter %d", &iter)
&& 0 == unformat (input, "bytes %d", &g_bytes)
&& 0 == unformat (input, "seed %d", &g_seed)
&& 0 == unformat (input, "align %d", &g_align)
&& 0 == unformat (input, "overlap %d", &g_overlap)
&& 0 == unformat (input, "verbose %d", &g_verbose)
&& 0 == unformat (input, "swap %=", &g_swap, 1)
&& 0 == unformat (input, "help %=", &help, 1))
{
clib_error ("unknown input `%U'", format_unformat_error, input);
goto usage;
}
}
if (help)
goto usage;
fformat (stdout, "iter %d, bytes %d, seed %u, align %d, overlap %d, "
"verbose %d, %s\n",
iter, g_bytes, g_seed, g_align, g_overlap, g_verbose,
(g_swap) ? "swap" : "");
#if 1
assert_memset (iter);
assert_memcpy (iter);
assert_memmove (iter);
assert_memcmp (iter);
assert_strlen (iter);
#endif
if (g_bytes < 64)
{
fformat (stdout, "To ensure fairness in timing, the number of bytes "
"to process needs to be at least 64\n");
return -1;
}
#if 1
time_memset (iter);
time_memcpy (iter);
time_memmove (iter);
time_memcmp (iter);
time_strcpy (iter);
#endif
memory_snap ();
return 0;
usage:
fformat (stdout,
"Usage: test_standalone_string iter <N> bytes <N> seed <N>\n"
" align <N> overlap <N> verbose <N>\n"
" swap help\n");
if (help)
return 0;
return -1;
}
int
main (int argc, char **argv)
{
test_main_t *tm = &test_main;
api_main_t *am = &api_main;
u32 swt_pid = 0;
int connected = 0;
signal (SIGINT, signal_handler);
while (1)
{
if (tm->signal_received)
break;
if (am->shmem_hdr)
swt_pid = am->shmem_hdr->vl_pid;
/* If kill returns 0, the vpe-f process is alive */
if (kill (swt_pid, 0) == 0)
{
/* Try to connect */
if (connected == 0)
{
fformat (stdout, "Connect to VPE-f\n");
if (connect_to_vpe ("test_ha_client") >= 0)
{
tm->pings_sent = 0;
tm->pings_replied = 0;
connected = 1;
}
else
{
fformat (stdout, "Connect failed, sleep and retry...\n");
sleep (1);
continue;
}
}
tm->pings_sent++;
ping (tm);
sleep (1);
/* havent heard back in 3 seconds, disco / reco */
if ((tm->pings_replied + 3) <= tm->pings_sent)
{
fformat (stdout, "VPE-f pid %d not responding\n", swt_pid);
swt_pid = 0;
disconnect_from_vpe ();
connected = 0;
}
}
else
{
if (connected)
{
fformat (stdout, "VPE-f pid %d died\n", swt_pid);
swt_pid = 0;
disconnect_from_vpe ();
connected = 0;
}
sleep (1);
}
}
fformat (stdout, "Signal received, graceful exit\n");
disconnect_from_vpe ();
exit (0);
}
int
main (int argc, char **argv)
{
unformat_input_t input;
char *chroot_path = 0;
u8 *chroot_path_u8;
int interval = 0;
f64 *vector_ratep, *rx_ratep, *sig_error_ratep;
pid_t *vpp_pidp;
svmdb_map_args_t _ma, *ma = &_ma;
int uid, gid, rv;
struct passwd _pw, *pw;
struct group _grp, *grp;
char *s, buf[128];
unformat_init_command_line (&input, argv);
uid = geteuid ();
gid = getegid ();
while (unformat_check_input (&input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (&input, "chroot %s", &chroot_path_u8))
{
chroot_path = (char *) chroot_path_u8;
}
else if (unformat (&input, "interval %d", &interval))
;
else if (unformat (&input, "uid %d", &uid))
;
else if (unformat (&input, "gid %d", &gid))
;
else if (unformat (&input, "uid %s", &s))
{
/* lookup the username */
pw = NULL;
rv = getpwnam_r (s, &_pw, buf, sizeof (buf), &pw);
if (rv < 0)
{
fformat (stderr, "cannot fetch username %s", s);
exit (1);
}
if (pw == NULL)
{
fformat (stderr, "username %s does not exist", s);
exit (1);
}
vec_free (s);
uid = pw->pw_uid;
}
else if (unformat (&input, "gid %s", &s))
{
/* lookup the group name */
grp = NULL;
rv = getgrnam_r (s, &_grp, buf, sizeof (buf), &grp);
if (rv != 0)
{
fformat (stderr, "cannot fetch group %s", s);
exit (1);
}
if (grp == NULL)
{
fformat (stderr, "group %s does not exist", s);
exit (1);
}
vec_free (s);
gid = grp->gr_gid;
}
else
{
fformat (stderr,
"usage: vpp_get_metrics [chroot <path>] [interval <nn>]\n");
exit (1);
}
}
setup_signal_handlers ();
clib_memset (ma, 0, sizeof (*ma));
ma->root_path = chroot_path;
ma->uid = uid;
ma->gid = gid;
c = svmdb_map (ma);
vpp_pidp =
svmdb_local_get_variable_reference (c, SVMDB_NAMESPACE_VEC, "vpp_pid");
vector_ratep =
svmdb_local_get_variable_reference (c, SVMDB_NAMESPACE_VEC,
"vpp_vector_rate");
rx_ratep =
svmdb_local_get_variable_reference (c, SVMDB_NAMESPACE_VEC,
"vpp_input_rate");
sig_error_ratep =
svmdb_local_get_variable_reference (c, SVMDB_NAMESPACE_VEC,
"vpp_sig_error_rate");
/*
* Make sure vpp is actually running. Otherwise, there's every
* chance that the database region will be wiped out by the
* process monitor script
*/
if (vpp_pidp == 0 || vector_ratep == 0 || rx_ratep == 0
|| sig_error_ratep == 0)
{
fformat (stdout, "vpp not running\n");
exit (1);
}
do
{
/*
* Once vpp exits, the svm db region will be recreated...
* Can't use kill (*vpp_pidp, 0) if running as non-root /
* accessing the shared-VM database via group perms.
*/
if (*vpp_pidp == 0)
{
fformat (stdout, "vpp not running\n");
exit (1);
}
fformat (stdout,
"%d: vpp_vector_rate=%.2f, vpp_input_rate=%f, vpp_sig_error_rate=%f\n",
*vpp_pidp, *vector_ratep, *rx_ratep, *sig_error_ratep);
if (interval)
sleep (interval);
if (signal_received)
break;
}
while (interval);
svmdb_unmap (c);
exit (0);
}
void SPI_FLASH_Format (void) {
fformat("S:");
}
int main (int argc, char ** argv)
{
api_main_t * am = &api_main;
vl_api_show_version_t message;
vl_api_show_version_t *mp;
int async = 1;
int rv = pneum_connect("pneum_client");
if (rv != 0) {
printf("Connect failed: %d\n", rv);
exit(rv);
}
struct timeb timer_msec;
long long int timestamp_msec_start; /* timestamp in millisecond. */
if (!ftime(&timer_msec)) {
timestamp_msec_start = ((long long int) timer_msec.time) * 1000ll +
(long long int) timer_msec.millitm;
}
else {
timestamp_msec_start = -1;
}
/*
* Test vpe_api_write and vpe_api_read to send and recv message for an
* API
*/
int i;
long int no_msgs = 10000;
mp = &message;
for (i = 0; i < no_msgs; i++) {
/* Construct the API message */
M_NOALLOC(SHOW_VERSION, show_version);
pneum_write((char *)mp, sizeof(*mp));
if (!async)
while (result_ready == 0);
}
if (async) {
vl_api_control_ping_t control;
vl_api_control_ping_t *mp;
mp = &control;
M_NOALLOC(CONTROL_PING, control_ping);
pneum_write((char *)mp, sizeof(*mp));
while (result_msg_id != VL_API_CONTROL_PING_REPLY);
}
long long int timestamp_msec_end; /* timestamp in millisecond. */
if (!ftime(&timer_msec)) {
timestamp_msec_end = ((long long int) timer_msec.time) * 1000ll +
(long long int) timer_msec.millitm;
}
else {
timestamp_msec_end = -1;
}
printf("Took %lld msec, %lld msgs/msec \n", (timestamp_msec_end - timestamp_msec_start),
no_msgs/(timestamp_msec_end - timestamp_msec_start));
fformat(stdout, "Exiting...\n");
pneum_disconnect();
exit (0);
}
