void vlib_clear_combined_counters (vlib_combined_counter_main_t * cm) { uword i, j; vlib_mini_counter_t *my_minis; for (i = 0; i < vec_len (cm->minis); i++) { my_minis = cm->minis[i]; for (j = 0; j < vec_len (my_minis); j++) { cm->maxi[j].packets += my_minis[j].packets; cm->maxi[j].bytes += my_minis[j].bytes; my_minis[j].packets = 0; my_minis[j].bytes = 0; } } j = vec_len (cm->maxi); if (j > 0) vec_validate (cm->value_at_last_clear, j - 1); for (i = 0; i < j; i++) { vlib_counter_t *c = vec_elt_at_index (cm->value_at_last_clear, i); c[0] = cm->maxi[i]; } }
static void do_emit_data(Vector *inits, int size, int off, int depth) { SAVE; for (int i = 0; i < vec_len(inits) && 0 < size; i++) { Node *node = vec_get(inits, i); Node *v = node->initval; emit_padding(node, off); if (node->totype->bitsize > 0) { assert(node->totype->bitoff == 0); long data = eval_intexpr(v, NULL); Type *totype = node->totype; for (i++ ; i < vec_len(inits); i++) { node = vec_get(inits, i); if (node->totype->bitsize <= 0) { break; } v = node->initval; totype = node->totype; data |= ((((long)1 << totype->bitsize) - 1) & eval_intexpr(v, NULL)) << totype->bitoff; } emit_data_primtype(totype, &(Node){ AST_LITERAL, totype, .ival = data }, depth); off += totype->size; size -= totype->size; if (i == vec_len(inits)) break; } else {
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; }
/* Take each x, y, and z and divide by the length for each * Hint: newX = x / vec.len(v) */ vector_t vec_normalize(vector_t v) { vector_t vec; vec.x = v.x / vec_len(v); vec.y = v.y / vec_len(v); vec.z = v.z / vec_len(v); return vec; }
/* Take each x, y, and z and divide by the length for each * Hint: newX = x / vec.len(v) */ vector_t vec_normalize(vector_t v) { vector_t res; res.x = v.x / vec_len(v); res.y = v.y / vec_len(v); res.z = v.z / vec_len(v); return res; }
static void fields(node_t * sym) { int follow[] = {INT, CONST, '}', IF, 0}; node_t *sty = SYM_TYPE(sym); if (!first_decl(token)) { error("expect type name or qualifiers"); return; } struct vector *v = vec_new(); do { node_t *basety = specifiers(NULL, NULL); for (;;) { node_t *field = new_field(); if (token->id == ':') { bitfield(field); FIELD_TYPE(field) = basety; } else { node_t *ty = NULL; struct token *id = NULL; declarator(&ty, &id, NULL); attach_type(&ty, basety); if (token->id == ':') bitfield(field); FIELD_TYPE(field) = ty; if (id) { for (int i = 0; i < vec_len(v); i++) { node_t *f = vec_at(v, i); if (FIELD_NAME(f) && !strcmp(FIELD_NAME(f), id->name)) { errorf(id->src, "redefinition of '%s'", id->name); break; } } FIELD_NAME(field) = id->name; AST_SRC(field) = id->src; } } vec_push(v, field); if (token->id != ',') break; expect(','); ensure_field(field, vec_len(v), false); } match(';', follow); ensure_field(vec_tail(v), vec_len(v), isstruct(sty) && !first_decl(token)); } while (first_decl(token)); TYPE_FIELDS(sty) = (node_t **) vtoa(v); set_typesize(sty); }
static clib_error_t * show_errors (vlib_main_t * vm, unformat_input_t * input, vlib_cli_command_t * cmd) { vlib_error_main_t *em = &vm->error_main; vlib_node_t *n; u32 code, i, ni; u64 c; int index = 0; int verbose = 0; u64 *sums = 0; if (unformat (input, "verbose %d", &verbose)) ; else if (unformat (input, "verbose")) verbose = 1; vec_validate (sums, vec_len (em->counters)); if (verbose) vlib_cli_output (vm, "%=10s%=40s%=20s%=6s", "Count", "Node", "Reason", "Index"); else vlib_cli_output (vm, "%=10s%=40s%=6s", "Count", "Node", "Reason"); /* *INDENT-OFF* */ foreach_vlib_main(({ em = &this_vlib_main->error_main; if (verbose) vlib_cli_output(vm, "Thread %u (%v):", index, vlib_worker_threads[index].name); for (ni = 0; ni < vec_len (this_vlib_main->node_main.nodes); ni++) { n = vlib_get_node (this_vlib_main, ni); for (code = 0; code < n->n_errors; code++) { i = n->error_heap_index + code; c = em->counters[i]; if (i < vec_len (em->counters_last_clear)) c -= em->counters_last_clear[i]; sums[i] += c; if (c == 0 && verbose < 2) continue; if (verbose) vlib_cli_output (vm, "%10Ld%=40v%=20s%=6d", c, n->name, em->error_strings_heap[i], i); else vlib_cli_output (vm, "%10d%=40v%s", c, n->name, em->error_strings_heap[i]); } } index++; }));
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; }
/* Reserves given number of error codes for given node. */ void vlib_register_errors (vlib_main_t * vm, u32 node_index, u32 n_errors, char *error_strings[]) { vlib_error_main_t *em = &vm->error_main; vlib_node_t *n = vlib_get_node (vm, node_index); uword l; ASSERT (os_get_cpu_number () == 0); /* Free up any previous error strings. */ if (n->n_errors > 0) heap_dealloc (em->error_strings_heap, n->error_heap_handle); n->n_errors = n_errors; n->error_strings = error_strings; if (n_errors == 0) return; n->error_heap_index = heap_alloc (em->error_strings_heap, n_errors, n->error_heap_handle); l = vec_len (em->error_strings_heap); clib_memcpy (vec_elt_at_index (em->error_strings_heap, n->error_heap_index), error_strings, n_errors * sizeof (error_strings[0])); /* Allocate a counter/elog type for each error. */ vec_validate (em->counters, l - 1); vec_validate (vm->error_elog_event_types, l - 1); /* Zero counters for re-registrations of errors. */ if (n->error_heap_index + n_errors <= vec_len (em->counters_last_clear)) clib_memcpy (em->counters + n->error_heap_index, em->counters_last_clear + n->error_heap_index, n_errors * sizeof (em->counters[0])); else memset (em->counters + n->error_heap_index, 0, n_errors * sizeof (em->counters[0])); { elog_event_type_t t; uword i; memset (&t, 0, sizeof (t)); for (i = 0; i < n_errors; i++) { t.format = (char *) format (0, "%v %s: %%d", n->name, error_strings[i]); vm->error_elog_event_types[n->error_heap_index + i] = t; } } }
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]); } } }
void efp_charge_octupole_grad(double q1, const double *oct2, const vec_t *dr, vec_t *force, vec_t *add1, vec_t *add2) { double r = vec_len(dr); double r3 = r * r * r; double r7 = r3 * r3 * r; double r9 = r3 * r3 * r3; double t1x = q1 / r7 * octupole_sum_xyz(oct2, dr, 0); double t1y = q1 / r7 * octupole_sum_xyz(oct2, dr, 1); double t1z = q1 / r7 * octupole_sum_xyz(oct2, dr, 2); double g = 7.0 * q1 / r9 * octupole_sum(oct2, dr); force->x = -g * dr->x + t1x; force->y = -g * dr->y + t1y; force->z = -g * dr->z + t1z; add1->x = 0.0; add1->y = 0.0; add1->z = 0.0; add2->x = t1y * dr->z - t1z * dr->y; add2->y = t1z * dr->x - t1x * dr->z; add2->z = t1x * dr->y - t1y * dr->x; }
static void vl_unmap_shmem_internal (u8 is_client) { svm_region_t *rp; int i; api_main_t *am = &api_main; if (!svm_get_root_rp ()) return; for (i = 0; i < vec_len (am->mapped_shmem_regions); i++) { rp = am->mapped_shmem_regions[i]; is_client ? svm_region_unmap_client (rp) : svm_region_unmap (rp); } vec_free (am->mapped_shmem_regions); am->shmem_hdr = 0; is_client ? svm_region_exit_client () : svm_region_exit (); /* $$$ more careful cleanup, valgrind run... */ vec_free (am->msg_handlers); vec_free (am->msg_endian_handlers); vec_free (am->msg_print_handlers); }
static clib_error_t * sendmsg_helper (mc_socket_main_t * msm, int socket, struct sockaddr_in * tx_addr, u32 buffer_index) { vlib_main_t * vm = msm->mc_main.vlib_main; struct msghdr h; word n_bytes, n_bytes_tx, n_retries; memset (&h, 0, sizeof (h)); h.msg_name = tx_addr; h.msg_namelen = sizeof (tx_addr[0]); if (msm->iovecs) _vec_len (msm->iovecs) = 0; n_bytes = append_buffer_index_to_iovec (vm, buffer_index, &msm->iovecs); ASSERT (n_bytes <= msm->mc_main.transport.max_packet_size); if (n_bytes > msm->mc_main.transport.max_packet_size) clib_error ("sending packet larger than interace MTU %d bytes", n_bytes); h.msg_iov = msm->iovecs; h.msg_iovlen = vec_len (msm->iovecs); n_retries = 0; while ((n_bytes_tx = sendmsg (socket, &h, /* flags */ 0)) != n_bytes && errno == EAGAIN) n_retries++; if (n_bytes_tx != n_bytes) { clib_unix_warning ("sendmsg"); return 0; } if (n_retries) { ELOG_TYPE_DECLARE (e) = { .format = "sendmsg-helper: %d retries", .format_args = "i4", }; struct { u32 retries; } * ed = 0; ed = ELOG_DATA (&vm->elog_main, e); ed->retries = n_retries; } return 0; } static clib_error_t * tx_buffer (void * transport, mc_transport_type_t type, u32 buffer_index) { mc_socket_main_t *msm = (mc_socket_main_t *)transport; vlib_main_t * vm = msm->mc_main.vlib_main; mc_multicast_socket_t * ms = &msm->multicast_sockets[type]; clib_error_t * error; error = sendmsg_helper (msm, ms->socket, &ms->tx_addr, buffer_index); if (type != MC_TRANSPORT_USER_REQUEST_TO_RELAY) vlib_buffer_free_one (vm, buffer_index); return error; }
void cnat_port_free_v2 ( cnat_portmap_v2_t *pm, int index, port_pair_t pair_type, u16 base_port, u16 static_port_range) { cnat_portmap_v2_t *my_pm; uword bit; /* check for valid portmap */ if (PREDICT_FALSE(index > vec_len(pm))) { spp_printf(CNAT_INVALID_INDEX_TO_FREE_PORT, 0, 0); return; } my_pm = pm + index; bit = port2bit(base_port); #if DEBUG > 0 if(clib_bitmap_get_no_check(my_pm->bm, bit)) ASSERT(clib_bitmap_get_no_check(my_pm->bm, bit) == 0); #endif cgn_clib_bitmap_set_no_check(my_pm->bm, bit); my_pm->inuse -= 1; if(base_port >= static_port_range) { /* Clear the full flag. we can have a new dynamic session now */ my_pm->dyn_full = 0; } return; }
u8 * format_dpdk_flow (u8 * s, va_list * args) { u32 dev_instance = va_arg (*args, u32); u32 flow_index = va_arg (*args, u32); uword private_data = va_arg (*args, uword); dpdk_main_t *dm = &dpdk_main; dpdk_device_t *xd = vec_elt_at_index (dm->devices, dev_instance); dpdk_flow_entry_t *fe; if (flow_index == ~0) { s = format (s, "%-25s: %U\n", "supported flow actions", format_flow_actions, xd->supported_flow_actions); s = format (s, "%-25s: %d\n", "last DPDK error type", xd->last_flow_error.type); s = format (s, "%-25s: %s\n", "last DPDK error message", xd->last_flow_error.message ? xd->last_flow_error.message : "n/a"); return s; } if (private_data >= vec_len (xd->flow_entries)) return format (s, "unknown flow"); fe = vec_elt_at_index (xd->flow_entries, private_data); s = format (s, "mark %u", fe->mark); return s; }
static int flowprobe_template_add_del (u32 domain_id, u16 src_port, flowprobe_record_t flags, vnet_flow_data_callback_t * flow_data_callback, vnet_flow_rewrite_callback_t * rewrite_callback, bool is_add, u16 * template_id) { flow_report_main_t *frm = &flow_report_main; vnet_flow_report_add_del_args_t a = { .rewrite_callback = rewrite_callback, .flow_data_callback = flow_data_callback, .is_add = is_add, .domain_id = domain_id, .src_port = src_port, .opaque.as_uword = flags, }; return vnet_flow_report_add_del (frm, &a, template_id); } static void flowprobe_expired_timer_callback (u32 * expired_timers) { vlib_main_t *vm = vlib_get_main (); flowprobe_main_t *fm = &flowprobe_main; u32 my_cpu_number = vm->thread_index; int i; u32 poolindex; for (i = 0; i < vec_len (expired_timers); i++) { poolindex = expired_timers[i] & 0x7FFFFFFF; vec_add1 (fm->expired_passive_per_worker[my_cpu_number], poolindex); } }
void cpp_eval(char *buf) { stream_stash(make_file_string(buf)); Vector *toplevels = read_toplevels(); for (int i = 0; i < vec_len(toplevels); i++) emit_toplevel(vec_get(toplevels, i)); stream_unstash(); }
void efp_dipole_dipole_grad(const vec_t *d1, const vec_t *d2, const vec_t *dr, vec_t *force, vec_t *add1, vec_t *add2) { double r = vec_len(dr); double r3 = r * r * r; double r5 = r3 * r * r; double r7 = r5 * r * r; double d1dr = vec_dot(d1, dr); double d2dr = vec_dot(d2, dr); double t1 = 3.0 / r5; double t2 = t1 * vec_dot(d1, d2) - 15.0 / r7 * d1dr * d2dr; force->x = t2 * dr->x + t1 * (d2dr * d1->x + d1dr * d2->x); force->y = t2 * dr->y + t1 * (d2dr * d1->y + d1dr * d2->y); force->z = t2 * dr->z + t1 * (d2dr * d1->z + d1dr * d2->z); add1->x = d1->y * (d2->z / r3 - t1 * dr->z * d2dr) - d1->z * (d2->y / r3 - t1 * dr->y * d2dr); add1->y = d1->z * (d2->x / r3 - t1 * dr->x * d2dr) - d1->x * (d2->z / r3 - t1 * dr->z * d2dr); add1->z = d1->x * (d2->y / r3 - t1 * dr->y * d2dr) - d1->y * (d2->x / r3 - t1 * dr->x * d2dr); add2->x = d2->y * (d1->z / r3 - t1 * dr->z * d1dr) - d2->z * (d1->y / r3 - t1 * dr->y * d1dr); add2->y = d2->z * (d1->x / r3 - t1 * dr->x * d1dr) - d2->x * (d1->z / r3 - t1 * dr->z * d1dr); add2->z = d2->x * (d1->y / r3 - t1 * dr->y * d1dr) - d2->y * (d1->x / r3 - t1 * dr->x * d1dr); }
double efp_charge_charge_energy(double q1, double q2, const vec_t *dr) { double r = vec_len(dr); return q1 * q2 / r; }
int vl_msg_api_trace_free(api_main_t *am, vl_api_trace_which_t which) { vl_api_trace_t *tp; int i; switch(which) { case VL_API_TRACE_TX: tp = am->tx_trace; break; case VL_API_TRACE_RX: tp = am->rx_trace; break; default: /* duh? */ return -1; } /* Configured? */ if (!tp || tp->nitems == 0) return -1; tp->curindex = 0; tp->wrapped = 0; for (i = 0; i < vec_len(tp->traces); i++) { vec_free(tp->traces[i]); } vec_free(tp->traces); return 0; }
int64_t decode(void *buffer, size_t size, int64_t sum) { unsigned int i; C(table_t) foobarcontainer; FooBar(vec_t) list; FooBar(table_t) foobar; Bar(struct_t) bar; Foo(struct_t) foo; foobarcontainer = C(as_root(buffer)); sum += C(initialized(foobarcontainer)); sum += StringLen(C(location(foobarcontainer))); sum += C(fruit(foobarcontainer)); list = C(list(foobarcontainer)); for (i = 0; i < FooBar(vec_len(list)); ++i) { foobar = FooBar(vec_at(list, i)); sum += StringLen(FooBar(name(foobar))); sum += FooBar(postfix(foobar)); sum += (int64_t)FooBar(rating(foobar)); bar = FooBar(sibling(foobar)); sum += (int64_t)Bar(ratio(bar)); sum += Bar(size(bar)); sum += Bar(time(bar)); foo = Bar(parent(bar)); sum += Foo(count(foo)); sum += Foo(id(foo)); sum += Foo(length(foo)); sum += Foo(prefix(foo)); } return sum + 2 * sum; }
/* Construct a unit vector v2 in direction of input vector v1 */ void vec_unit( vec_t *v1, /* Input vector */ vec_t *v2) /* output unit vec */ { double mult = 1 / vec_len(v1); vec_scale(mult, v1, v2); }
double efp_quadrupole_quadrupole_energy(const double *quad1, const double *quad2, const vec_t *dr) { double r = vec_len(dr); double r2 = r * r; double r5 = r2 * r2 * r; double r7 = r5 * r2; double r9 = r7 * r2; double q1dr = quadrupole_sum(quad1, dr); double q2dr = quadrupole_sum(quad2, dr); double q1q2 = 0.0; double q1q2dr = 0.0; for (size_t a = 0; a < 3; a++) { double t1 = 0.0; double t2 = 0.0; for (size_t b = 0; b < 3; b++) { size_t idx = quad_idx(a, b); t1 += quad1[idx] * vec_get(dr, b); t2 += quad2[idx] * vec_get(dr, b); q1q2 += quad1[idx] * quad2[idx]; } q1q2dr += t1 * t2; } return (2.0 / r5 * q1q2 - 20.0 / r7 * q1q2dr + 35.0 / r9 * q1dr * q2dr) / 3.0; }
vec_t vec_normalize(vec_t a){ if (vec_zero(a)){ return a; }else{ return vec_scale(a,1.0/vec_len(a)); } }
void efp_charge_quadrupole_grad(double q1, const double *quad2, const vec_t *dr, vec_t *force, vec_t *add1, vec_t *add2) { double r = vec_len(dr); double r2 = r * r; double r5 = r2 * r2 * r; double r7 = r5 * r2; double t1x = q1 / r5 * -2.0 * (dr->x * quad2[quad_idx(0, 0)] + dr->y * quad2[quad_idx(0, 1)] + dr->z * quad2[quad_idx(0, 2)]); double t1y = q1 / r5 * -2.0 * (dr->x * quad2[quad_idx(1, 0)] + dr->y * quad2[quad_idx(1, 1)] + dr->z * quad2[quad_idx(1, 2)]); double t1z = q1 / r5 * -2.0 * (dr->x * quad2[quad_idx(2, 0)] + dr->y * quad2[quad_idx(2, 1)] + dr->z * quad2[quad_idx(2, 2)]); double g = 5.0 * q1 / r7 * quadrupole_sum(quad2, dr); force->x = g * dr->x + t1x; force->y = g * dr->y + t1y; force->z = g * dr->z + t1z; add1->x = 0.0; add1->y = 0.0; add1->z = 0.0; add2->x = t1z * dr->y - t1y * dr->z; add2->y = t1x * dr->z - t1z * dr->x; add2->z = t1y * dr->x - t1x * dr->y; }
void vlib_unix_error_report (vlib_main_t * vm, clib_error_t * error) { unix_main_t *um = &unix_main; if (um->flags & UNIX_FLAG_INTERACTIVE || error == 0) return; { char save; u8 *msg; u32 msg_len; msg = error->what; msg_len = vec_len (msg); /* Null Terminate. */ save = msg[msg_len - 1]; msg[msg_len - 1] = 0; syslog (LOG_ERR | LOG_DAEMON, "%s", msg); msg[msg_len - 1] = save; } }
static vnet_config_t * find_config_with_features (vlib_main_t * vm, vnet_config_main_t * cm, vnet_config_feature_t * feature_vector) { u32 last_node_index = ~0; vnet_config_feature_t * f; u32 * config_string; uword * p; vnet_config_t * c; config_string = cm->config_string_temp; cm->config_string_temp = 0; if (config_string) _vec_len (config_string) = 0; vec_foreach (f, feature_vector) { /* Connect node graph. */ f->next_index = add_next (vm, cm, last_node_index, f->node_index); last_node_index = f->node_index; /* Store next index in config string. */ vec_add1 (config_string, f->next_index); /* Store feature config. */ vec_add (config_string, f->feature_config, vec_len (f->feature_config)); }
// // normalize a vector // void normalize(Vector *u) { float p; p = vec_len(*u); (*u).x = (*u).x / p; (*u).y = (*u).y / p; (*u).z = (*u).z / p; }
vec_t vec_norm(vec_t a){ float len = vec_len(a); if(len == 0.0f){ return vec_new(1.0f,0.0f,0.0f,0.0f); }else{ return vec_scale(1.0f/len,a); } }
double efp_charge_dipole_energy(double q1, const vec_t *d2, const vec_t *dr) { double r = vec_len(dr); double r3 = r * r * r; return -q1 / r3 * vec_dot(d2, dr); }