/* handle initial event (initialize job submission) */
void handle_kick_off_event(
awe_server_state * ns,
tw_bf * b,
awe_msg * m,
tw_lp * lp)
{
printf("%lf;awe_server;%lu]Start serving\n", now_sec(lp), lp->gid);
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init(&iter, job_map);
while (g_hash_table_iter_next(&iter, &key, &value)) {
Job* job = (Job*)value;
tw_event *e;
awe_msg *msg;
tw_stime submit_time;
submit_time = s_to_ns(etime_to_stime(job->stats.created)) + ns_tw_lookahead;
if (fraction < 1.0) {
submit_time = submit_time * fraction;
}
e = codes_event_new(lp->gid, submit_time, lp);
msg = tw_event_data(e);
msg->event_type = JOB_SUBMIT;
strcpy(msg->object_id, job->id);
tw_event_send(e);
}
return;
}
int main(
int argc,
char **argv)
{
int nprocs;
int rank;
int num_nets, *net_ids;
//printf("\n Config count %d ",(int) config.lpgroups_count);
g_tw_ts_end = s_to_ns(60*60*24*365); /* one year, in nsecs */
lp_io_handle handle;
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if(argc < 2)
{
printf("\n Usage: mpirun <args> --sync=2/3 mapping_file_name.conf (optional --nkp) ");
MPI_Finalize();
return 0;
}
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
configuration_load(argv[2], MPI_COMM_WORLD, &config);
svr_add_lp_type();
codes_mapping_setup();
net_ids = model_net_configure(&num_nets);
assert(num_nets==1);
net_id = *net_ids;
free(net_ids);
num_servers = codes_mapping_get_lp_count("MODELNET_GRP", 0, "server",
NULL, 1);
if(net_id == DRAGONFLY)
{
num_routers = codes_mapping_get_lp_count("MODELNET_GRP", 0,
"dragonfly_router", NULL, 1);
offset = 1;
}
if(lp_io_prepare("modelnet-test", LP_IO_UNIQ_SUFFIX, &handle, MPI_COMM_WORLD) < 0)
{
return(-1);
}
tw_run();
model_net_report_stats(net_id);
if(lp_io_flush(handle, MPI_COMM_WORLD) < 0)
{
return(-1);
}
tw_end();
return 0;
}
TimePoint SteadyClock::now() noexcept {
struct timespec tp;
int err = clock_gettime(CLOCK_UPTIME_RAW, &tp);
(void)err;
assert_(err == 0);
return TimePoint(s_to_ns(tp.tv_sec) + tp.tv_nsec);
}
void SleepFor(Duration d) noexcept {
if (d <= 0) {
return;
}
long long s = ns_to_s(d);
timespec ts;
ts.tv_sec = static_cast<time_t>(s);
ts.tv_nsec = static_cast<long>(d - s_to_ns(s));
while (nanosleep(&ts, &ts) == -1 && errno == EINTR);
}
int main(int argc, char **argv) {
int nprocs;
int rank;
int num_nets, *net_ids;
int i;
//for later random pairing:
srand(time(NULL));
g_tw_ts_end = s_to_ns(60*60*24*365);
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if (!conf_file_name[0]) {
fprintf(stderr, "Expected \"codes-config\" option, please see --help.\n");
MPI_Finalize();
return 1;
}
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
if (configuration_load(conf_file_name, MPI_COMM_WORLD, &config)) {
fprintf(stderr, "Error loading config file %s.\n", conf_file_name);
MPI_Finalize();
return 1;
}
model_net_register();
node_add_lp_type();
codes_mapping_setup();
net_ids = model_net_configure(&num_nets);
assert(num_nets==1);
net_id = *net_ids;
free(net_ids);
if(net_id != TORUS) {
printf("\n This is written to simulate torus networks.");
MPI_Finalize();
return 0;
}
num_nodes = codes_mapping_get_lp_count(group_name, 0, "node", NULL, 1);
configuration_get_value_int(&config, param_group_nm, num_reqs_key, NULL, &num_reqs);
configuration_get_value_int(&config, param_group_nm, payload_sz_key, NULL, &payload_sz);
configuration_get_value_int(&config, param_group_nm, num_messages_key, NULL, &num_messages);
tw_run();
model_net_report_stats(net_id);
tw_end();
free_node_mappings();
return 0;
}
int main(
int argc,
char **argv)
{
int nprocs;
int rank;
lp_io_handle handle;
int ret;
g_tw_ts_end = s_to_ns(60*60*24*365); /* one year, in nsecs */
tw_opt_add(app_opt);
tw_init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
/* read in configuration file */
ret = configuration_load(conf_file_name, MPI_COMM_WORLD, &config);
if (ret)
{
fprintf(stderr, "Error opening config file: %s\n", conf_file_name);
return(-1);
}
lp_type_register("server", &svr_lp);
lsm_register();
codes_mapping_setup();
lsm_configure();
ret = lp_io_prepare("lsm-test", LP_IO_UNIQ_SUFFIX, &handle, MPI_COMM_WORLD);
if(ret < 0)
{
return(-1);
}
INIT_CODES_CB_INFO(&cb_info, svr_msg, h, tag, ret);
tw_run();
ret = lp_io_flush(handle, MPI_COMM_WORLD);
assert(ret == 0);
tw_end();
return 0;
}
int main(int argc, char *argv[])
{
int num_nets, *net_ids;
g_tw_ts_end = s_to_ns(60*60*24*365); /* one year, in nsecs */
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if (!conf_file_name[0]) {
fprintf(stderr, "Expected \"codes-config\" option, please see --help.\n");
MPI_Finalize();
return 1;
}
/* loading the config file into the codes-mapping utility, giving us the
* parsed config object in return.
* "config" is a global var defined by codes-mapping */
if (configuration_load(conf_file_name, MPI_COMM_WORLD, &config)){
fprintf(stderr, "Error loading config file %s.\n", conf_file_name);
MPI_Finalize();
return 1;
}
/* currently restrict to simplenet, as other networks are trickier to
* setup. TODO: handle other networks properly */
if(net_id != SIMPLENET) {
printf("\n The test works with simple-net configuration only! ");
MPI_Finalize();
return 1;
}
testsvr_init();
model_net_register();
codes_mapping_setup();
/* Setup the model-net parameters specified in the global config object,
* returned are the identifier for the network type */
net_ids = model_net_configure(&num_nets);
assert(num_nets==1);
net_id = *net_ids;
free(net_ids);
tw_run();
tw_end();
return 0;
}
int main(
int argc,
char **argv)
{
int num_nets;
int *net_ids;
g_tw_ts_end = s_to_ns(60*60*24*365); /* one year, in nsecs */
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if(argc < 2)
{
printf("\n Usage: mpirun <args> --sync=[1,3] -- mapping_file_name.conf (optional --nkp) ");
MPI_Finalize();
return 0;
}
configuration_load(argv[2], MPI_COMM_WORLD, &config);
model_net_register();
svr_add_lp_type();
codes_mapping_setup();
net_ids = model_net_configure(&num_nets);
assert(num_nets==1);
net_id = *net_ids;
free(net_ids);
assert(net_id == SIMPLENET);
assert(NUM_SERVERS == codes_mapping_get_lp_count("MODELNET_GRP", 0,
"server", NULL, 1));
tw_run();
tw_end();
return prog_rtn;
}
int main(int argc, char *argv[]) {
//printf("In main\n");
g_tw_ts_end = s_to_ns(60 * 60 * 24 * 365); /* one year, in nsecs */
/* ROSS initialization function calls */
tw_opt_add(app_opt); /* add user-defined args */
/* initialize ROSS and parse args. NOTE: tw_init calls MPI_Init */
tw_init(&argc, &argv);
if (!conf_file_name[0]) {
tw_error(TW_LOC,
"Expected \"codes-config\" option, please see --help.\n");
return 1;
}
/* loading the config file into the codes-mapping utility, giving us the
* parsed config object in return.
* "config" is a global var defined by codes-mapping */
if (configuration_load(conf_file_name, MPI_COMM_WORLD, &config)) {
tw_error(TW_LOC, "Error loading config file %s.\n", conf_file_name);
return 1;
}
lsm_register();
//lsm_configure();
/* register model-net LPs with ROSS */
model_net_register();
/* register the user LPs */
node_register();
forwarder_register();
/* setup the LPs and codes_mapping structures */
codes_mapping_setup();
/* setup the globals */
int rc = configuration_get_value_int(&config, "server_pings", "num_reqs",
NULL, &num_reqs);
if (rc != 0)
tw_error(TW_LOC, "unable to read server_pings:num_reqs");
int payload_sz_d;
rc = configuration_get_value_int(&config, "server_pings", "payload_sz",
NULL, &payload_sz_d);
if (rc != 0)
tw_error(TW_LOC, "unable to read server_pings:payload_sz");
payload_sz = (uint64_t) payload_sz_d;
/* get the counts for the client and svr clusters */
num_client_nodes = codes_mapping_get_lp_count("client_CLUSTER", 0, "node",
NULL, 1);
num_svr_nodes = codes_mapping_get_lp_count("svr_CLUSTER", 0, "node", NULL,
1);
num_burst_buffer_nodes = codes_mapping_get_lp_count("bb_CLUSTER", 0, "node",
NULL, 1);
num_storage_nodes = codes_mapping_get_lp_count("storage_CLUSTER", 0, "node",
NULL, 1);
num_client_forwarders = codes_mapping_get_lp_count("client_FORWARDERS", 0,
"forwarder", NULL, 1);
num_svr_forwarders = codes_mapping_get_lp_count("svr_FORWARDERS", 0,
"forwarder", NULL, 1);
num_burst_buffer_forwarders = codes_mapping_get_lp_count("bb_FORWARDERS", 0,
"forwarder", NULL, 1);
num_storage_forwarders = codes_mapping_get_lp_count("storage_FORWARDERS", 0,
"forwarder", NULL, 1);
/* Setup the model-net parameters specified in the global config object,
* returned are the identifier(s) for the network type.
* 1 ID -> all the same modelnet model
* 2 IDs -> clusters are the first id, forwarding network the second
* 3 IDs -> client is first, svr and bb second and forwarding network the third
* 4 IDs -> cluster client is the first, svr is the second, burst buffer the third and forwarding network the last
* */
int num_nets;
int *net_ids = model_net_configure(&num_nets);
assert(num_nets <= 5);
if (num_nets == 1) {
net_id_client = net_ids[0];
net_id_svr = net_ids[0];
net_id_bb = net_ids[0];
net_id_storage = net_ids[0];
net_id_forwarding = net_ids[0];
} else if (num_nets == 2) {
net_id_client = net_ids[0];
net_id_svr = net_ids[0];
net_id_bb = net_ids[0];
net_id_storage = net_ids[0];
net_id_forwarding = net_ids[1];
} else if (num_nets == 3) {
net_id_client = net_ids[0];
net_id_svr = net_ids[1];
net_id_bb = net_ids[1];
net_id_storage = net_ids[1];
net_id_forwarding = net_ids[2];
} else if (num_nets == 4) {
net_id_client = net_ids[0];
net_id_svr = net_ids[1];
net_id_bb = net_ids[2];
net_id_storage = net_ids[2];
net_id_forwarding = net_ids[3];
} else {
net_id_client = net_ids[0];
net_id_svr = net_ids[1];
net_id_bb = net_ids[2];
net_id_storage = net_ids[3];
net_id_forwarding = net_ids[4];
}
free(net_ids);
configuration_get_value_int(&config, param_group_nm, num_reqs_key, NULL,
&num_reqs);
configuration_get_value_int(&config, param_group_nm, payload_sz_key, NULL,
(int *) &payload_sz);
configuration_get_value_int(&config, param_group_nm, pvfs_file_sz_key, NULL,
&pvfs_file_sz); /*Sughosh: added for pvfsfs*/
configuration_get_value_int(&config, param_group_nm, bb_file_size_key, NULL,
&bb_file_sz); /*Tony: added for bb*/
configuration_get_value_int(&config, param_group_nm, bb_capacity_key, NULL,
&burst_buffer_max_capacity); /*Tony: added for bb*/
/* begin simulation */
model_net_report_stats(net_id);
tw_run();
tw_end();
return 0;
}
int main( int argc, char** argv )
{
int rank, nprocs;
int num_nets;
int* net_ids;
g_tw_ts_end = s_to_ns(60*60*24*365); /* one year, in nsecs */
workload_type[0]='\0';
tw_opt_add(app_opt);
tw_init(&argc, &argv);
if(strlen(workload_file) == 0)
{
if(tw_ismaster())
printf("\n Usage: mpirun -np n ./codes-nw-test --sync=1/2/3 --workload_type=type --workload_file=workload-file-name");
tw_end();
return -1;
}
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
configuration_load(argv[2], MPI_COMM_WORLD, &config);
nw_add_lp_type();
codes_mapping_setup();
num_net_lps = codes_mapping_get_lp_count("MODELNET_GRP", 0, "nw-lp", NULL, 0);
tw_run();
long long total_bytes_sent, total_bytes_recvd;
double avg_run_time;
double avg_comm_run_time;
double avg_col_run_time;
double total_avg_send_time;
double total_avg_wait_time;
double total_avg_recv_time;
double total_avg_col_time;
double total_avg_comp_time;
long overall_sends, overall_recvs, overall_waits, overall_cols;
MPI_Reduce(&num_bytes_sent, &total_bytes_sent, 1, MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&num_bytes_recvd, &total_bytes_recvd, 1, MPI_LONG_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_time, &avg_run_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_recv_time, &total_avg_recv_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_comm_time, &avg_comm_run_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_col_time, &avg_col_run_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_wait_time, &total_avg_wait_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_send_time, &total_avg_send_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&avg_compute_time, &total_avg_comp_time, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&total_sends, &overall_sends, 1, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&total_recvs, &overall_recvs, 1, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&total_waits, &overall_waits, 1, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
MPI_Reduce(&total_collectives, &overall_cols, 1, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
if(!g_tw_mynode)
printf("\n Total bytes sent %lld recvd %lld \n avg runtime %lf \n avg comm time %lf avg compute time %lf \n avg collective time %lf avg send time %lf \n avg recv time %lf \n avg wait time %lf \n total sends %ld total recvs %ld total waits %ld total collectives %ld ", total_bytes_sent, total_bytes_recvd,
avg_run_time/num_net_lps,
avg_comm_run_time/num_net_lps,
total_avg_comp_time/num_net_lps,
total_avg_col_time/num_net_lps,
total_avg_send_time/num_net_lps,
total_avg_recv_time/num_net_lps,
total_avg_wait_time/num_net_lps,
overall_sends, overall_recvs, overall_waits, overall_cols);
tw_end();
return 0;
}