自学教程：C++ vec_len函数代码示例

voidvlib_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 {

inttest1 (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++;  }));

intmain (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. */voidvlib_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 voiddump_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]);	  }    }}

voidefp_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 voidvl_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 intflowprobe_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 voidflowprobe_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();}

voidefp_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);}

doubleefp_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);}

doubleefp_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));	}}

voidefp_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;}

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);	}}

doubleefp_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);}