Sensix Wireless Sensor Network Middleware    Home    Project Page    Download    CVS  Hosted by

/home/brennan/Software/sensix/tools/sim/sim_net.c Go to the documentation of this file. /* * Copyright 2008. Los Alamos National Security, LLC. This material * was produced under U.S. Government contract DE-AC52-06NA25396 for * Los Alamos National Laboratory (LANL), which is operated by Los * Alamos National Security, LLC, for the Department of Energy. The * U.S. Government has rights to use, reproduce, and distribute this * software. NEITHER THE GOVERNMENT NOR LOS ALAMOS NATIONAL SECURITY, * LLC, MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL * LIABILITY FOR THE USE OF THIS SOFTWARE. If software is modified to * produce derivative works, such modified software should be clearly * marked, so as not to confuse it with the version available from LANL. * * Additionally, this program is free software; you can redistribute * it and/or modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; version 2 of * the License. Accordingly, this program is distributed in the hope * it will be useful, but WITHOUT ANY WARRANTY; without even the * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. */ #define _GNU_SOURCE #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <errno.h> #include <string.h> #include <sys/time.h> #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <netdb.h> #include <math.h> #include <signal.h> #include <pthread.h> #include <igraph/igraph.h> #define norace #include "platform.pc/external_comm.h" #include "sense_endian.h" #include "SensixMsg.h" #define MAX_CLIENTS 1024 #define MAX_MOTES 100000 #define MAX_ADC_PORTS 16 #define SLEEP_MSECS 500 #define TIME_ADJUST 4000.0 // to get msecs #define DATA_BUFFER_SIZE 256 #define MAX_MSG_SIZE 512 #define ACK 65 #define NACK 66 #define APP "NETSIM: " #define BROADCAST 0xffff #define INSTRUMENTATION //#define DEBUG_CLIENTS #define DEBUG_VERBOSE #define DEBUG_RADIO //#define DEBUG_RADIO_RAW #define DEBUG_ADC //#define ACK // Swiped from tinyos1.x/tos/platform/pc/GuiMsg.h // (inclusion is too messy) enum { AM_DEBUGMSGEVENT = 1, AM_RADIOMSGSENTEVENT = 1 << 1, AM_UARTMSGSENTEVENT = 1 << 2, AM_ADCDATAREADYEVENT = 1 << 3, AM_TOSSIMINITEVENT = 1 << 4, AM_INTERRUPTEVENT = 1 << 5, AM_LEDEVENT = 1 << 6, AM_TURNONMOTECOMMAND = 1 << 12, AM_TURNOFFMOTECOMMAND, AM_RADIOMSGSENDCOMMAND, AM_UARTMSGSENDCOMMAND, AM_SETLINKPROBCOMMAND, AM_SETADCPORTVALUECOMMAND, AM_INTERRUPTCOMMAND, AM_SETRATECOMMAND, AM_SETDBGCOMMAND, AM_VARIABLERESOLVECOMMAND, AM_VARIABLERESOLVERESPONSE, AM_VARIABLEREQUESTCOMMAND, AM_VARIABLEREQUESTRESPONSE, AM_GETMOTECOUNTCOMMAND, AM_GETMOTECOUNTRESPONSE, AM_SETEVENTMASKCOMMAND, AM_BEGINBATCHCOMMAND, AM_ENDBATCHCOMMAND, }; typedef struct GuiMsg { uint16_t msgType; uint16_t moteID; long long time; uint16_t payLoadLen; } GuiMsg_t; #define GUI_MSG_HEADER_LENGTH 14 typedef struct { uint8_t port; uint8_t _pad; uint16_t data; } adc_request_t; typedef struct { uint16_t addr; uint8_t type; uint8_t grp; uint8_t len; char data[MAX_MSG_SIZE]; uint16_t crc; uint16_t strength; uint8_t ack; uint8_t _pad2; uint16_t time; uint8_t send_sec_mode; uint8_t recv_sec_mode; } radio_msg_t; typedef struct { int evtfd; int cmdfd; int idx; unsigned char is_tos; unsigned long addr; } client_t; static igraph_t network_graph; static unsigned int num_threads; static long long sim_time; static unsigned int not_done; static int num_clients; static int num_motes; static int first; static client_t clients[MAX_CLIENTS]; static int expected_clients; static int adc_values[MAX_MOTES][MAX_ADC_PORTS]; pthread_t threads[MAX_CLIENTS + 1]; pthread_mutex_t num_threads_mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t sim_time_mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t not_done_mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t clients_mutex = PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t adc_mutex = PTHREAD_MUTEX_INITIALIZER; static void msg_hdr_swap(GuiMsg_t *host) { _byte_swap((uint8_t*)&host->msgType, sizeof(host->msgType)); _byte_swap((uint8_t*)&host->moteID, sizeof(host->moteID)); _byte_swap((uint8_t*)&host->time, sizeof(host->time)); _byte_swap((uint8_t*)&host->payLoadLen, sizeof(host->payLoadLen)); } static void adc_msg_swap(adc_request_t *req) { _byte_swap((uint8_t*)&req->data, sizeof(req->data)); } static void radio_msg_swap(radio_msg_t *msg) { _byte_swap((uint8_t*)&msg->addr, sizeof(msg->addr)); _byte_swap((uint8_t*)&msg->crc, sizeof(msg->crc)); _byte_swap((uint8_t*)&msg->strength, sizeof(msg->strength)); _byte_swap((uint8_t*)&msg->time, sizeof(msg->time)); } static int recv_all(int sock, void *buf, int len) { int total = 0; while (total < len) { int bytes; if ((bytes = read(sock, buf + total, len - total)) <= 0) { if (bytes < 0) perror(APP "read"); return bytes; } total += bytes; } return total; } static int send_all(int sock, void *buf, int len) { int total = 0; while (total < len) { int bytes; if ((bytes = write(sock, buf + total, len - total)) <= 0) { if (bytes < 0) perror(APP "write"); return bytes; } total += bytes; } return total; } static int acknowledge(int sock) { unsigned char ack = 0; int bytes; if ((bytes = write(sock, &ack, 1)) < 0) perror(APP "write"); return bytes; } #ifdef ACK static int await_ack(int sock) { unsigned char ack = 0; int bytes; if ((bytes = read(sock, &ack, 1)) < 0) perror(APP "read"); return bytes; } #endif static int are_connected(uint16_t a, uint16_t b) { int adjacent = 0; igraph_vs_t v_sel; igraph_vit_t v_iter; if (igraph_vs_adj(&v_sel, a, IGRAPH_OUT) < 0) { perror(APP "igraph_vs_adj"); return -1; } if (igraph_vit_create(&network_graph, v_sel, &v_iter) < 0) { perror(APP "igraph_vit_create"); return -1; } while (!IGRAPH_VIT_END(v_iter)) { if (b == VAN(&network_graph, "id", IGRAPH_VIT_GET(v_iter))) { adjacent = 1; break; } IGRAPH_VIT_NEXT(v_iter); } igraph_vit_destroy(&v_iter); igraph_vs_destroy(&v_sel); return adjacent; } static int num_direct_connections(uint16_t from) { igraph_integer_t size = 0; igraph_vs_t v_sel; if (igraph_vs_adj(&v_sel, from, IGRAPH_OUT) < 0) { perror(APP "igraph_vs_adj"); return -1; } igraph_vs_size(&network_graph, &v_sel, &size); igraph_vs_destroy(&v_sel); return (int)size; } static int get_direct_connections(uint16_t from, int motes[], int num) { int i = 0; igraph_vs_t v_sel; igraph_vit_t v_iter; if (igraph_vs_adj(&v_sel, from, IGRAPH_OUT) < 0) { perror(APP "igraph_vs_adj"); return -1; } if (igraph_vit_create(&network_graph, v_sel, &v_iter) < 0) { perror(APP "igraph_vit_create"); return -1; } while (!IGRAPH_VIT_END(v_iter) && i < num) { motes[i] = VAN(&network_graph, "id", IGRAPH_VIT_GET(v_iter)); IGRAPH_VIT_NEXT(v_iter); } igraph_vit_destroy(&v_iter); igraph_vs_destroy(&v_sel); return 0; } static void send_to_networks(uint16_t from, uint16_t to, int sims[], int num, int **motes) { int i; for (i = 0; i < num; i++) { if (to != BROADCAST) { if (are_connected(to, from)) { sims[i] = 1; motes[i] = (int*) malloc(sizeof(int) * sims[i]); memset(motes[i], 0, sims[i]); //break; } } else { sims[i] = num_direct_connections(from); motes[i] = (int*) malloc(sizeof(int) * sims[i]); memset(motes[i], 0, sims[i]); get_direct_connections(from, motes[i], sims[i]); } } } static int forward_message(int idx, uint16_t to, uint16_t from, GuiMsg_t *msg_hdr, radio_msg_t *msg, char evt) { int msg_len; GuiMsg_t header; radio_msg_t message; int fd = clients[idx].cmdfd; if (evt) fd = clients[idx].evtfd; if (to == from) return -1; memcpy(&header, msg_hdr, sizeof(GuiMsg_t)); memcpy(&message, msg, sizeof(radio_msg_t)); msg_len = msg_hdr->payLoadLen; #ifdef DEBUG_RADIO fprintf(stderr, "%s Sending radio message from mote %u to mote %u.\n", APP, from, to); #ifdef DEBUG_VERBOSE { int i; fprintf(stderr, "%s Addr: %hu, Type: %hhu, Group: %hhu, Len: %hhu\n", APP, message.addr, message.type, message.grp, message.len); fprintf(stderr, "%s Data: ", APP); for (i = 0; i < message.len; i++) fprintf(stderr, "%hhu ", message.data[i]); fprintf(stderr, "\n%s crc: %hu, str: %hu, ack: %hhu, time: %hu, " "sendSecMode: %hhu, recvSecMode: %hhu\n", APP, message.crc, message.strength, message.ack, message.time, message.send_sec_mode, message.recv_sec_mode); #ifdef DEBUG_RADIO_RAW fprintf(stderr, "Raw: "); for (i = 0; i < header.payLoadLen; i++) fprintf(stderr, " %hhu", ((unsigned char*)&message)[i]); fprintf(stderr, "\n"); #endif } #endif #endif msg_hdr_swap(&header); if (send_all(fd, &header, GUI_MSG_HEADER_LENGTH) < 0) { perror(APP "send"); if (errno == EPIPE) return -1; } radio_msg_swap(&message); if (send_all(fd, &message, msg_len) < 0) { perror(APP "send"); if (errno == EPIPE) return -1; } #ifdef ACK { int numbytes; if ((numbytes = await_ack(fd)) < 0) { if (numbytes == 0) return -1; } } #endif return 0; } static int load_data(FILE* data_file) { // NB: data file is of the format - time:mote:port:value long long stime; char *line = NULL; size_t len = 0; int mote = -1, port = -1, value = -1; int parsed, ready = 0; long sleep_time = 0; long long data_time = 0; pthread_mutex_lock(&clients_mutex); if (num_motes >= expected_clients) ready = 1; pthread_mutex_unlock(&clients_mutex); if (!ready) { usleep(SLEEP_MSECS * 1000); return 1; } if (getdelim(&line, &len, (int)':', data_file) < 0) { if (errno == 0) // EOF encountered return 0; perror(APP "getdelim"); if (line) free(line); return -1; } if ((parsed = sscanf(line, "%Ld:", &data_time)) < 0) perror(APP "sscanf"); if (parsed < 1) fprintf(stderr, "%s Failed to parse data: (%d) %s\n", APP, parsed, line); free(line); line = NULL; do { if (sleep_time > 0) usleep(sleep_time); pthread_mutex_lock(&sim_time_mutex); stime = (long long) floor((double)sim_time / TIME_ADJUST); pthread_mutex_unlock(&sim_time_mutex); sleep_time = (data_time - stime) * (int)TIME_ADJUST; } while (sleep_time > MAX_MOTES); #if defined(DEBUG_ADC) && defined(DEBUG_VERBOSE) fprintf(stderr, "%s %Ld msecs, data: %Ld msecs\n", APP, stime, data_time); #endif if ((len = getline(&line, &len, data_file)) < 0) { perror(APP "getline"); free(line); return 0; } if (len == 0) return 1; if ((parsed = sscanf(line, "%d:%d:%d", &mote, &port, &value) < 0)) { perror(APP "sscanf"); free(line); return 0; } /* TODO: for some reason this line is triggered regardless of matches if (parsed < 3) { fprintf(stderr, "%s Failed to parse: (%d: %d, %d, %d) %s", APP, parsed, mote, port, value, line); free(line); continue; } */ free(line); pthread_mutex_lock(&adc_mutex); adc_values[mote][port] = value; pthread_mutex_unlock(&adc_mutex); return 1; } void *service_thread(void *idx_ptr) { unsigned int keep_going = 1, not_ready = 1; int this_client = -1; int evtfd, cmdfd; this_client = (int)idx_ptr; if (this_client < 0 || this_client > MAX_CLIENTS) { fprintf(stderr, "%s Bad index %d\n", APP, this_client); exit(1); } while (keep_going && not_ready) { sleep(1); pthread_mutex_lock(&clients_mutex); if (clients[this_client].evtfd > 0 && clients[this_client].cmdfd > 0) not_ready = 0; pthread_mutex_unlock(&clients_mutex); pthread_mutex_lock(&not_done_mutex); keep_going = not_done; pthread_mutex_unlock(&not_done_mutex); } evtfd = clients[this_client].evtfd; cmdfd = clients[this_client].cmdfd; #ifdef DEBUG_CLIENTS fprintf(stderr, "%s Client %d joined.\n", APP, this_client); #endif while (keep_going) { struct timeval tv; fd_set recv_set; int i, numbytes, client_num; GuiMsg_t msg_hdr; char event_msg[MAX_MSG_SIZE]; memset(event_msg, 0 , MAX_MSG_SIZE); pthread_mutex_lock(&clients_mutex); client_num = num_clients; pthread_mutex_unlock(&clients_mutex); tv.tv_sec = 1; tv.tv_usec = 0; FD_ZERO(&recv_set); FD_SET(evtfd, &recv_set); if (select(evtfd + 1, &recv_set, NULL, NULL, &tv) < 0) { perror("select"); goto servloop; } if (!FD_ISSET(evtfd, &recv_set)) goto servloop; if ((numbytes = recv_all(evtfd, &msg_hdr, GUI_MSG_HEADER_LENGTH)) <= 0) { if (numbytes == 0) goto end; goto servloop; } msg_hdr_swap(&msg_hdr); if ((numbytes = recv_all(evtfd, event_msg, msg_hdr.payLoadLen)) <= 0) { if (numbytes == 0) goto end; goto servloop; } switch(msg_hdr.msgType) { case (AM_TOSSIMINITEVENT): { int ready = 0; int *node = (int*)event_msg; #ifdef DEBUG_CLIENTS fprintf(stderr, "%s Starting simulation %d with %d motes.\n", APP, this_client + 1, *node); #endif pthread_mutex_lock(&clients_mutex); num_motes += *node; clients[this_client].is_tos = 1; if (first < 0) first = this_client; pthread_mutex_unlock(&clients_mutex); while (!ready) { pthread_mutex_lock(&clients_mutex); if (num_motes >= expected_clients) ready = 1; pthread_mutex_unlock(&clients_mutex); sleep(1); } if ((numbytes = acknowledge(evtfd)) <= 0) { if (numbytes == 0 || errno == EPIPE) goto end; } } break; case (AM_ADCDATAREADYEVENT): { adc_request_t *req = (adc_request_t*)event_msg; adc_msg_swap(req); #ifdef DEBUG_ADC fprintf(stderr, "%s ADC data request from mote %d\n", APP, msg_hdr.moteID); fprintf(stderr, "%s Port: %hhu data: %hu \n", APP, req->port, req->data); #endif pthread_mutex_lock(&sim_time_mutex); sim_time = msg_hdr.time; pthread_mutex_unlock(&sim_time_mutex); pthread_mutex_lock(&adc_mutex); req->data = adc_values[msg_hdr.moteID][req->port]; pthread_mutex_unlock(&adc_mutex); if ((numbytes = acknowledge(evtfd)) <= 0) { if (numbytes == 0 || errno == EPIPE) goto end; } msg_hdr.msgType = AM_SETADCPORTVALUECOMMAND; msg_hdr_swap(&msg_hdr); if (send_all(cmdfd, &msg_hdr, GUI_MSG_HEADER_LENGTH) < 0) { perror(APP "send"); if (errno == EPIPE) goto end; } adc_msg_swap(req); if (send_all(cmdfd, req, sizeof(adc_request_t)) < 0) { perror(APP "send"); if (errno == EPIPE) goto end; } #ifdef ACK if ((numbytes = await_ack(cmdfd)) < 0) { if (numbytes == 0) goto end; } #endif } break; case (AM_RADIOMSGSENTEVENT): { int sims[client_num], *motes[client_num]; radio_msg_t *msg = (radio_msg_t*)event_msg; memset(sims, 0, client_num); radio_msg_swap(msg); #ifdef DEBUG_RADIO fprintf(stderr, "%s Radio message recvd from mote %d.\n", APP, msg_hdr.moteID); #ifdef DEBUG_VERBOSE { int i; fprintf(stderr, "%s Addr: %hu, Type: %hhu, Group: %hhu, Len: %hhu\n", APP, msg->addr, msg->type, msg->grp, msg->len); fprintf(stderr, "%s Data: ", APP); for (i = 0; i < msg->len; i++) fprintf(stderr, "%hhu ", msg->data[i]); fprintf(stderr, "\n%s crc: %hu, str: %hu, ack: %hhu, time: %hu, " "sendSecMode: %hhu, recvSecMode: %hhu\n", APP, msg->crc, msg->strength, msg->ack, msg->time, msg->send_sec_mode, msg->recv_sec_mode); #ifdef DEBUG_RADIO_RAW fprintf(stderr, "Raw: "); for (i = 0; i < msg_hdr.payLoadLen; i++) fprintf(stderr, " %hhu", ((unsigned char*)msg)[i]); fprintf(stderr, "\n"); #endif } #endif #endif if ((numbytes = acknowledge(evtfd)) <= 0) { if (numbytes == 0 || errno == EPIPE) goto end; } #ifdef INSTRUMENTATION if (msg->addr == BROADCAST) { char path[255]; FILE *file; sprintf(path, "tiny.%u.msgct", getpid()); if ((file = fopen(path, "a")) != NULL) { fprintf(file, "%u bytes\n", msg_hdr.payLoadLen); fclose(file); } } #endif send_to_networks(msg_hdr.moteID, msg->addr, sims, client_num, motes); for (i = 0; i < client_num; i++) { if (i == this_client) continue; if (clients[i].is_tos == 0 && clients[i].cmdfd > 0 && msg->addr == BROADCAST) { if (forward_message(i, msg->addr, msg_hdr.moteID, &msg_hdr, msg, 1) < 0) goto end; } else if (sims[i] > 0 && clients[i].cmdfd > 0) { msg_hdr.msgType = AM_RADIOMSGSENDCOMMAND; // TODO: collisions if (msg->addr == BROADCAST) { int j; for (j = 0; j < sims[i]; j++) { if (forward_message(i, motes[i][j], msg_hdr.moteID, &msg_hdr, msg, 0) < 0) goto end; } free(motes[i]); } else { if (forward_message(i, msg->addr, msg_hdr.moteID, &msg_hdr, msg, 0) < 0) goto end; } } } } break; case (AM_UARTMSGSENTEVENT): printf("UART msg\n"); if ((numbytes = acknowledge(evtfd)) <= 0) { if (numbytes == 0 || errno == EPIPE) goto end; } break; case (AM_INTERRUPTEVENT): case (AM_LEDEVENT): case (AM_DEBUGMSGEVENT): default: if ((numbytes = acknowledge(evtfd)) <= 0) { if (numbytes == 0 || errno == EPIPE) goto end; } break; } servloop: pthread_mutex_lock(&not_done_mutex); keep_going = not_done; pthread_mutex_unlock(&not_done_mutex); } end: #ifdef DEBUG_CLIENTS fprintf(stderr, "%s Client %d left.\n", APP, this_client); #endif pthread_mutex_lock(&clients_mutex); close(evtfd); clients[this_client].evtfd = -1; close(cmdfd); clients[this_client].cmdfd = -1; pthread_mutex_unlock(&clients_mutex); close(evtfd); return NULL; } void *accept_thread(void *unused) { int evtfd, cmdfd, yes = 1; struct sockaddr_in my_evt_addr, my_cmd_addr; unsigned int keep_going = 1; if ((evtfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { perror(APP "socket"); exit(1); } if ((cmdfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { perror(APP "socket"); exit(1); } if (setsockopt(evtfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) < 0) perror(APP "setsockopt"); if (setsockopt(cmdfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) < 0) perror(APP "setsockopt"); memset(&my_evt_addr, 0, sizeof(struct sockaddr_in)); my_evt_addr.sin_family = AF_INET; my_evt_addr.sin_port = htons(EVENT_PORT); my_evt_addr.sin_addr.s_addr = INADDR_ANY; memset(&my_cmd_addr, 0, sizeof(struct sockaddr_in)); my_cmd_addr.sin_family = AF_INET; my_cmd_addr.sin_port = htons(COMMAND_PORT); my_cmd_addr.sin_addr.s_addr = INADDR_ANY; if (bind(evtfd, (struct sockaddr*)&my_evt_addr, sizeof(struct sockaddr)) < 0) { perror(APP "bind"); exit(1); } if (bind(cmdfd, (struct sockaddr*)&my_cmd_addr, sizeof(struct sockaddr)) < 0) { perror(APP "bind"); exit(1); } if (listen(evtfd, MAX_CLIENTS) < 0) { perror(APP "listen"); exit(1); } if (listen(cmdfd, MAX_CLIENTS) < 0) { perror(APP "listen"); exit(1); } while(keep_going) { struct timeval tv; int max = 0; fd_set accept_set; struct sockaddr_in their_addr; socklen_t sin_size= sizeof(struct sockaddr_in); int idx = -1; tv.tv_sec = 1; tv.tv_usec = 0; FD_ZERO(&accept_set); FD_SET(evtfd, &accept_set); max = evtfd; FD_SET(cmdfd, &accept_set); if (cmdfd > max) max = cmdfd; if (select(max + 1, &accept_set, NULL, NULL, &tv) < 0) { perror("select"); goto acceptloop; } if (FD_ISSET(evtfd, &accept_set)) { int fd; if ((fd = accept(evtfd, (struct sockaddr*)&their_addr, &sin_size)) < 0) { perror(APP "accept"); goto acceptloop; } pthread_mutex_lock(&clients_mutex); clients[num_clients].addr = their_addr.sin_addr.s_addr; clients[num_clients].evtfd = fd; idx = num_clients; num_clients++; pthread_mutex_unlock(&clients_mutex); pthread_mutex_lock(&num_threads_mutex); if (pthread_create(&threads[num_threads], NULL, service_thread, (void*)idx) < 0) { perror(APP "pthread_create"); exit(1); } num_threads++; pthread_mutex_unlock(&num_threads_mutex); } else if (FD_ISSET(cmdfd, &accept_set)) { int i, fd; if ((fd = accept(cmdfd, (struct sockaddr*)&their_addr, &sin_size)) < 0) { perror(APP "accept"); goto acceptloop; } pthread_mutex_lock(&clients_mutex); for (i = 0; i < num_clients; i++) { if (clients[i].addr == their_addr.sin_addr.s_addr && clients[i].cmdfd == 0) { clients[i].cmdfd = fd; break; } } pthread_mutex_unlock(&clients_mutex); } acceptloop: pthread_mutex_lock(&not_done_mutex); keep_going = not_done; pthread_mutex_unlock(&not_done_mutex); } return NULL; } static void quit(int sig, siginfo_t *si, void *unused) { pthread_mutex_lock(&not_done_mutex); not_done = 0; pthread_mutex_unlock(&not_done_mutex); } int main(int argc, char *argv[]) { int i; char *net_file_name; char *adc_file_name; FILE *net_data_file; FILE *adc_data_file; struct sigaction sa; int loop = 1; if (argc != 4) { char *app = rindex(argv[0], '/'); if (app == NULL) app = argv[0]; else app++; fprintf(stderr, "%s Usage: %s <num clients> <network file> <adc file>\n", APP, app); exit(1); } expected_clients = atoi(argv[1]); net_file_name = argv[2]; adc_file_name = argv[3]; sa.sa_flags = SA_SIGINFO; sigemptyset(&sa.sa_mask); sa.sa_sigaction = quit; if (sigaction(SIGTERM, &sa, NULL) < 0) perror(APP "sigaction"); if (sigaction(SIGINT, &sa, NULL) < 0) perror(APP "sigaction"); if ((adc_data_file = fopen(adc_file_name, "r")) == NULL) { perror(APP "fopen"); exit(1); } if ((net_data_file = fopen(net_file_name, "r")) == NULL) { perror(APP "fopen"); exit(1); } igraph_i_set_attribute_table(&igraph_cattribute_table); if (igraph_read_graph_gml(&network_graph, net_data_file) < 0) { perror(APP "igraph_read_graph_gml"); exit(1); } fclose(net_data_file); num_threads = 0; sim_time = 0; not_done = 1; num_clients = 0; num_motes = 0; first = -1; memset(clients, 0, sizeof(client_t) * MAX_CLIENTS); pthread_mutex_lock(&num_threads_mutex); if (pthread_create(&threads[num_threads], NULL, accept_thread, NULL) < 0) { perror(APP "pthread_create"); exit(1); } num_threads++; pthread_mutex_unlock(&num_threads_mutex); do { pthread_mutex_lock(&not_done_mutex); loop = not_done; pthread_mutex_unlock(&not_done_mutex); } while (loop && load_data(adc_data_file)); // process ADC file do { sleep(1); // continue providing network until killed pthread_mutex_lock(&not_done_mutex); loop = not_done; pthread_mutex_unlock(&not_done_mutex); } while (loop); for (i = 0; i < num_threads; i++) pthread_join(threads[i], NULL); fclose(adc_data_file); igraph_destroy(&network_graph); return 0; }

© 2008, Los Alamos National Security, LLC.