int get_node_count(group *g) { int count = 1; if(g->negative != NULL) { count += get_node_count(g->negative); count += get_node_count(g->positive); } return count; }
/** * Prints the graph by printing Node informations and Edge informations while iterating it * Testcase:Node:%d,%d\n with the linkaddr.u8[0] and the depth * Testcase:Edge:%d,%d\n with the linkaddr.u8[0] of the source and the linkaddr.u8[0] of the drain */ static void debug_k_hop_timer_event(void *ptr) { printf("Print Graph for Node %d\n", linkaddr_node_addr.u8[0]); uint8_t count = 0; uint8_t i = 0; printf("Saved Nodes:%d\n", get_node_count()); printf("Saved Edges:%d\n", get_edge_count()); //print nodes p_hop_t *hops = get_hop_counts(&count); printf("Count Node hops:%d\n", count); //also print root printf("Testcase:Node:%d,%d\n", linkaddr_node_addr.u8[0], 0); for (i = 0; i < count; i++) { printf("Testcase:Node:%d,%d\n", hops[i].addr.u8[0], hops[i].hop_count); } free(hops); //print edges p_edge_t **edge_array = get_all_edges(&count); printf("Count Edge:%d\n", count); for (i = 0; i < count; i++) { printf("Testcase:Edge:%d,%d\n", edge_array[i]->src.u8[0], edge_array[i]->dst.u8[0]); } }
int log_energymap(call_t *c) { struct entitydata *entitydata = get_entity_private_data(c); int i = get_node_count(); FILE *file = NULL; char file_map[100]; double time = get_time() * 0.000001; /* create file */ sprintf(file_map, "%s/%s.%.0lf.data", entitydata->directory, entitydata->map_prefix, time); if ((file = fopen(file_map, "w+")) == NULL) { fprintf(stderr, "My monitor: can not open file %s in monitor_event()\n", file_map); return -1; } /* log energy map */ while (i--) { call_t c0 = {-1, i, -1}; position_t *position = get_node_position(c0.node); fprintf(file, "%d %lf %lf %lf %lf\n", c0.node, position->x, position->y, position->z, battery_status(&c0)); } /* log virtual nodes for the 4 area corners */ fprintf(file, "%d %lf %lf %lf %lf\n", -1, 0.0, 0.0, 0.0, 1.0); fprintf(file, "%d %lf %lf %lf %lf\n", -1, get_topology_area()->x, 0.0, 0.0, 1.0); fprintf(file, "%d %lf %lf %lf %lf\n", -1, 0.0, get_topology_area()->y, 0.0, 1.0); fprintf(file, "%d %lf %lf %lf %lf\n", -1, get_topology_area()->x, get_topology_area()->y, 0.0, 1.0); fclose(file); return 0; }
/* ************************************************** */ void do_end(void) { int i = get_node_count(); /* unsetnode */ while (i--) { int j; node_t *node = get_node_by_id(i); if ((node->state == NODE_DEAD) || (node->state == NODE_UNDEF)) { continue; } for (j = 0; j < bundles.elts[node->bundle].entity.size; j++) { entity_t *entity = get_entity_by_id(bundles.elts[node->bundle].entity.elts[j]); call_t c = {entity->id, node->id, -1}; if ((entity)->unsetnode) { (entity)->unsetnode(&c); } } } /* unsetnode */ i = entities.size; while (i--) { entity_t *entity = get_entity_by_id(i); call_t c = {entity->id, -1, -1}; if ((entity)->destroy) { (entity)->destroy(&c); } } }
/* Find all the neighbors (i.e. nodes in range) of the current node */ int find_neighbors(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); struct neighbor *neighbor = NULL; nodeid_t i; double dist = 0; int nb_neigh = 0; /* Parse all the nodes in the simulation: and find the ones * that are in range of that node */ for(i = 0; i < get_node_count(); i++) { /* Do not include myself */ if (i == c->node) { continue; } dist = distance(get_node_position(c->node), get_node_position(i)); if (dist <= nodedata->range) { /* Add the node in the list of neighbors */ neighbor = (struct neighbor *) malloc(sizeof(struct neighbor)); neighbor->id = i; neighbor->position.x = get_node_position(i)->x; neighbor->position.y = get_node_position(i)->y; neighbor->position.z = get_node_position(i)->z; neighbor->time = get_time(); //PRINT_ROUTING("Node %d is added to neighbor list of node %d\n", // neighbor->id, c->node); das_insert(nodedata->neighbors, (void *) neighbor); nb_neigh++; } } return nb_neigh; }
int unsetnode(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); struct route *route; int i = get_node_count(); while (i--) { if ((route = (struct route *) hadas_get(nodedata->routes, (void *) ((unsigned long) i))) != NULL) { free(route); } } hadas_destroy(nodedata->routes); free(nodedata); return 0; }
// // Function: move() // // Purpose: Moves ALL the nodes for the member func by the delta passed in. // // Arguments: // // int x_delta - how many 'x' elements (in the values[] array) to move each node by // // Returns: // // void // // Author: Michael Zarozinski // Date: 7/99 // // Modification History // Author Date Modification // ------ ---- ------------ // // void MemberFuncBase::move(int x_delta) { if (x_delta == 0) return; // nothing to do! // move all the nodes... // we need to be careful about the order we move them in. // if they are being move to the right (positive offset) we need to // move the last point and work our way to the first point so we don't // cross any points if the offset is large. // likewize if we're moving to the left (negative offset) move them in // order (first to last) int start, end, increment; // values that determine how we loop int node_count = get_node_count(); if (x_delta < 0) { // moving to the left start = 0; end = node_count; increment = 1; // adjust the delta so we don't "collapse" the term if (nodes[0].x + x_delta < 0) x_delta = -nodes[0].x; } // end if offset negative else { // offset is positive start = node_count - 1; end = -1; increment = -1; if (nodes[node_count - 1].x + x_delta > FuzzyVariableBase::get_x_array_max_idx()) x_delta = ( FuzzyVariableBase::get_x_array_max_idx()) - nodes[node_count - 1].x; } // end if offset positive // now move them all (note the 'y' direction is invariant when moving all nodes at once) for (int i = start; i != end; i += increment) { move_node(i, nodes[i].x + x_delta, nodes[i].y ); } // end loop through nodes } // end MemberFuncBase::move()
/* ************************************************** */ int init(call_t *c, void *params) { struct entitydata *entitydata = malloc(sizeof(struct entitydata)); char filenode[100]; param_t *param; /* default values */ entitydata->callbacks = das_create(); entitydata->nbr_nodes = get_node_count(); strcpy(entitydata->map_prefix, "energymap"); strcpy(entitydata->directory,"./"); entitydata->map_period = 1000000000; das_init_traverse(params); while ((param = (param_t *) das_traverse(params)) != NULL) { int i = 0; if (!strcmp(param->key, "directory")) { strcpy(entitydata->directory, param->value); goto parse_key_ok; } if (!strcmp(param->key, "prefix")) { strcpy(entitydata->map_prefix, param->value); goto parse_key_ok; } if (!strcmp(param->key, "map-period")) { if (get_param_time(param->value, &(entitydata->map_period))) { goto error; } goto parse_key_ok; } (void) fprintf(stderr, "WARNING: token %s is not recognized\n", param->key); parse_key_ok: i++; } /* open node activity file */ sprintf(filenode, "%s/%s.data", entitydata->directory, "activenodes"); if ((entitydata->filenode = fopen(filenode, "w")) == NULL) { fprintf(stderr, "NRJ monitor: can not open file %s !\n", filenode); goto error; } set_entity_private_data(c, entitydata); return 0; error: free(entitydata); return -1; }
/* ************************************************** */ int init(call_t *c, void *params) { struct entitydata *entitydata = malloc(sizeof(struct entitydata)); param_t *param; char *filepath = NULL; int src, dst; double proba; FILE *file; char str[128]; /* default values */ filepath = "propagation.data"; /* get parameters */ das_init_traverse(params); while ((param = (param_t *) das_traverse(params)) != NULL) { if (!strcmp(param->key, "file")) { filepath = param->value; } } /* open file */ if ((file = fopen(filepath, "r")) == NULL) { fprintf(stderr, "filestatic: can not open file %s in init()\n", filepath); goto error; } /* extract link success probability */ entitydata->node_cnt = get_node_count(); entitydata->success = malloc(sizeof(double) * entitydata->node_cnt *entitydata->node_cnt); for (src = 0; src < entitydata->node_cnt; src++) { for (dst = 0; dst < entitydata->node_cnt; dst++) { *(entitydata->success + (src * entitydata->node_cnt) + dst) = MIN_DBM; } } fseek(file, 0L, SEEK_SET); while (fgets(str, 128, file) != NULL) { sscanf(str, "%d %d %lf\n", &src, &dst, &proba); *(entitydata->success + (src * entitydata->node_cnt) + dst) = proba; } fclose(file); set_entity_private_data(c, entitydata); return 0; error: free(entitydata); return -1; }
static void worldsens_rx_disconnect(struct _worldsens_c_disconnect *pkt) { node_t *node = get_node_by_id(worldsens_get_wsnet_node_id(pkt->node_id)); if (node->worldsens != NODE_CONNECTED) { return; } node->worldsens = NODE_DISCONNECTED; node_kill(node->id); if (ws_connected == 0 && ws_count == get_node_count()) { end_simulation(); } }
// initialisation des noeuds a partir du fichier xml int setnode(call_t *c, void *params) { struct nodedata *nodedata = malloc(sizeof(struct nodedata)); struct protocoleData *entitydata = malloc(sizeof(struct protocoleData)); nodedata->overhead = -1; nodedata->oneHopNeighbourhood = 0; nodedata->twoHopNeighbourhood = 0; nodedata->g2hop = malloc(sizeof(graphe)); initGraphe(nodedata->g2hop, c->node); nodedata->BIP_tree = 0; nodedata->nbr_evenement = 0; //STATS nodedata->lastIDs = malloc(get_node_count()*sizeof(int)); nodedata->energiesRem = malloc(get_node_count()*sizeof(double)); set_node_private_data(c, nodedata); SHOW_GRAPH("N: %d %lf %f\n",c->node,get_node_position(c->node)->x,get_node_position(c->node)->y); // printf("Node %d at ( %.1lf ; %.1lf ; %.1lf )\n", c->node,get_node_position(c->node)->x,get_node_position(c->node)->y,get_node_position(c->node)->z); return 0; }
void MemberFuncBase::save_to_fcl_file(std::ofstream& file_contents) { char val[6]; // temp string to hold the string version of a number int precision ; // how many decimal places to show // list the points... for (int i = 0; i < get_node_count(); i++) { // convert the index in the values array to an 'x' value RealType fvalue = get_parent()->convert_idx_to_value(get_node_x(i)); // if there is a decimal point for this, display only 2 decimal places, // else don't display any (this just makes the FCL file easier to read) if (fmod(fvalue, 1) == 0) precision = 0; else precision = 2; // trim 'x' value to the specified precision sprintf( val, "%.*lf", precision, fvalue ); file_contents << "(" << val << ", "; // convert to 'y' coordinates fvalue = static_cast<RealType>(get_node_y(i)) / static_cast<RealType>(FuzzyVariableBase::get_dom_array_max_idx()); if (fmod(fvalue, 1) == 0) precision = 0; else precision = 2; sprintf( val, "%.*lf", precision, fvalue ); file_contents << val << ") "; } // end loop through nodes // add ending semi-colon file_contents << ";"; } // end MemberFuncBase::save_to_file()
int bootstrap(call_t *c) { struct nodedata *nodedata = get_node_private_data(c); struct protocoleData *entitydata = get_entity_private_data(c); call_t c0 = {get_entity_bindings_down(c)->elts[0], c->node, c->entity}; /* get mac header overhead */ nodedata->overhead = GET_HEADER_SIZE(&c0); int i; for(i = 0 ; i < get_node_count() ; i++) { nodedata->lastIDs[i] = -1; nodedata->energiesRem[i] = battery_remaining(c) - 2*getCoutFromDistance(getRange(c), entitydata->alpha, entitydata->c); } broadcast_hello(c, NULL); uint64_t at=get_time_now()+time_seconds_to_nanos(2); scheduler_add_callback(at, c, broadcast_hello2, NULL); return 0; }
void get_shader_data(world *w, scene_shader_data &data, unsigned int row_pad) { data.row_pad = row_pad; data.sphere_count = w->sphere_count; data.sphere_data_rows = (data.sphere_count + row_pad - 1) / row_pad; data.sphere_geometries = new float[4 * row_pad * data.sphere_data_rows]; data.sphere_colors = new float[3 * row_pad * data.sphere_data_rows]; for(int i = 0; i < w->sphere_count; i++) { const sphere &s = w->spheres[i]; data.sphere_geometries[i * 4 + 0] = s.center.x; data.sphere_geometries[i * 4 + 1] = s.center.y; data.sphere_geometries[i * 4 + 2] = s.center.z; data.sphere_geometries[i * 4 + 3] = s.radius; data.sphere_colors[i * 3 + 0] = s.color.x; data.sphere_colors[i * 3 + 1] = s.color.y; data.sphere_colors[i * 3 + 2] = s.color.z; } data.group_count = get_node_count(w->root); data.group_data_rows = (data.group_count + row_pad - 1) / row_pad; data.group_directions = new float[3 * row_pad * data.group_data_rows]; data.group_boxmin = new float[3 * row_pad * data.group_data_rows]; data.group_boxmax = new float[3 * row_pad * data.group_data_rows]; data.group_children = new float[2 * row_pad * data.group_data_rows]; data.group_objects = new float[2 * row_pad * data.group_data_rows]; data.group_hitmiss = new float[2 * row_pad * data.group_data_rows]; int used; generate_group_indices(w->root, 0, &used, data.group_count, data.row_pad); assert(used == data.group_count); data.tree_root = w->root->my_index; store_group_data(w->root, data); create_hitmiss(w->root, data); // xxx_dump_group_code(w->root, "g"); }
int MemberFuncBase::get_end_x(void) const { return(nodes[get_node_count() - 1].x); }
int MemberFuncBase::get_center_x(void) const { return nodes[0].x + ((nodes[get_node_count() - 1].x - nodes[0].x)/2); };
long get_item_count(void) { return get_node_count(item_space_root); }
void MEDIA_TX(call_t *c, packet_t *packet) { int i = get_node_count(); node_t *node = get_node_by_id(c->node); uint64_t clock; /* check wether node is active */ if (node->state != NODE_ACTIVE) { packet_dealloc(packet); return; } /* edit by Loic Lemaitre */ if (node->worldsens == NODE_LOCAL) { /* WORLDSENS MODE? -> radio part is simulated in wsim */ /* fill packet info */ packet->node = c->node; packet->antenna = c->from; packet->txdBm = radio_get_power(c); packet->channel = radio_get_channel(c); packet->modulation = radio_get_modulation(c); packet->Tb = radio_get_Tb(c); //packet->duration = packet->size * packet->Tb * 8; /* edit by Quentin Lampin <*****@*****.**> */ packet->duration = packet->real_size * packet->Tb; /* end of edition */ packet->clock0 = get_time(); packet->clock1 = packet->clock0 + packet->duration; /* scheduler tx_end event */ scheduler_add_tx_end(packet->clock1, c, packet); } /* end of edition */ /* scheduler rx_begin event */ #ifdef N_DAS_O if (propagation_range) { void *rx_nodes; node_t *rx_node; rx_nodes = spadas_rangesearch(location, NULL, &(node->position), propagation_range); while ((rx_node = (node_t *) das_pop(rx_nodes)) != NULL) { double derive = distance(&(node->position), &(rx_node->position)) / 0.3; bundle_t *bundle = get_bundle_by_id(rx_node->bundle); int i; if (rx_node->state == NODE_DEAD) { continue; } for (i = 0; i < bundle->antenna.size; i++) { entity_t *entity = get_entity_by_id(bundle->antenna.elts[i]); call_t c0 = {entity->id, rx_node->id, -1}; packet_t *packet_rx = packet_rxclone(packet); clock = packet->clock0 + ((uint64_t) derive); packet_rx->clock0 = clock; packet_rx->clock1 = clock + packet->duration; scheduler_add_rx_begin(clock, &c0, packet_rx); } } das_destroy(rx_nodes); } else { while (i--) { node_t *rx_node = get_node_by_id(i); double derive = distance(&(node->position), &(rx_node->position)) / 0.3; bundle_t *bundle = get_bundle_by_id(rx_node->bundle); int i; if (rx_node->state == NODE_DEAD) { continue; } for (i = 0; i < bundle->antenna.size; i++) { entity_t *entity = get_entity_by_id(bundle->antenna.elts[i]); call_t c0 = {entity->id, rx_node->id, -1}; packet_t *packet_rx = packet_rxclone(packet); clock = packet->clock0 + ((uint64_t) derive); packet_rx->clock0 = clock; packet_rx->clock1 = clock + packet->duration; scheduler_add_rx_begin(clock, &c0, packet_rx); } } } #else /* N_DAS_O */ while (i--) { node_t *rx_node = get_node_by_id(i); double dist = distance(&(node->position), &(rx_node->position)); double derive = dist / 0.3; bundle_t *bundle = get_bundle_by_id(rx_node->bundle); int i; if (rx_node->state == NODE_DEAD) { continue; } if ((propagation_range) && (dist > propagation_range)) { continue; } for (i = 0; i < bundle->antenna.size; i++) { entity_t *entity = get_entity_by_id(bundle->antenna.elts[i]); call_t c0 = {entity->id, rx_node->id, -1}; packet_t *packet_rx = packet_rxclone(packet); clock = packet->clock0 + ((uint64_t) derive); packet_rx->clock0 = clock; packet_rx->clock1 = clock + packet->duration; scheduler_add_rx_begin(clock, &c0, packet_rx); } } #endif /* N_DAS_O */ }
// // Function: MemberFuncTri() // // Purpose: Constructor // // Arguments: // // FuzzySetBase* _parent - Set this member function is part of // // Returns: // // nothing // // Author: Michael Zarozinski // Date: 8/99 // // Modification History // Author Date Modification // ------ ---- ------------ // // MemberFuncTri::MemberFuncTri(FuzzySetBase* _parent) : MemberFuncBase(_parent), FFLLBase(_parent) { // create the nodes array alloc_nodes( get_node_count() ); } // MemberFuncTri::MemberFuncTri()
long get_user_count(void) { return get_node_count(user_space_root); }
/* ************************************************** */ int init(call_t *c, void *params) { struct _env_data *entitydata = malloc(sizeof(struct _env_data)); char *filepath = "collection_ctrl.data"; int line; struct _collec_event *event; param_t *param; char str[128]; char event_str[30]; FILE *file; /* We use a sorted list for the events (sorted by time) */ entitydata->events = sodas_create(event_compare); /* Get parameters from the configuration file */ das_init_traverse(params); while ((param = (param_t *) das_traverse(params)) != NULL) { if (!strcmp(param->key, "file")) { filepath = param->value; } } /* Open the data collection scheme file */ if ((file = fopen(filepath, "r")) == NULL) { DBG("ERROR: cannot open file %s in init()\n", filepath); goto error; } /* Save the events in a data structure */ /* Structure of the file is: * <time> <node id> <event type> <value> */ fseek(file, 0L, SEEK_SET); line = 1; while (fgets(str, 128, file) != NULL) { event = malloc(sizeof(struct _collec_event)); memset(event_str, 0, sizeof(event_str)); if (event == NULL) { DBG("ERROR: malloc failed\n"); goto error; } if (str[0] == '#' || str[0] == '\n') { /* Line is a comment or an empty line */ line++; continue; } if (sscanf(str, "%"PRId64" %d %s %d\n", &event->time, &event->node_id, event_str, &event->event_value) != 4) { DBG("ERROR: cannot read event in file %s, line %d\n", filepath, line); free(event); goto error; } if (!strncmp(event_str, "APP_TIME_DRV", sizeof(event_str))) { event->event_type = APP_TIME_DRV; } else if (!strncmp(event_str, "APP_EVENT_DRV", sizeof(event_str))) { event->event_type = APP_EVENT_DRV; } else if (!strncmp(event_str, "APP_QUERY_DRV", sizeof(event_str))) { event->event_type = APP_QUERY_DRV; } else if (!strncmp(event_str, "APP_PAYLOAD_SIZE", sizeof(event_str))) { event->event_type = APP_PAYLOAD_SIZE; } else if (!strncmp(event_str, "ENV_EVENT", sizeof(event_str))) { event->event_type = ENV_EVENT; } else if (!strncmp(event_str, "QUERY_MSG", sizeof(event_str))) { event->event_type = QUERY_MSG; } else if (!strncmp(event_str, "CHANGE_APP_DST", sizeof(event_str))) { event->event_type = CHANGE_APP_DST; } else { DBG("ERROR: event type %s unknown in file %s, line %d\n", event_str, filepath, line); free(event); goto error; } //DBG("EVENT: %"PRId64" %d %d %d\n", // event->time, event->node_id, // event->event_type, event->event_value); if (event->node_id >= get_node_count()) { DBG("ERROR: node id %d (line %d) does not exist, " "skipping this event \n", event->node_id, line); free(event); } else { /* Insert the event in the sorted data structure */ sodas_insert(entitydata->events, &event->time, event); } line++; } /* Close the opened file */ fclose(file); set_entity_private_data(c, entitydata); return 0; error: free(entitydata); return -1; }