void handle_testsvr_local(
testsvr_state * ns,
testsvr_msg * m,
tw_lp * lp){
assert(ns->idx == 1);
testsvr_msg m_net;
m_net.magic = testsvr_magic;
m_net.event_type = ACK;
m_net.idx_src = ns->idx;
m_net.lp_src = lp->gid;
m_net.req_num = m->req_num;
tw_lpid dest_lp = m->idx_src * 2;
#if TEST_DEBUG
m_net.src_event_ctr = ns->event_ctr;
#endif
model_net_event(net_id, "ack", dest_lp,
1, 0.0, sizeof(m_net), &m_net, 0, NULL, lp);
ns->req_stat[m->req_num]++;
/* we are handling exactly two reqs per slot */
assert(ns->req_stat[m->req_num] <= 2);
#if TEST_DEBUG
ns->event_ctr++;
#endif
}
static void handle_pong_event(node_state *ns, tw_bf *b, node_msg *m, tw_lp *lp) {
int i;
if(ns->msg_sent_count < num_reqs*num_messages) {
node_msg m_remote;
m_remote.node_event_type = PING;
m_remote.src = lp->gid;
tw_stime tmp = tw_now(lp);
ns->total_ts += tmp - ns->last_ts;
ns->last_ts = tmp;
for (i=0; i<num_messages; i++) {
model_net_event(net_id, "ping", m->src, payload_sz, 0.0, sizeof(node_msg),
(const void *)&m_remote, 0, NULL, lp);
ns->msg_sent_count++;
}
m->incremented_flag = 1;
}
else {
m->incremented_flag = 0;
ns->end_ts = tw_now(lp);
}
return;
}
/* handle initial event */
static void handle_kickoff_event(
svr_state * ns,
tw_bf * b,
svr_msg * m,
tw_lp * lp)
{
assert(ns->server_idx < NUM_SERVERS-1);
// same msg header for all
svr_msg m_remote;
msg_set_header(666, RECV, lp->gid, &m_remote.h);
m_remote.src_svr_idx = ns->server_idx;
// dest LP is the same - the last server
tw_lpid dest = (NUM_SERVERS-1) * 2;
MN_START_SEQ();
for (int i = 0; i < NUM_PRIOS; i++){
m_remote.msg_prio = ns->random_order[i];
//printf("%lu: sending message with prio %d to %lu\n", lp->gid,
//m_remote.msg_prio, dest);
model_net_set_msg_param(MN_MSG_PARAM_SCHED, MN_SCHED_PARAM_PRIO,
(void*) &m_remote.msg_prio);
model_net_event(net_id, "test", dest, PAYLOAD_SZ, 0.0, sizeof(svr_msg),
&m_remote, 0, NULL, lp);
}
MN_END_SEQ();
}
/* handle recving ack */
static void handle_ack_event(
svr_state * ns,
tw_bf * b,
svr_msg * m,
tw_lp * lp)
{
svr_msg * m_local = malloc(sizeof(svr_msg));
svr_msg * m_remote = malloc(sizeof(svr_msg));
// m_local->svr_event_type = REQ;
m_local->svr_event_type = LOCAL;
m_local->src = lp->gid;
memcpy(m_remote, m_local, sizeof(svr_msg));
m_remote->svr_event_type = (do_pull) ? ACK : REQ;
//printf("handle_ack_event(), lp %llu.\n", (unsigned long long)lp->gid);
/* safety check that this request got to the right server */
// printf("\n m->src %d lp->gid %d ", m->src, lp->gid);
int opt_offset = 0;
if(net_id == DRAGONFLY && (lp->gid % lps_per_rep == num_servers_per_rep - 1))
opt_offset = num_servers_per_rep + num_routers_per_rep; /* optional offset due to dragonfly mapping */
tw_lpid dest_id = (lp->gid + offset + opt_offset)%(num_servers*2 + num_routers);
/* in the "pull" case, src should actually be self */
if (do_pull){
assert(m->src == lp->gid);
}
else{
assert(m->src == dest_id);
}
if(ns->msg_sent_count < NUM_REQS)
{
/* send another request */
if (do_pull){
model_net_pull_event(net_id, "test", dest_id, PAYLOAD_SZ, 0.0,
sizeof(svr_msg), (const void*)m_remote, lp);
}
else{
model_net_event(net_id, "test", dest_id, PAYLOAD_SZ, 0.0, sizeof(svr_msg), (const void*)m_remote, sizeof(svr_msg), (const void*)m_local, lp);
}
ns->msg_sent_count++;
m->incremented_flag = 1;
}
else
{
ns->end_ts = tw_now(lp);
m->incremented_flag = 0;
}
return;
}
static void handle_ping_event(node_state *ns, tw_bf *b, node_msg *m, tw_lp *lp) {
node_msg m_remote;
m_remote.node_event_type = PONG;
m_remote.src = lp->gid;
ns->msg_recvd_count++;
model_net_event(net_id, "pong", m->src, payload_sz, 0.0, sizeof(node_msg),
(const void*)&m_remote, 0, NULL, lp);
return;
}
static void handle_kickoff_event(
svr_state * ns,
tw_bf * b,
svr_msg * m,
tw_lp * lp)
{
char* anno;
tw_lpid local_dest = -1, global_dest = -1;
svr_msg * m_local = malloc(sizeof(svr_msg));
svr_msg * m_remote = malloc(sizeof(svr_msg));
m_local->svr_event_type = LOCAL;
m_local->src = lp->gid;
memcpy(m_remote, m_local, sizeof(svr_msg));
m_remote->svr_event_type = REMOTE;
assert(net_id == DRAGONFLY); /* only supported for dragonfly model right now. */
ns->start_ts = tw_now(lp);
codes_mapping_get_lp_info(lp->gid, group_name, &group_index, lp_type_name, &lp_type_index, anno, &rep_id, &offset);
/* in case of uniform random traffic, send to a random destination. */
if(traffic == UNIFORM)
{
local_dest = tw_rand_integer(lp->rng, 0, num_nodes - 1);
// printf("\n LP %ld sending to %d ", lp->gid, local_dest);
}
else if(traffic == NEAREST_GROUP)
{
local_dest = (rep_id * 2 + offset + num_nodes_per_grp) % num_nodes;
// printf("\n LP %ld sending to %ld num nodes %d ", rep_id * 2 + offset, local_dest, num_nodes);
}
else if(traffic == NEAREST_NEIGHBOR)
{
local_dest = (rep_id * 2 + offset + 2) % num_nodes;
// printf("\n LP %ld sending to %ld num nodes %d ", rep_id * 2 + offset, local_dest, num_nodes);
}
assert(local_dest < num_nodes);
codes_mapping_get_lp_id(group_name, lp_type_name, anno, 1, local_dest / num_servers_per_rep, local_dest % num_servers_per_rep, &global_dest);
ns->msg_sent_count++;
model_net_event(net_id, "test", global_dest, PAYLOAD_SZ, 0.0, sizeof(svr_msg), (const void*)m_remote, sizeof(svr_msg), (const void*)m_local, lp);
issue_event(ns, lp);
return;
}
/* handle initial event */
static void handle_kickoff_event(
svr_state * ns,
tw_bf * b,
svr_msg * m,
tw_lp * lp)
{
svr_msg * m_local = malloc(sizeof(svr_msg));
svr_msg * m_remote = malloc(sizeof(svr_msg));
// m_local->svr_event_type = REQ;
m_local->svr_event_type = LOCAL;
m_local->src = lp->gid;
memcpy(m_remote, m_local, sizeof(svr_msg));
m_remote->svr_event_type = (do_pull) ? ACK : REQ;
//printf("handle_kickoff_event(), lp %llu.\n", (unsigned long long)lp->gid);
/* record when transfers started on this server */
ns->start_ts = tw_now(lp);
num_servers_per_rep = codes_mapping_get_lp_count("MODELNET_GRP", 1,
"server", NULL, 1);
num_routers_per_rep = codes_mapping_get_lp_count("MODELNET_GRP", 1,
"dragonfly_router", NULL, 1);
lps_per_rep = num_servers_per_rep * 2 + num_routers_per_rep;
int opt_offset = 0;
int total_lps = num_servers * 2 + num_routers;
if(net_id == DRAGONFLY && (lp->gid % lps_per_rep == num_servers_per_rep - 1))
opt_offset = num_servers_per_rep + num_routers_per_rep; /* optional offset due to dragonfly mapping */
/* each server sends a request to the next highest server */
int dest_id = (lp->gid + offset + opt_offset)%total_lps;
if (do_pull){
model_net_pull_event(net_id, "test", dest_id, PAYLOAD_SZ, 0.0,
sizeof(svr_msg), (const void*)m_remote, lp);
}
else{
model_net_event(net_id, "test", dest_id, PAYLOAD_SZ, 0.0, sizeof(svr_msg), (const void*)m_remote, sizeof(svr_msg), (const void*)m_local, lp);
}
ns->msg_sent_count++;
}
static void handle_init_event(node_state *ns, tw_bf *b, node_msg *m, tw_lp *lp) {
int dest_id;
node_msg m_remote;
m_remote.node_event_type = PING;
m_remote.src = lp->gid;
ns->start_ts = tw_now(lp);
ns->last_ts = ns->start_ts;
dest_id = get_next_node(lp->gid);
if (dest_id == -1) return;
int dim_lens[3] = {10, 10, 10};
model_net_torus_get_dim_id(dest_id, 3, dim_lens, ns->dest_dim_id); //dim length hard-coded for now
model_net_event(net_id, "ping", dest_id, payload_sz, 0.0, sizeof(node_msg),
(const void*)&m_remote, 0, NULL, lp);
ns->msg_sent_count++;
}
void handle_data_upload_req_event(
shock_router_state * ns,
tw_bf * b,
awe_msg * m,
tw_lp * lp)
{
awe_msg m_remote;
tw_lpid dest_id = m->next_hop;
m_remote.event_type = UPLOAD_REQ;
m_remote.src = lp->gid;
m_remote.last_hop = m->src;
strcpy(m_remote.object_id, m->object_id);
m_remote.size = m->size;
//printf("[%lf][shock_router][%lu][StartSending]client=%lu;filesize=%llu\n", now_sec(lp), lp->gid, m->src, m->size);
model_net_event(net_id, "upload", dest_id, m->size, 0.0, sizeof(awe_msg), (const void*)&m_remote, 0, NULL, lp);
ns->size_download += m->size;
}
void handle_data_download_event(
shock_state * ns,
tw_bf * b,
awe_msg * m,
tw_lp * lp)
{
awe_msg m_remote;
tw_lpid dest_id = m->src;
m_remote.event_type = INPUT_DATA_DOWNLOAD;
m_remote.src = lp->gid;
strcpy(m_remote.object_id, m->object_id);
m_remote.size = m->size;
//printf("[%lf][shock][%lu][StartSending]client=%lu;filesize=%llu\n", now_sec(lp), lp->gid, m->src, m->size);
model_net_event(net_id, "download", dest_id, m->size, sizeof(awe_msg), (const void*)&m_remote, 0, NULL, lp);
ns->size_download += m->size;
return;
}
/* handle receiving request
* (note: this should never be called when doing the "pulling" version of
* the program) */
static void handle_req_event(
svr_state * ns,
tw_bf * b,
svr_msg * m,
tw_lp * lp)
{
assert(!do_pull);
svr_msg * m_local = malloc(sizeof(svr_msg));
svr_msg * m_remote = malloc(sizeof(svr_msg));
m_local->svr_event_type = LOCAL;
m_local->src = lp->gid;
memcpy(m_remote, m_local, sizeof(svr_msg));
m_remote->svr_event_type = ACK;
//printf("handle_req_event(), lp %llu src %llu .\n", (unsigned long long)lp->gid, (unsigned long long) m->src);
/* safety check that this request got to the right server */
// printf("\n m->src %d lp->gid %d ", m->src, lp->gid);
int opt_offset = 0;
if(net_id == DRAGONFLY && (m->src % lps_per_rep == num_servers_per_rep - 1))
opt_offset = num_servers_per_rep + num_routers_per_rep; /* optional offset due to dragonfly mapping */
assert(lp->gid == (m->src + offset + opt_offset)%(num_servers*2 + num_routers));
ns->msg_recvd_count++;
/* send ack back */
/* simulated payload of 1 MiB */
/* also trigger a local event for completion of payload msg */
/* remote host will get an ack event */
// mm Q: What should be the size of an ack message? may be a few bytes? or larger..?
model_net_event(net_id, "test", m->src, PAYLOAD_SZ, 0.0, sizeof(svr_msg), (const void*)m_remote, sizeof(svr_msg), (const void*)m_local, lp);
// printf("\n Sending ack to LP %d %d ", m->src, m_remote->src);
return;
}
void handle_testsvr_kickoff(
testsvr_state * ns,
testsvr_msg * m,
tw_lp * lp){
assert(ns->idx == 0 || ns->idx == 2);
int req;
for (req = 0; req < NUM_REQS; req++){
tw_lpid dest_lp = (1) * 2; /* send to server 1 */
testsvr_msg m_net;
m_net.magic = testsvr_magic;
m_net.event_type = REQ;
m_net.idx_src = ns->idx;
m_net.lp_src = lp->gid;
#if TEST_DEBUG
m_net.src_event_ctr = ns->event_ctr++;
#endif
m_net.req_num = req;
model_net_event(net_id, "req", dest_lp, 1, 0.0, sizeof(m_net), &m_net, 0, NULL, lp);
}
#if TEST_DEBUG
ns->event_ctr++;
#endif
}
/*Processes the packet after it arrives from the neighboring torus node
* routes it to the next compute node if this is not the destination
* OR if this is the destination then a remote event at the server is issued. */
static void packet_arrive( nodes_state * s,
tw_bf * bf,
nodes_message * msg,
tw_lp * lp )
{
bf->c2 = 0;
tw_event *e;
tw_stime ts;
nodes_message *m;
mn_stats* stat;
credit_send( s, bf, lp, msg);
msg->my_N_hop++;
ts = 0.1 + tw_rand_exponential(lp->rng, MEAN_INTERVAL/200);
if(msg->packet_ID == TRACE)
printf("\n packet arrived at lp %d final dest %d ", (int)lp->gid, (int)msg->dest_lp);
if( lp->gid == msg->dest_lp )
{
uint64_t num_chunks = msg->packet_size/s->params->chunk_size;
if(msg->packet_size % s->params->chunk_size)
num_chunks++;
if( msg->chunk_id == num_chunks - 1 )
{
bf->c2 = 1;
stat = model_net_find_stats(msg->category, s->torus_stats_array);
stat->recv_count++;
stat->recv_bytes += msg->packet_size;
stat->recv_time += tw_now( lp ) - msg->travel_start_time;
/*count the number of packets completed overall*/
N_finished_packets++;
total_time += tw_now( lp ) - msg->travel_start_time;
total_hops += msg->my_N_hop;
if (max_latency < tw_now( lp ) - msg->travel_start_time) {
bf->c3 = 1;
msg->saved_available_time = max_latency;
max_latency=tw_now( lp ) - msg->travel_start_time;
}
// Trigger an event on receiving server
if(msg->remote_event_size_bytes)
{
void *tmp_ptr = model_net_method_get_edata(TORUS, msg);
if (msg->is_pull) {
int net_id = model_net_get_id(LP_METHOD_NM);
model_net_event(net_id, msg->category, msg->sender_svr,
msg->pull_size, 0.0, msg->remote_event_size_bytes,
tmp_ptr, 0, NULL, lp);
}
else {
e = tw_event_new(msg->final_dest_gid, ts, lp);
m = tw_event_data(e);
memcpy(m, tmp_ptr, msg->remote_event_size_bytes);
tw_event_send(e);
}
}
}
}
else
{
//e = tw_event_new(lp->gid, ts , lp);
//m = tw_event_data( e );
//memcpy(m, msg, torus_get_msg_sz() + msg->remote_event_size_bytes);
void *m_data;
e = model_net_method_event_new(lp->gid, ts, lp, TORUS, (void**)&m,
&m_data);
memcpy(m, msg, sizeof(nodes_message));
if (msg->remote_event_size_bytes) {
memcpy(m_data, model_net_method_get_edata(TORUS, msg),
msg->remote_event_size_bytes);
}
m->type = SEND;
m->next_stop = -1;
tw_event_send(e);
}
}
