int
main(int argc, char **argv, char **env)
{
int i;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
offset_lpid = g_tw_mynode * nlp_per_pe;
ttl_lps = tw_nnodes() * g_tw_npe * nlp_per_pe;
g_tw_memory_nqueues = 1;
g_tw_events_per_pe = (mult * nlp_per_pe * g_mem_start_events) +
optimistic_memory;
tw_define_lps(nlp_per_pe, sizeof(mem_message));
for(i = 0; i < nlp_per_pe; i++)
tw_lp_settype(i, &mylps[0]);
//((g_tw_nlp/g_tw_nkp) * g_mem_start_events),
// init the memory interface
my_fd = tw_memory_init(g_tw_events_per_pe * nbufs, sizeof(mem_packet), 0.5);
tw_run();
mem_stats_print();
tw_end();
return 0;
}
int
main(int argc, char **argv, char **env)
{
int i;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
offset_lpid = g_tw_mynode * nlp_per_pe;
ttl_lps = tw_nnodes() * g_tw_npe * nlp_per_pe;
g_tw_memory_nqueues = 1;
g_tw_events_per_pe = (mult * nlp_per_pe * g_tmr_start_events) +
optimistic_memory;
tw_define_lps(nlp_per_pe, sizeof(tmr_message), 0);
// use g_tw_nlp now
for(i = 0; i < g_tw_nlp; i++)
tw_lp_settype(i, &mylps[0]);
tw_kp_memory_init(g_tw_kp, 1000, 100, 1);
if(verbose)
f = stdout;
else
f = fopen("output", "w");
//f = fopen("/dev/null", "w");
tw_run();
tw_end();
return 0;
}
int main(int argc, char **argv, char **env)
{
int i;
lookahead = 1.0;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if( lookahead > 1.0 )
tw_error(TW_LOC, "Lookahead > 1.0 .. needs to be less\n");
g_tw_events_per_pe = (nlp_per_pe * g_start_events) + optimistic_memory;
g_tw_lookahead = lookahead;
tw_define_lps(nlp_per_pe, sizeof(ping_pong_message), 0);
for(i = 0; i < g_tw_nlp; i++)
tw_lp_settype(i, &mylps[0]);
if( g_tw_mynode == 0 )
{
printf("=============================================\n");
printf("Ping Pong Configuration..............\n");
printf(" Lookahead..............%lf\n", lookahead);
printf(" Start-events...........%u\n", g_start_events);
printf(" Memory.................%u\n", optimistic_memory);
printf("========================================\n\n");
}
tw_run();
tw_end();
return 0;
}
int
main(int argc, char **argv, char **env)
{
int i;
lookahead = 1.0;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
g_tw_memory_nqueues = 16;
offset_lpid = g_tw_mynode * nlp_per_pe;
ttl_lps = tw_nnodes() * g_tw_npe * nlp_per_pe;
g_tw_events_per_pe = (mult * nlp_per_pe * g_wifi_start_events)+ optimistic_memory;
g_tw_lookahead = lookahead;
tw_define_lps(nlp_per_pe, sizeof(wifi_message));
tw_lp_settype(0, &mylps[0]);
for(i = 1; i < g_tw_nlp; i++)
tw_lp_settype(i, &mylps[0]);
tw_run();
tw_end();
return 0;
}
int main(int argc, char *argv[])
{
int i;
g_tw_events_per_pe = nlp_per_pe * nlp_per_pe * 1;
tw_opt_add(olsr_opts);
tw_init(&argc, &argv);
tw_define_lps(nlp_per_pe, sizeof(olsr_msg_data), 0);
for (i = 0; i < g_tw_nlp; i++) {
tw_lp_settype(i, &olsr_lps[0]);
}
tw_run();
if (tw_ismaster()) {
printf("Complete.\n");
}
tw_end();
return 0;
}
int
main(int argc, char **argv)
{
int i;
tw_lp *lp;
tw_kp *kp;
tw_pe *pe;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if( lookahead > 1.0 )
tw_error(TW_LOC, "Lookahead > 1.0 .. needs to be less\n");
//reset mean based on lookahead
mean = mean - lookahead;
g_tw_memory_nqueues = 16; // give at least 16 memory queue event
offset_lpid = g_tw_mynode * nlp_per_pe;
ttl_lps = tw_nnodes() * g_tw_npe * nlp_per_pe;
g_tw_events_per_pe = (mult * nlp_per_pe * g_phold_start_events) +
optimistic_memory;
//g_tw_rng_default = TW_FALSE;
g_tw_lookahead = lookahead;
tw_define_lps(nlp_per_pe, sizeof(tcp_phold_message));
for(i = 0; i < g_tw_nlp; i++)
tw_lp_settype(i, &mylps[0]);
if( g_tw_mynode == 0 )
{
printf("Running simulation with following configuration: \n" );
printf(" Processors Used = %d\n", tw_nnodes());
printf(" KPs Used = %lu\n", g_tw_nkp);
printf(" LPs Used = %u\n", nlp_per_model);
printf(" End Time = %f \n", g_tw_ts_end);
printf(" Buffers Allocated Per PE = %d\n", g_tw_events_per_pe);
printf(" Gvt Interval = %d\n", g_tw_gvt_interval);
printf(" Message Block Size (i.e., Batch) = %d\n", g_tw_mblock);
printf("\n\n");
}
TWAppStats.sent_packets = 0;
TWAppStats.received_packets = 0;
TWAppStats.dropped_packets = 0;
TWAppStats.timedout_packets = 0;
TWAppStats.throughput = 0;
tw_run();
tw_end();
tcp_finalize( &TWAppStats );
return 0;
}
int main( int argc, char** argv )
{
int i;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
printf("First version BGP model! \n");
////////////
N_controller_per_DDN = NumControllerPerDDN;
N_FS_per_DDN = N_controller_per_DDN * NumFSPerController;
N_ION_per_DDN = N_FS_per_DDN * N_ION_per_FS;
N_CN_per_DDN = N_ION_per_DDN * N_CN_per_ION;
int N_lp_per_DDN = N_controller_per_DDN + N_FS_per_DDN + N_ION_per_DDN
+ N_CN_per_DDN + 1;
int N_lp_t = N_lp_per_DDN * NumDDN;
nlp_per_pe = N_lp_t/tw_nnodes()/g_tw_npe;
N_DDN_per_PE = NumDDN/tw_nnodes()/g_tw_npe;
g_tw_events_per_pe = nlp_per_pe * 32 + opt_mem;
tw_define_lps(nlp_per_pe, sizeof(MsgData), 0);
// mapping initialization
int LPaccumulate = 0;
for( i=0; i<N_CN_per_DDN*N_DDN_per_PE; i++ )
tw_lp_settype(i, &mylps[0]);
LPaccumulate += N_CN_per_DDN*N_DDN_per_PE;
for( i=0; i<N_ION_per_DDN*N_DDN_per_PE; i++ )
tw_lp_settype(i + LPaccumulate, &mylps[1]);
LPaccumulate += N_ION_per_DDN*N_DDN_per_PE;
for( i=0; i<N_FS_per_DDN*N_DDN_per_PE; i++ )
tw_lp_settype(i + LPaccumulate, &mylps[2]);
LPaccumulate += N_FS_per_DDN*N_DDN_per_PE;
for( i=0; i<N_controller_per_DDN*N_DDN_per_PE; i++ )
tw_lp_settype(i + LPaccumulate, &mylps[3]);
LPaccumulate += N_controller_per_DDN*N_DDN_per_PE;
for( i=0; i<N_DDN_per_PE; i++ )
tw_lp_settype(i + LPaccumulate, &mylps[4]);
tw_run();
tw_end();
return 0;
}
int gates_main(int argc, char* argv[]){
int i, j;
tw_opt_add(gates_opts);
tw_init(&argc, &argv);
// if (WAVE_COUNT != 0 && g_tw_synchronization_protocol > 2) {
// printf("ERROR: Waveform viewing is not supported for non-conservative protocols.\n");
// return 1;
// }
g_tw_mapping = CUSTOM;
g_tw_custom_initial_mapping = &gates_custom_mapping_setup;
g_tw_custom_lp_global_to_local_map = &gates_custom_mapping_to_local;
routing_table_mpi = routing_table_mapper(tw_nnodes());
g_tw_lp_offset = (*routing_table_mpi)[g_tw_mynode];
g_tw_nlp = (*routing_table_mpi)[g_tw_mynode+1] - g_tw_lp_offset;
g_tw_nkp = TOTAL_PARTS / tw_nnodes();
if (g_tw_mynode < TOTAL_PARTS - (g_tw_nkp * tw_nnodes())) {
g_tw_nkp++;
}
g_tw_events_per_pe = 100*g_tw_nlp;
g_tw_lookahead = 0.001;
tw_define_lps(g_tw_nlp, sizeof(message));
g_tw_lp_types = gates_lps;
g_io_lp_types = iolps;
tw_lp_setup_types();
g_io_events_buffered_per_rank = 0;
char cpname[100];
char *dpath = dirname(argv[0]);
sprintf(cpname, "%s/checkpoint/submodule-checkpoint", dpath);
io_init();
io_load_checkpoint(cpname, PRE_INIT);
#if DEBUG_TRACE
char debugfile[100];
sprintf(debugfile, "%s/debug/node_%d_output_file.txt", dpath, g_tw_mynode);
node_out_file = fopen(debugfile,"w");
#endif
tw_run();
tw_end();
return 0;
}
int
main(int argc, char **argv, char **env)
{
int i;
// get rid of error if compiled w/ MEMORY queues
g_tw_memory_nqueues=1;
// set a min lookahead of 1.0
lookahead = 1.0;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if( lookahead > 1.0 )
tw_error(TW_LOC, "Lookahead > 1.0 .. needs to be less\n");
//reset mean based on lookahead
mean = mean - lookahead;
g_tw_memory_nqueues = 16; // give at least 16 memory queue event
offset_lpid = g_tw_mynode * nlp_per_pe;
ttl_lps = tw_nnodes() * g_tw_npe * nlp_per_pe;
g_tw_events_per_pe = (mult * nlp_per_pe * g_phold_start_events) +
optimistic_memory;
//g_tw_rng_default = TW_FALSE;
g_tw_lookahead = lookahead;
tw_define_lps(nlp_per_pe, sizeof(phold_message));
for(i = 0; i < g_tw_nlp; i++)
tw_lp_settype(i, &mylps[0]);
if( g_tw_mynode == 0 )
{
printf("========================================\n");
printf("PHOLD Model Configuration..............\n");
printf(" Lookahead..............%lf\n", lookahead);
printf(" Start-events...........%u\n", g_phold_start_events);
printf(" stagger................%u\n", stagger);
printf(" Mean...................%lf\n", mean);
printf(" Mult...................%lf\n", mult);
printf(" Memory.................%u\n", optimistic_memory);
printf(" Remote.................%lf\n", percent_remote);
printf("========================================\n\n");
}
tw_run();
tw_end();
return 0;
}
int main(
int argc,
char **argv)
{
int nprocs;
int rank;
int lps_per_proc;
int i;
int ret;
lp_io_handle handle;
g_tw_ts_end = 60*60*24*365;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
if((NUM_SERVERS) % nprocs)
{
fprintf(stderr, "Error: number of server LPs (%d total) is not evenly divisible by the number of MPI processes (%d)\n", NUM_SERVERS, nprocs);
exit(-1);
}
lps_per_proc = (NUM_SERVERS) / nprocs;
tw_define_lps(lps_per_proc, sizeof(struct svr_msg), 0);
for(i=0; i<lps_per_proc; i++)
{
tw_lp_settype(i, &svr_lp);
}
g_tw_lookahead = 100;
ret = lp_io_prepare("lp-io-test-results", LP_IO_UNIQ_SUFFIX, &handle, MPI_COMM_WORLD);
if(ret < 0)
{
return(-1);
}
tw_run();
ret = lp_io_flush(handle, MPI_COMM_WORLD);
assert(ret == 0);
tw_end();
return 0;
}
/*
* main - start function for the model, setup global state space of model and
* init and run the simulation executive. Also must map LPs to PEs
*/
int
main(int argc, char **argv, char **env)
{
int i;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
g_tw_events_per_pe = (g_tw_nlp / g_tw_npe) * 4;
g_tw_memory_nqueues = 2;
tw_define_lps(g_tw_nlp, sizeof(epi_message), 0);
epi_disease_init();
// create KP memory buffer queues
for(i = 0; i < g_tw_nkp; i++)
{
g_epi_fd = tw_kp_memory_init(tw_getkp(i),
//0, //g_epi_nagents / g_tw_nkp,
g_epi_nagents / g_tw_nkp,
sizeof(epi_agent), 1);
g_epi_pathogen_fd = tw_kp_memory_init(tw_getkp(i),
(g_epi_nagents / g_tw_nkp) * g_epi_ndiseases,
sizeof(epi_pathogen), 1);
}
// Round-robin mapping of LPs to KPs and KPs to PEs
for(i = 0; i < g_tw_nlp; i++)
tw_lp_settype(i, &mylps[0]);
// read input files, create global data structures, etc
epi_agent_init();
tw_run();
epi_model_final();
return 0;
}
int
main(int argc, char **argv, char **env)
{
#ifdef TEST_COMM_ROSS
// Init outside of ROSS
MPI_Init(&argc, &argv);
// Split COMM_WORLD in half even/odd
int mpi_rank;
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
MPI_Comm split_comm;
MPI_Comm_split(MPI_COMM_WORLD, mpi_rank%2, mpi_rank, &split_comm);
if(mpi_rank%2 == 1){
// tests should catch any MPI_COMM_WORLD collectives
MPI_Finalize();
}
// Allows ROSS to function as normal
tw_comm_set(split_comm);
#endif
int i;
// get rid of error if compiled w/ MEMORY queues
g_tw_memory_nqueues=1;
// set a min lookahead of 1.0
lookahead = 1.0;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
#ifdef USE_DAMARIS
if(g_st_ross_rank)
{ // only ross ranks should run code between here and tw_run()
#endif
if( lookahead > 1.0 )
tw_error(TW_LOC, "Lookahead > 1.0 .. needs to be less\n");
//reset mean based on lookahead
mean = mean - lookahead;
g_tw_memory_nqueues = 16; // give at least 16 memory queue event
offset_lpid = g_tw_mynode * nlp_per_pe;
ttl_lps = tw_nnodes() * g_tw_npe * nlp_per_pe;
g_tw_events_per_pe = (mult * nlp_per_pe * g_phold_start_events) +
optimistic_memory;
//g_tw_rng_default = TW_FALSE;
g_tw_lookahead = lookahead;
tw_define_lps(nlp_per_pe, sizeof(phold_message));
for(i = 0; i < g_tw_nlp; i++)
{
tw_lp_settype(i, &mylps[0]);
st_model_settype(i, &model_types[0]);
}
if( g_tw_mynode == 0 )
{
printf("========================================\n");
printf("PHOLD Model Configuration..............\n");
printf(" Lookahead..............%lf\n", lookahead);
printf(" Start-events...........%u\n", g_phold_start_events);
printf(" stagger................%u\n", stagger);
printf(" Mean...................%lf\n", mean);
printf(" Mult...................%lf\n", mult);
printf(" Memory.................%u\n", optimistic_memory);
printf(" Remote.................%lf\n", percent_remote);
printf("========================================\n\n");
}
tw_run();
#ifdef USE_DAMARIS
} // end if(g_st_ross_rank)
#endif
tw_end();
return 0;
}
int
main(int argc, char **argv, char **env)
{
int i;
num_buf_slots = vc_size / chunk_size;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if(strcmp(traffic_str, "uniform") == 0)
TRAFFIC = UNIFORM_RANDOM;
else if(strcmp(traffic_str, "nearest") == 0)
TRAFFIC = NEAREST_NEIGHBOR;
else if(strcmp(traffic_str, "diagonal") == 0)
TRAFFIC = DIAGONAL;
else
printf("\n Incorrect traffic pattern specified, using %s as default ", traffic_str );
/* for automatically reducing the channel link bandwidth of a 7-D or a 9-D torus */
link_bandwidth = (link_bandwidth * 10) / (2 * N_dims);
injection_limit = injection_interval / MEAN_INTERVAL;
for (i=0; i<N_dims; i++)
{
N_nodes*=dim_length[i];
N_mpi_procs*=dim_length[i];
}
nlp_nodes_per_pe = N_nodes/tw_nnodes()/g_tw_npe;
nlp_mpi_procs_per_pe = N_mpi_procs/tw_nnodes()/g_tw_npe;
num_rows = sqrt(N_nodes);
num_cols = num_rows;
total_lps = g_tw_nlp * tw_nnodes();
node_rem = N_nodes % (tw_nnodes()/g_tw_npe);
if(g_tw_mynode < node_rem)
{
nlp_nodes_per_pe++;
nlp_mpi_procs_per_pe++;
}
num_packets=1;
num_chunks = PACKET_SIZE/chunk_size;
if( mpi_message_size > PACKET_SIZE)
{
num_packets = mpi_message_size / PACKET_SIZE;
if(mpi_message_size % PACKET_SIZE != 0 )
num_packets++;
}
g_tw_mapping=CUSTOM;
g_tw_custom_initial_mapping=&torus_mapping;
g_tw_custom_lp_global_to_local_map=&torus_mapping_to_lp;
g_tw_events_per_pe = mem_factor * 1024 * (nlp_nodes_per_pe/g_tw_npe + nlp_mpi_procs_per_pe/g_tw_npe) + opt_mem;
tw_define_lps(nlp_nodes_per_pe + nlp_mpi_procs_per_pe, sizeof(nodes_message), 0);
head_delay = (1 / link_bandwidth) * chunk_size;
// BG/L torus network paper: Tokens are 32 byte chunks that is why the credit delay is adjusted according to bandwidth * 32
credit_delay = (1 / link_bandwidth) * 8;
packet_offset = (g_tw_ts_end/MEAN_INTERVAL) * num_packets;
if(tw_ismaster())
{
printf("\nTorus Network Model Statistics:\n");
printf("Number of nodes: %d Torus dimensions: %d ", N_nodes, N_dims);
printf(" Link Bandwidth: %f Traffic pattern: %s \n", link_bandwidth, traffic_str );
}
tw_run();
unsigned long long total_finished_storage[N_COLLECT_POINTS];
unsigned long long total_generated_storage[N_COLLECT_POINTS];
unsigned long long total_num_hops[N_COLLECT_POINTS];
unsigned long long total_queue_depth[N_COLLECT_POINTS];
unsigned long long wait_length,event_length,N_total_packets_finish, N_total_msgs_finish, N_total_hop;
tw_stime total_time_sum,g_max_latency;
for( i=0; i<N_COLLECT_POINTS; i++ )
{
MPI_Reduce( &N_finished_storage[i], &total_finished_storage[i],1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &N_generated_storage[i], &total_generated_storage[i],1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &N_num_hops[i], &total_num_hops[i],1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &N_queue_depth[i], &total_queue_depth[i],1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
}
MPI_Reduce( &total_time, &total_time_sum,1,
MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &N_finished_packets, &N_total_packets_finish,1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &N_finished_msgs, &N_total_msgs_finish,1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &total_hops, &N_total_hop,1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &max_latency, &g_max_latency,1,
MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);
for( i=1; i<N_COLLECT_POINTS; i++ )
{
total_finished_storage[i]+=total_finished_storage[i-1];
total_generated_storage[i]+=total_generated_storage[i-1];
}
// if( total_lp_time > 0 )
// total_lp_time /= num_mpi_msgs;
if(tw_ismaster())
{
printf("\n ****************** \n");
printf("\n total packets finished: %lld and %lld; \n",
total_finished_storage[N_COLLECT_POINTS-1],N_total_packets_finish);
printf("\n total MPI messages finished: %lld; \n",
N_total_msgs_finish);
printf("\n total generate: %lld; \n",
total_generated_storage[N_COLLECT_POINTS-1]);
printf("\n total hops: %lf; \n",
(double)N_total_hop/N_total_packets_finish);
printf("\n average travel time: %lf; \n\n",
total_time_sum/N_total_msgs_finish);
#if REPORT_BANDWIDTH
for( i=0; i<N_COLLECT_POINTS; i++ )
{
printf(" %d ",i*100/N_COLLECT_POINTS);
printf("total finish: %lld; generate: %lld; alive: %lld \n ",
total_finished_storage[i],
total_generated_storage[i],
total_generated_storage[i]-total_finished_storage[i]);
}
// capture the steady state statistics
tw_stime bandwidth;
tw_stime interval = (g_tw_ts_end / N_COLLECT_POINTS);
interval = interval/(1000.0 * 1000.0 * 1000.0); //convert ns to seconds
for( i=1; i<N_COLLECT_POINTS; i++ )
{
bandwidth = total_finished_storage[i] - total_finished_storage[i - 1];
unsigned long long avg_hops = total_num_hops[i]/bandwidth;
bandwidth = (bandwidth * PACKET_SIZE) / (1024.0 * 1024.0 * 1024.0); // convert bytes to GB
bandwidth = bandwidth / interval;
printf("\n Interval %0.7lf Bandwidth %lf avg hops %lld queue depth %lld ", interval, bandwidth, avg_hops, (unsigned long long)total_queue_depth[i]/num_chunks);
}
unsigned long long steady_sum=0;
for( i = N_COLLECT_POINTS/2; i<N_COLLECT_POINTS;i++)
steady_sum+=total_generated_storage[i]-total_finished_storage[i];
printf("\n Steady state, packet alive: %lld\n",
2*steady_sum/N_COLLECT_POINTS);
#endif
printf("\nMax latency is %lf\n\n",g_max_latency);
}
// if(packet_sent > 0 || credit_sent > 0)
// printf("\n Packet sent are %d, credit sent %d ", packet_sent, credit_sent);
tw_end();
return 0;
}
int olsr_main(int argc, char *argv[])
{
int i;
char log[32];
tw_opt_add(olsr_opts);
tw_init(&argc, &argv);
#if DEBUG
sprintf( log, "olsr-log.%ld", g_tw_mynode );
olsr_event_log = fopen( log, "w+");
if( olsr_event_log == nullptr )
tw_error( TW_LOC, "Failed to Open OLSR Event Log file \n");
#endif
g_tw_mapping = CUSTOM;
g_tw_custom_initial_mapping = &olsr_custom_mapping;
g_tw_custom_lp_global_to_local_map = &olsr_mapping_to_lp;
// nlp_per_pe = OLSR_MAX_NEIGHBORS;// / tw_nnodes();
//g_tw_lookahead = SA_INTERVAL;
SA_range_start = nlp_per_pe;
// Increase nlp_per_pe by nlp_per_pe / OMN
nlp_per_pe += nlp_per_pe / OLSR_MAX_NEIGHBORS;
g_tw_events_per_pe = OLSR_MAX_NEIGHBORS / 2 * nlp_per_pe + 65536;
tw_define_lps(nlp_per_pe, sizeof(olsr_msg_data));
for(i = 0; i < OLSR_END_EVENT; i++)
g_olsr_event_stats[i] = 0;
for (i = 0; i < SA_range_start; i++) {
tw_lp_settype(i, &olsr_lps[0]);
}
for (i = SA_range_start; i < nlp_per_pe; i++) {
tw_lp_settype(i, &olsr_lps[1]);
}
#if DEBUG
printf("g_tw_nlp is %llu\n", g_tw_nlp);
#endif
tw_run();
if( g_tw_synchronization_protocol != 1 )
{
MPI_Reduce( g_olsr_event_stats, g_olsr_root_event_stats, OLSR_END_EVENT, MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
}
else {
for (i = 0; i < OLSR_END_EVENT; i++) {
g_olsr_root_event_stats[i] = g_olsr_event_stats[i];
}
}
if (tw_ismaster()) {
for( i = 0; i < OLSR_END_EVENT; i++ )
printf("OLSR Type %s Event Count = %llu \n", event_names[i], g_olsr_root_event_stats[i]);
printf("Complete.\n");
}
tw_end();
return 0;
}
int
main(int argc, char **argv, char **env)
{
int i;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
for (i=0; i<N_dims; i++)
N_nodes*=dim_length[i];
MEAN_INTERVAL = N_nodes/ARRIVAL_RATE;
nlp_per_pe = N_nodes/tw_nnodes()/g_tw_npe;
g_tw_events_per_pe = nlp_per_pe/g_tw_npe + opt_mem;
tw_define_lps(nlp_per_pe, sizeof(nodes_message), 0);
for(i = 0; i < g_tw_nlp; i++)
tw_lp_settype(i, &nodes_lps[0]);
tw_run();
if(tw_ismaster())
{
printf("\nTorus Network Model Statistics:\n");
printf("\t%-50s %11lld\n", "Number of nodes",
nlp_per_pe * g_tw_npe * tw_nnodes());
}
unsigned long long total_finished_storage[N_COLLECT_POINTS];
unsigned long long total_dropped_storage[N_COLLECT_POINTS];
unsigned long long total_generated_storage[N_COLLECT_POINTS];
unsigned long long wait_length,event_length,N_total_finish,N_total_hop;
tw_stime total_time_sum,g_max_latency;
for( i=0; i<N_COLLECT_POINTS; i++ )
{
MPI_Reduce( &N_dropped_storage[i], &total_dropped_storage[i],1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &N_finished_storage[i], &total_finished_storage[i],1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &N_generated_storage[i], &total_generated_storage[i],1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
}
MPI_Reduce( &queueing_times_sum, &event_length,1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &total_queue_length, &wait_length,1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &total_time, &total_time_sum,1,
MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &N_finished, &N_total_finish,1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &total_hops, &N_total_hop,1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce( &max_latency, &g_max_latency,1,
MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);
unsigned long long total_rand_total;
MPI_Reduce( &rand_total, &total_rand_total,1,
MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
for( i=1; i<N_COLLECT_POINTS; i++ )
{
total_dropped_storage[i]+=total_dropped_storage[i-1];
total_finished_storage[i]+=total_finished_storage[i-1];
total_generated_storage[i]+=total_generated_storage[i-1];
}
if(tw_ismaster())
{
printf("\n ****************** \n");
printf("\n Total drop: %lld; \n",
total_dropped_storage[N_COLLECT_POINTS-1]);
printf("\n total finish: %lld and %lld; \n",
total_finished_storage[N_COLLECT_POINTS-1],N_total_finish);
printf("\n total generate: %lld; \n",
total_generated_storage[N_COLLECT_POINTS-1]);
printf("\n total hops: %lf; \n",
(double)N_total_hop/total_finished_storage[N_COLLECT_POINTS-1]);
printf("\n total wait length: %lf; \n",
(double)wait_length/total_finished_storage[N_COLLECT_POINTS-1]);
printf("\n total total queued: %lf; \n",
(double)event_length/total_finished_storage[N_COLLECT_POINTS-1]);
printf("\n average travel time: %lf; \n\n",
total_time_sum/total_finished_storage[N_COLLECT_POINTS-1]);
for( i=0; i<N_COLLECT_POINTS; i++ )
{
printf(" %d ",i*100/N_COLLECT_POINTS);
printf("drop: %lld; finish: %lld; generate: %lld; alive: %lld\n",
total_dropped_storage[i],
total_finished_storage[i],
total_generated_storage[i],
total_generated_storage[i]-total_finished_storage[i]);
}
// capture the steady state statistics
unsigned long long steady_sum=0;
for( i = N_COLLECT_POINTS/2; i<N_COLLECT_POINTS;i++)
steady_sum+=total_generated_storage[i]-total_finished_storage[i];
printf("\n Steady state, packet alive: %lld\n",
2*steady_sum/N_COLLECT_POINTS);
printf("Aeverage is %lld\n",total_rand_total/total_generated_storage[N_COLLECT_POINTS-1]);
printf("\nMax latency is %lf\n\n",g_max_latency);
}
tw_end();
return 0;
}
int main(int argc, char * argv[])
{
g_tw_ts_end = 30;
g_tw_gvt_interval = 16;
int i;
// get rid of error if compiled w/ MEMORY queues
g_tw_memory_nqueues=1;
// set a min lookahead of 1.0
lookahead = 1.0;
//tw_opt_add(app_opt);
tw_init(&argc, &argv);
if( lookahead > 1.0 )
tw_error(TW_LOC, "Lookahead > 1.0 .. needs to be less\n");
//reset mean based on lookahead
mean = mean - lookahead;
g_tw_memory_nqueues = 16; // give at least 16 memory queue event
offset_lpid = g_tw_mynode * nlp_per_pe;
ttl_lps = tw_nnodes() * g_tw_npe * nlp_per_pe;
//g_tw_rng_default = TW_FALSE;
g_tw_lookahead = lookahead;
nlp_per_pe = (NUM_CELLS_X * NUM_CELLS_Y) / (tw_nnodes() * g_tw_npe);
g_tw_events_per_pe = (mult * nlp_per_pe * g_traffic_start_events) +
optimistic_memory;
num_cells_per_kp = (NUM_CELLS_X * NUM_CELLS_Y) / (NUM_VP_X * NUM_VP_Y);
vp_per_proc = (NUM_VP_X * NUM_VP_Y) / ((tw_nnodes() * g_tw_npe)) ;
g_vp_per_proc = vp_per_proc;
g_tw_nlp = nlp_per_pe;
g_tw_nkp = vp_per_proc;
g_tw_mapping = CUSTOM;
g_tw_custom_initial_mapping = &traffic_grid_mapping;
g_tw_custom_lp_global_to_local_map = &CellMapping_to_lp;
tw_define_lps(nlp_per_pe, sizeof(Msg_Data));
for(i = 0; i < g_tw_nlp; i++)
tw_lp_settype(i, &mylps[0]);
if( g_tw_mynode == 0 )
{
printf("========================================\n");
printf("Traffice Model Configuration..............\n");
printf(" Lookahead..............%lf\n", lookahead);
printf(" Start-events...........%u\n", g_traffic_start_events);
printf(" stagger................%u\n", stagger);
printf(" Mean...................%lf\n", mean);
printf(" Mult...................%lf\n", mult);
printf(" Memory.................%u\n", optimistic_memory);
printf(" Remote.................%lf\n", percent_remote);
printf("========================================\n\n");
}
tw_run();
tw_end();
printf("Number of Arivals: %lld\n", totalCars);
printf("Number of Cars reached their dest: %lld\n", carsFinished);
return 0;
}
int srw_main(int argc, char *argv[])
{
int i;
int num_lps_per_pe = 1;
tw_opt_add(srw_opts);
/* This configures g_tw_npe */
tw_init(&argc, &argv);
/* Must call this to properly set g_tw_nlp */
tw_define_lps(num_lps_per_pe, sizeof(srw_msg_data), 0);
#ifdef WITH_NETDMF
/* IF we ARE using NETDMF... */
if (!strcmp("", netdmf_config)) {
/* AND we DO NOT have a config file */
/* There is no NetDMF configuration file. Create a scenario with fake
* data, i.e. no changes are required: fake data is created by default */
for (i = 0; i < g_tw_nlp; i++) {
tw_lp_settype(i, &srw_lps[0]);
}
printf("No NetDMF configuration specified.\n");
}
else {
/* OR we DO have a config file */
/* Must repeatedly call this to copy the function pointers appropriately */
for (i = 0; i < g_tw_nlp; i++) {
tw_lp_settype(i, &netdmf_srw_lps[0]);
}
/* Read in the netdmf_config file. This must be done after
* we set up the LPs (via tw_lp_settype) so we have data
* to configure. */
for (i = 0; i < g_tw_npe; i++) {
tw_pe_settype(g_tw_pe[i], &srw_pes[0]);
}
}
#else /* WITH_NETDMF */
/* WE are NOT using NETDMF */
/* Must repeatedly call this to copy the function pointers appropriately */
for (i = 0; i < g_tw_nlp; i++) {
tw_lp_settype(i, &srw_lps[0]);
}
#endif /* WITH_NETDMF */
tw_run();
if (tw_ismaster()) {
printf("Total radios in simulation: %d\n", total_radios);
printf("Total movements: %d\n", total_movements);
printf("Total communcation failures: %d\n", total_fail);
printf("Total communcation attempts: %d\n", total_comm);
printf("Total communication successes: %d\n", total_comm - total_fail);
printf("Node %d moved the most: %d\n", top_node, top_move);
}
tw_end();
return 0;
}
/*
* This function initializes the environment model.. should be called
* once by user model. Allows EM to control how ROSS is init'd.
*
* This function provides the Reactive Model with a pre-simulation 'main'
*/
int
rm_initialize(tw_petype * ptypes, tw_lptype * types, tw_peid npe,
tw_kpid nkp, tw_lpid nradios, size_t msg_sz)
{
//FILE *fp;
tw_lptype *t;
//tw_pe *pe;
//tw_kp *kp;
//tw_lp *lp;
//size_t size;
//int max_name;
int ntypes;
tw_lpid nlp_grid;
//int nkp_grid;
//int nnodes;
int i;
//int j;
//int k;
//int m;
//int kp_per_pe;
/*
* Open debug plotting files
*/
#if 0
g_rm_waves_plt_f = fopen("waves.plt", "w");
g_rm_nodes_plt_f = fopen("user_nodes.plt", "w");
g_rm_parts_plt_f = fopen("particles.plt", "w");
if(!g_rm_nodes_plt_f || !g_rm_parts_plt_f)
tw_error(TW_LOC, "Unable to open plotting files!");
#endif
g_rm_stats = tw_calloc(TW_LOC, "rm stats", sizeof(rm_statistics), 1);
memset(g_rm_stats, 0, sizeof(rm_statistics));
// # of cells around me = 2 * # spatial_dim
g_rm_spatial_dir = g_rm_spatial_dim * 2;
g_rm_spatial_offset = nradios;
g_rm_spatial_coeff = 2.0 / g_rm_spatial_dir;
g_rm_spatial_grid_i = tw_calloc(TW_LOC, "spatial grid i", sizeof(int), g_rm_spatial_dim);
g_rm_spatial_offset_ts = tw_calloc(TW_LOC, "spatial offset ts", sizeof(tw_stime), g_rm_spatial_dir);
g_rm_spatial_ground_coeff = 0.75;
if(0.0 > g_rm_wave_loss_coeff)
{
g_rm_wave_loss_coeff = 0.5;
g_rm_wave_loss_coeff = 1.0 / exp(g_rm_wave_attenuation * g_rm_spatial_d[0]);
if(tw_node_eq(&g_tw_mynode, &g_tw_masternode))
printf("\n\tSETTING WAVE LOSS COEFF %lf! \n\n", g_rm_wave_loss_coeff);
}
g_rm_wave_velocity = 3.0 * 1000.0 * 1000.0 * 1000.0;
// Require NULL terminated array, plus LPs for Cells
for(ntypes = 2, t = types; t->state_sz; t++)
ntypes++;
//printf("Creating %d lp types\n", ntypes);
t = tw_calloc(TW_LOC, "lp types array", sizeof(tw_lptype), ntypes);
memcpy(t, types, sizeof(tw_lptype) * (ntypes-2));
memcpy(&t[ntypes-2], rm_lps, sizeof(rm_lps));
nlp_grid = rm_grid_init();
nrmlp_per_pe = ceil(nlp_grid / (tw_nnodes() * g_tw_npe));
if(tw_nnodes() == 1)
nrmlp_per_pe = nlp_grid;
nlp_per_pe = nradios + nrmlp_per_pe;
g_tw_events_per_pe = .1 * nlp_grid / (tw_nnodes() * g_tw_npe);
g_tw_events_per_pe += optimistic_memory;
rm_grid_terrain();
for(i = 0; i < g_tw_npe; i++)
tw_pe_settype(g_tw_pe[i], rm_pes);
tw_pe_settype(&g_rm_pe, ptypes);
g_tw_rng_default = TW_FALSE;
tw_define_lps(nlp_per_pe, sizeof(rm_message), 0);
for(i = 0; i < g_rm_spatial_offset; i++)
tw_lp_settype(i, types);
for( ; i < g_tw_nlp; i++)
tw_lp_settype(i, rm_lps);
return 1;
}