//Reverse Event Handler
void model_event_reverse (state *s, tw_bf *bf, message *in_msg, tw_lp *lp) {
int self = lp->gid;
// undo the state update using the value stored in the 'reverse' message
SWAP(&(s->value), &(in_msg->contents));
// handle the message
switch (in_msg->type) {
case HELLO :
{
s->rcvd_count_H--;
break;
}
case GOODBYE :
{
s->rcvd_count_G--;
break;
}
default :
printf("Unhandeled reverse message type %d\n", in_msg->type);
}
// don't forget to undo all rng calls
tw_rand_reverse_unif(lp->rng);
tw_rand_reverse_unif(lp->rng);
}
void Airport_RC_EventHandler(Airport_State *SV, tw_bf *CV, Msg_Data *M,
tw_lp *lp) {
switch(M->event_type) {
case ARRIVAL:
SV->InTheAir--;
if(CV->c1){
SV->RunwayFree = 1;
tw_rand_reverse_unif(lp->id);
}
break;
case LAND:
SV->InTheAir++;
SV->OnTheGround--;
SV->NumLanded--;
tw_rand_reverse_unif(lp->id);
if(CV->c1)
tw_rand_reverse_unif(lp->id);
else
SV->RunwayFree = 0;
break;
case DEPARTURE:
SV->OnTheGround++;
tw_rand_reverse_unif(lp->id);
break;
}
}
void
mem_event_handler_rc(mem_state * s, tw_bf * bf, mem_message * m, tw_lp * lp)
{
tw_memory *b;
int i;
s->stats.s_rb++;
s->stats.s_recv--;
tw_rand_reverse_unif(lp->rng);
tw_rand_reverse_unif(lp->rng);
if(bf->c1 == 1)
tw_rand_reverse_unif(lp->rng);
// undo the membuf frees and reattach them to the RB event
for(i = 0; i < nbufs; i++)
{
b = tw_memory_free_rc(lp, my_fd);
s->stats.s_mem_free_rc++;
tw_event_memory_get_rc(lp, b, my_fd);
s->stats.s_mem_get_rc++;
/*
* unnecessary to undo the allocs ..
* they will be reclaimed when the events are reclaimed.
*/
}
// sanity check
if(i != nbufs)
tw_error(TW_LOC, "Did not free_rc %d (%d) memory buffers!",
nbufs, i);
}
void
phold_event_handler_rc(phold_state * s, tw_bf * bf, phold_message * m, tw_lp * lp)
{
tw_rand_reverse_unif(lp->rng);
tw_rand_reverse_unif(lp->rng);
if(bf->c1 == 1)
tw_rand_reverse_unif(lp->rng);
}
void wifi_station_arrival_rc(wifi_access_point_state * s, tw_bf * bf, wifi_message * m, tw_lp * lp)
{
tw_rand_reverse_unif(lp->rng);
tw_rand_reverse_unif(lp->rng);
if( bf->c1 )
{
s->stations[m->station].failed_packets--;
}
}
void wifi_access_point_arrival_rc(wifi_access_point_state * s, tw_bf * bf, wifi_message * m, tw_lp * lp)
{
s->total_packets--;
// packets coming from access point have much more power and so better snr
tw_rand_reverse_unif(lp->rng);
tw_rand_reverse_unif(lp->rng);
if( bf->c1 )
{
s->failed_packets--;
}
}
void
r_msg_open(bgp_state * state, tw_bf * bf, bgp_message * msg, tw_lp * lp)
{
int i;
if (bf->c1)
{
for (i = 0; i < state->routes.size; i++)
{
tw_rand_reverse_unif(lp->id);
}
}
tw_rand_reverse_unif(lp->id);
state->stats->s_nopens--;
}
/* reverse handler code for a MPI process LP */
void mpi_event_rc_handler( mpi_process * p,
tw_bf * bf,
nodes_message * msg,
tw_lp * lp)
{
switch(msg->type)
{
case MPI_SEND:
{
if(bf->c4)
return;
if(bf->c3)
tw_rand_reverse_unif(lp->rng);
int i;
for( i=0; i < num_packets; i++ )
{
tw_rand_reverse_unif(lp->rng);
p->available_time = msg->saved_available_time;
p->message_counter--;
}
tw_rand_reverse_unif(lp->rng);
}
break;
case MPI_RECV:
{
int index = floor( N_COLLECT_POINTS * ( tw_now( lp ) / g_tw_ts_end ) );
N_finished_msgs--;
N_finished_packets--;
N_finished_storage[index]--;
N_num_hops[index] -= msg->my_N_hop;
total_time -= tw_now( lp ) - msg->travel_start_time;
total_hops-=msg->my_N_hop;
if(bf->c3)
max_latency= msg->saved_available_time;
}
break;
}
}
void
r_msg_keepalivetimer(bgp_state * state, tw_bf * bf, bgp_message * msg, tw_lp * lp)
{
int i;
for (i = 0; i <= state->n_interfaces; i++)
tw_rand_reverse_unif(lp->id);
state->stats->s_nkeepalivetimers--;
}
// Reverse Event Handler
void raid_controller_eventhandler_rc( ContState* s, tw_bf* cv, MsgData* m, tw_lp* lp )
{
int i;
s->condition = m->rc.controller_condition;
if( m->event_type == DISK_REPLACED || s->condition != FAILED )
{
s->num_rebuilds--;
for( i = 0; i < m->rc.rng_calls; ++i )
tw_rand_reverse_unif( lp->rng );
}
}
void
tmr_event_handler_rc(tmr_state * s, tw_bf * bf, tmr_message * m, tw_lp * lp)
{
if(bf->c1)
{
// old timer may be NULL
fprintf(f, "%lld: rc tmr fired at %lf\n",
lp->gid, tw_now(lp));
s->timer = m->old_timer;
m->old_timer = NULL;
return;
}
if(bf->c2)
{
if(s->timer == NULL)
{
s->timer = tw_timer_init(lp, m->old_time);
m->old_time = 0.0;
fprintf(f, "%lld: restore tmr to %lf\n",
lp->gid, s->timer->recv_ts);
} else
{
tw_timer_reset(lp, &s->timer, m->old_time);
m->old_time = 0.0;
fprintf(f, "%lld: reset tmr to %lf \n",
lp->gid, s->timer->recv_ts);
}
}
tw_rand_reverse_unif(lp->rng);
tw_rand_reverse_unif(lp->rng);
if(bf->c3 == 1)
tw_rand_reverse_unif(lp->rng);
}
void
tcp_router_forward_rc(Router_State *SV, tw_bf *CV, Msg_Data *M, tw_lp * lp)
{
int nexthop_link = tcp_util_nexthop_link(lp,M->dest);
tw_rand_reverse_unif(lp->id);
if(CV->c1 || CV->c2)
SV->lastsent[nexthop_link] = M->RC.rtt_time;
else {
/* switch(g_routers_links[lp->id][nexthop_link].buffer_sz){
case 12400000:
SV->dropped_packets[0]++;
break;
case 3000000:
SV->dropped_packets[1]++;
break;
case 775000:
SV->dropped_packets[2]++;
break;
case 200000:
SV->dropped_packets[3]++;
break;
case 60000:
SV->dropped_packets[4]++;
break;
case 20000:
SV->dropped_packets[5]++;
break;
case 10000:
SV->dropped_packets[6]++;
break;
case 5000:
SV->dropped_packets[7]++;
break;
default:
printf("there has been error in buffer_sz %d\n",
g_routers_links[lp->id][nexthop_link].buffer_sz);
exit(0);
}*/
SV->dropped_packets--;
}
}
void Intersection_RC_EventHandler(Intersection_State *SV, tw_bf *CV, Msg_Data *M, tw_lp *lp)
{
enum abs_directions temp_direction;
*(int *)CV = (int)0;
switch(M->event_type)
{
case ARIVAL:
if(M->car.x_to_go == 0 && M->car.y_to_go == 0)
{
SV->total_cars_finished--;
break;
}
// Schedule a departure in the future
SV->total_cars_arrived--;
switch(M->car.current_lane)
{
case WEST_LEFT:
SV->num_in_east_left--;
break;
case WEST_STRAIGHT:
SV->num_in_east_straight--;
break;
case WEST_RIGHT:
SV->num_in_east_right++;
break;
case EAST_LEFT:
SV->num_in_west_left++;
break;
case EAST_STRAIGHT:
SV->num_in_west_straight++;
break;
case EAST_RIGHT:
SV->num_in_west_right++;
break;
case NORTH_LEFT:
SV->num_in_south_left++;
break;
case NORTH_STRAIGHT:
SV->num_in_south_straight++;
break;
case NORTH_RIGHT:
SV->num_in_south_right++;
break;
case SOUTH_LEFT:
SV->num_in_north_left++;
break;
case SOUTH_STRAIGHT:
SV->num_in_north_straight++;
break;
case SOUTH_RIGHT:
SV->num_in_north_right++;
break;
}
// ts = tw_rand_exponential(lp->rng, MEAN_SERVICE);
tw_rand_reverse_unif( lp->rng );
break;
case DEPARTURE:
switch(M->car.current_lane){
case WEST_LEFT:
SV->num_out_west_left++;
break;
case WEST_STRAIGHT:
SV->num_out_west_straight++;
break;
case WEST_RIGHT:
SV->num_out_west_right++;
break;
case EAST_LEFT:
SV->num_out_east_left++;
break;
case EAST_STRAIGHT:
SV->num_out_east_straight++;
break;
case EAST_RIGHT:
SV->num_out_east_right++;
break;
case NORTH_LEFT:
SV->num_out_north_left++;
break;
case NORTH_STRAIGHT:
SV->num_out_north_straight++;
break;
case NORTH_RIGHT:
SV->num_out_north_right++;
break;
case SOUTH_LEFT:
SV->num_out_south_left++;
break;
case SOUTH_STRAIGHT:
SV->num_out_south_straight++;
break;
case SOUTH_RIGHT:
SV->num_out_south_right++;
break;
}
// ts = tw_rand_exponential(lp->rng, MEAN_SERVICE);
tw_rand_reverse_unif( lp->rng );
break;
case DIRECTION_SELECT:
temp_direction = M->car.current_lane;
switch(M->car.current_lane){
case EAST_LEFT:
SV->num_in_east_left++;
if(M->car.y_to_go < 0 && SV->num_out_south_straight < MAX_CARS_ON_ROAD){
SV->num_out_south_straight --;
}
else if(M->car.x_to_go < 0 && SV->num_out_south_right < MAX_CARS_ON_ROAD){
SV->num_out_south_right --;
}
else if(M->car.x_to_go > 0 && SV->num_out_south_left < MAX_CARS_ON_ROAD){
SV->num_out_south_left --;
}
else{
if(M->car.arrived_from == SOUTH_LEFT){
SV->num_out_east_right--;
}
else if(M->car.arrived_from == EAST_STRAIGHT){
SV->num_out_east_straight--;
}
else if(M->car.arrived_from == NORTH_RIGHT){
SV->num_out_east_left--;
}
}
break;
case EAST_STRAIGHT:
SV->num_in_east_straight++;
if(M->car.x_to_go < 0 && SV->num_out_west_straight < MAX_CARS_ON_ROAD){
SV->num_out_west_straight --;
}
else if(M->car.y_to_go < 0 && SV->num_out_west_left < MAX_CARS_ON_ROAD){
SV->num_out_west_left --;
}
else if(M->car.y_to_go > 0 && SV->num_out_west_right < MAX_CARS_ON_ROAD){
SV->num_out_west_right --;
}
else{
if(M->car.arrived_from == NORTH_RIGHT){
SV->num_out_east_left--;
}
else if(M->car.arrived_from == EAST_STRAIGHT){
SV->num_out_east_straight--;
}
else if(M->car.arrived_from == SOUTH_LEFT){
SV->num_out_east_right++;
}
}
break;
case EAST_RIGHT:
SV->num_in_east_right++;
if(M->car.y_to_go > 0 && SV->num_out_north_straight < MAX_CARS_ON_ROAD){
SV->num_out_north_straight --;
}
else if(M->car.x_to_go > 0 && SV->num_out_north_right < MAX_CARS_ON_ROAD){
SV->num_out_north_right --;
}
else if(M->car.x_to_go < 0 && SV->num_out_north_left < MAX_CARS_ON_ROAD){
SV->num_out_north_left --;
}
else{
if(M->car.arrived_from == SOUTH_LEFT){
SV->num_out_east_right--;
}
else if(M->car.arrived_from == EAST_STRAIGHT){
SV->num_out_east_straight--;
}
else if(M->car.arrived_from == NORTH_RIGHT){
SV->num_out_east_left--;
}
}
break;
case WEST_LEFT:
SV->num_in_west_left++;
if(M->car.y_to_go > 0 && SV->num_out_north_straight < MAX_CARS_ON_ROAD){
SV->num_out_north_straight --;
}
else if(M->car.x_to_go > 0 && SV->num_out_north_right < MAX_CARS_ON_ROAD){
SV->num_out_north_right --;
}
else if(M->car.x_to_go < 0 && SV->num_out_north_left < MAX_CARS_ON_ROAD){
SV->num_out_north_left --;
}
else{
if(M->car.arrived_from == SOUTH_RIGHT){
SV->num_out_west_left--;
}
else if(M->car.arrived_from == WEST_STRAIGHT){
SV->num_out_west_straight--;
}
else if(M->car.arrived_from == NORTH_LEFT){
SV->num_out_west_right--;
}
}
break;
case WEST_STRAIGHT:
SV->num_in_west_straight++;
if(M->car.x_to_go > 0 && SV->num_out_east_straight < MAX_CARS_ON_ROAD){
SV->num_out_east_straight --;
}
else if(M->car.y_to_go > 0 && SV->num_out_east_left < MAX_CARS_ON_ROAD){
SV->num_out_east_left --;
}
else if(M->car.y_to_go < 0 && SV->num_out_east_right < MAX_CARS_ON_ROAD){
SV->num_out_east_right --;
}
else{
if(M->car.arrived_from == SOUTH_RIGHT){
SV->num_out_west_left--;
}
else if(M->car.arrived_from == WEST_STRAIGHT){
SV->num_out_west_straight--;
}
else if(M->car.arrived_from == NORTH_LEFT){
SV->num_out_west_right--;
}
}
break;
case WEST_RIGHT:
SV->num_in_west_right++;
if(M->car.y_to_go < 0 && SV->num_out_south_straight < MAX_CARS_ON_ROAD){
SV->num_out_south_straight --;
}
else if(M->car.x_to_go > 0 && SV->num_out_south_left < MAX_CARS_ON_ROAD){
SV->num_out_south_left --;
}
else if(M->car.x_to_go < 0 && SV->num_out_south_right < MAX_CARS_ON_ROAD){
SV->num_out_south_right --;
}
else{
if(M->car.arrived_from == SOUTH_RIGHT){
SV->num_out_west_left--;
}
else if(M->car.arrived_from == WEST_STRAIGHT){
SV->num_out_west_straight--;
}
else if(M->car.arrived_from == NORTH_LEFT){
SV->num_out_west_right--;
}
}
break;
case NORTH_LEFT:
SV->num_in_north_left++;
if(M->car.x_to_go > 0 && SV->num_out_east_straight < MAX_CARS_ON_ROAD){
SV->num_out_east_straight --;
}
else if(M->car.y_to_go > 0 && SV->num_out_east_left < MAX_CARS_ON_ROAD){
SV->num_out_east_left --;
}
else if(M->car.y_to_go < 0 && SV->num_out_east_right < MAX_CARS_ON_ROAD){
SV->num_out_east_right --;
}
else{
if(M->car.arrived_from == WEST_RIGHT){
SV->num_out_north_left--;
}
else if(M->car.arrived_from == NORTH_STRAIGHT){
SV->num_out_north_straight--;
}
else if(M->car.arrived_from == EAST_LEFT){
SV->num_out_north_right--;
}
}
break;
case NORTH_STRAIGHT:
SV->num_in_north_straight++;
if(M->car.y_to_go < 0 && SV->num_out_south_straight < MAX_CARS_ON_ROAD){
SV->num_out_south_straight --;
}
else if(M->car.x_to_go > 0 && SV->num_out_south_left < MAX_CARS_ON_ROAD){
SV->num_out_south_left --;
}
else if(M->car.x_to_go < 0 && SV->num_out_south_right < MAX_CARS_ON_ROAD){
SV->num_out_south_right --;
}
else{
if(M->car.arrived_from == WEST_RIGHT){
SV->num_out_north_left--;
}
else if(M->car.arrived_from == NORTH_STRAIGHT){
SV->num_out_north_straight--;
}
else if(M->car.arrived_from == EAST_LEFT){
SV->num_out_north_right--;
}
}
break;
case NORTH_RIGHT:
SV->num_in_north_right++;
if(M->car.x_to_go < 0 && SV->num_out_west_straight < MAX_CARS_ON_ROAD){
SV->num_out_west_straight --;
}
else if(M->car.y_to_go < 0 && SV->num_out_west_left < MAX_CARS_ON_ROAD){
SV->num_out_west_left --;
}
else if(M->car.y_to_go > 0 && SV->num_out_west_right < MAX_CARS_ON_ROAD){
SV->num_out_west_right --;
}
else{
if(M->car.arrived_from == WEST_RIGHT){
SV->num_out_north_left--;
}
else if(M->car.arrived_from == NORTH_STRAIGHT){
SV->num_out_north_straight--;
}
else if(M->car.arrived_from == EAST_LEFT){
SV->num_out_north_right--;
}
}
break;
case SOUTH_LEFT:
SV->num_in_south_left++;
if(M->car.x_to_go < 0 && SV->num_out_west_straight < MAX_CARS_ON_ROAD){
SV->num_out_west_straight --;
}
else if(M->car.y_to_go < 0 && SV->num_out_west_left < MAX_CARS_ON_ROAD){
SV->num_out_west_left --;
}
else if(M->car.y_to_go > 0 && SV->num_out_west_right < MAX_CARS_ON_ROAD){
SV->num_out_west_right --;
}
else{
if(M->car.arrived_from == WEST_LEFT){
SV->num_out_south_right--;
}
else if(M->car.arrived_from == SOUTH_STRAIGHT){
SV->num_out_south_straight--;
}
else if(M->car.arrived_from == EAST_RIGHT){
SV->num_out_south_left--;
}
}
break;
case SOUTH_STRAIGHT:
SV->num_in_south_straight++;
if(M->car.y_to_go > 0 && SV->num_out_north_straight < MAX_CARS_ON_ROAD){
SV->num_out_north_straight --;
}
else if(M->car.x_to_go < 0 && SV->num_out_north_left < MAX_CARS_ON_ROAD){
SV->num_out_north_left --;
}
else if(M->car.x_to_go > 0 && SV->num_out_north_right < MAX_CARS_ON_ROAD){
SV->num_out_north_right --;
}
else{
if(M->car.arrived_from == EAST_RIGHT){
SV->num_out_south_left--;
}
else if(M->car.arrived_from == SOUTH_STRAIGHT){
SV->num_out_south_straight--;
}
else if(M->car.arrived_from == WEST_LEFT){
SV->num_out_south_right--;
}
}
break;
case SOUTH_RIGHT:
SV->num_in_south_right++;
if(M->car.x_to_go > 0 && SV->num_out_east_straight < MAX_CARS_ON_ROAD){
SV->num_out_east_straight --;
}
else if(M->car.y_to_go > 0 && SV->num_out_east_left < MAX_CARS_ON_ROAD){
SV->num_out_east_left --;
}
else if(M->car.y_to_go < 0 && SV->num_out_east_right < MAX_CARS_ON_ROAD){
SV->num_out_east_right --;
}
else{
if(M->car.arrived_from == EAST_RIGHT){
SV->num_out_south_left--;
}
else if(M->car.arrived_from == SOUTH_STRAIGHT){
SV->num_out_south_straight--;
}
else if(M->car.arrived_from == WEST_LEFT){
SV->num_out_south_right--;
}
}
break;
}
// ts = tw_rand_exponential(lp->rng, MEAN_SERVICE);
tw_rand_reverse_unif( lp->rng );
break;
}
}
void nw_test_event_handler_rc(nw_state* s, tw_bf * bf, nw_message * m, tw_lp * lp)
{
codes_workload_get_next_rc(wrkld_id, 0, (int)s->nw_id, &m->op);
if(m->op.op_type == CODES_WK_END)
return;
s->total_time -= (m->op.end_time - m->op.start_time);
switch(m->op.op_type)
{
case CODES_WK_SEND:
case CODES_WK_ISEND:
{
s->num_sends--;
s->send_time -= (m->op.end_time - m->op.start_time);
num_bytes_sent -= m->op.u.send.num_bytes;
};
break;
case CODES_WK_RECV:
case CODES_WK_IRECV:
{
s->num_recvs--;
s->recv_time -= (m->op.end_time - m->op.start_time);
num_bytes_recvd -= m->op.u.recv.num_bytes;
}
break;
case CODES_WK_DELAY:
{
s->num_delays--;
s->compute_time -= (m->op.end_time - m->op.start_time);
}
break;
case CODES_WK_BCAST:
case CODES_WK_ALLGATHER:
case CODES_WK_ALLGATHERV:
case CODES_WK_ALLTOALL:
case CODES_WK_ALLTOALLV:
case CODES_WK_REDUCE:
case CODES_WK_ALLREDUCE:
case CODES_WK_COL:
{
s->num_cols--;
s->col_time -= (m->op.end_time - m->op.start_time);
}
break;
case CODES_WK_WAIT:
{
s->num_wait--;
s->wait_time -= (m->op.end_time - m->op.start_time);
}
break;
case CODES_WK_WAITALL:
{
s->num_waitall--;
s->wait_time -= (m->op.end_time - m->op.start_time);
}
break;
case CODES_WK_WAITSOME:
{
s->num_waitsome--;
s->wait_time -= (m->op.end_time - m->op.start_time);
}
break;
case CODES_WK_WAITANY:
{
s->num_waitany--;
s->wait_time -= (m->op.end_time - m->op.start_time);
}
break;
default:
{
printf("\n Invalid op type %d", m->op.op_type);
return;
}
}
tw_rand_reverse_unif(lp->rng);
}
void
r_msg_update(bgp_state * state, tw_bf * bf, bgp_message * msg, tw_lp * lp)
{
int i;
if (bf->c6)
{
for (i = 0; i < msg->rev_num_neighbors; i++)
{
tw_rand_reverse_unif(lp->id);
}
}
if (bf->c1)
{ // reverse add
tw_memory *as_path;
if (bf->c2)
{
if (bf->c3)
{
tw_memoryq_delete_any(&state->routes, msg->this_route);
// state->routes.remove(msg->this_bgp_route);
// state->routes.pop_back(); // makes it non-deterministic
if (bf->c4)
{
tw_memory *jim = tw_memory_free_rc(lp, g_bgp_fd_rtes);
bgp_route *rjim = tw_memory_data(jim);;
tw_memoryq_push(&state->routes, jim);
// state->bgp_routes.push_back(msg->erased_route);
bzero(&rjim->as_path, sizeof(rjim->as_path));
while (msg->rc_asp)
{
tw_memoryq_push(&rjim->as_path,
tw_memory_free_rc(lp, g_bgp_fd_asp));
msg->rc_asp--;
}
}
}
}
while ((as_path =
tw_memoryq_pop(&((bgp_route *) msg->this_route->data)->
as_path)))
tw_event_memory_get_rc(lp, as_path, g_bgp_fd_asp);
state->stats->s_nupdateadds--;
} else
{ // reverse remove
if (bf->c5)
{
int i = msg->rc_asp;
tw_memory *it4;
bgp_route *r;
msg->this_route = tw_memory_free_rc(lp, g_bgp_fd_rtes);
while (i)
{
tw_event_memory_get_rc(lp, tw_memory_free_rc(lp, g_bgp_fd_asp),
g_bgp_fd_asp);
i--;
}
it4 = tw_memory_free_rc(lp, g_bgp_fd_rtes);
r = tw_memory_data(it4);
bzero(&r->as_path, sizeof(r->as_path));
while (msg->rc_asp)
{
tw_memoryq_push(&r->as_path,
tw_memory_free_rc(lp, g_bgp_fd_asp));
msg->rc_asp--;
}
tw_memoryq_push(&state->routes, it4);
// state->bgp_routes.push_back(msg->erased_bgp_route);
}
state->stats->s_nupdateremoves--;
}
tw_event_memory_get_rc(lp, msg->this_route, g_bgp_fd_rtes);
msg->this_route = NULL;
}
// Reverse Intersection Event Handler that is called when a Time Warp is initiated:
void traffic_light_intersection_reverse_eventhandler(
intersection_state* SV,
tw_bf* CV,
message_data* M,
tw_lp* LP) {
tw_lpid next_intersection;
tw_stime queue_wait_time;
// Unknown time warp bit field:
*(int*) CV = (int) 0;
// Handle the events defined in the "events" enumeration, but in reverse:
switch(M->event_type) {
case LIGHT_CHANGE:
// Check if the traffic is permitted north-south (green on north and south lights):
if (SV->traffic_direction == NORTH_SOUTH_LEFT) {
// Traffic was permitted NORTH_SOUTH_LEFT; switch permitted traffic to EAST_WEST:
SV->traffic_direction = EAST_WEST;
// Update the timers on the lights
SV->east_west_green_until = M->saved_green_until;
}
else if(SV->traffic_direction == NORTH_SOUTH) {
// Switch permitted traffic to NORTH_SOUTH_LEFT:
SV->traffic_direction = NORTH_SOUTH_LEFT;
// Update the timers on the lights
SV->north_south_left_green_until = M->saved_green_until;
} else if (SV->traffic_direction == EAST_WEST_LEFT) {
// Switch permitted traffic to NORTH_SOUTH:
SV->traffic_direction = NORTH_SOUTH;
// Update the timers on the lights
SV->north_south_green_until = M->saved_green_until;
} else if (SV->traffic_direction == EAST_WEST) {
// Switch permitted traffic to EAST_WEST_LEFT:
SV->traffic_direction = EAST_WEST_LEFT;
// Update the timers on the lights
SV->east_west_left_green_until = M->saved_green_until;
}
break;
case CAR_ARRIVES:
// Car reached its destination:
if(M->car.y_to_go == 0 && M->car.x_to_go == 0) {
SV->total_cars_finished--;
g_total_time -= (M->car.end_time - M->car.start_time);
printf("Car unfinished!\n");
break;
}
// Increment the total number of cars in this intersection:
SV->total_cars_arrived--;
// follows the y path first
// The car is too far south; have the car head up north:
if(M->car.y_to_go > 0) {
SV->num_cars_south--;
M->car.y_to_go++;
}
else if(M->car.y_to_go < 0) {
SV->num_cars_north--;
M->car.y_to_go--;
}
else if(M->car.y_to_go == 0) {
//TODO: figure out how to reverse has_turned
//TODO: also, much of this might be wrong...
if(M->car.has_turned) {
if(M->car.x_to_go > 0) {
SV->num_cars_west--;
M->car.x_to_go++;
}
else if(M->car.x_to_go < 0) {
SV->num_cars_east--;
M->car.x_to_go--;
}
}
else {
if(M->car.x_to_go > 0) {
if(M->car.y_to_go_original > 0) {
SV->num_cars_south--;
} else {
SV->num_cars_north_left--;
}
M->car.x_to_go++;
}
else if(M->car.x_to_go < 0) {
if(M->car.y_to_go_original > 0) {
SV->num_cars_south_left--;
} else {
SV->num_cars_north--;
}
M->car.x_to_go--;
}
}
}
tw_rand_reverse_unif(LP->rng);
break;
}
} /** END FUNCTION intersection_reverse_eventhandler **/
/* reverse handler code for a node */
void node_rc_handler(nodes_state * s, tw_bf * bf, nodes_message * msg, tw_lp * lp)
{
switch(msg->type)
{
case GENERATE:
{
int i;
for(i=0; i < num_chunks; i++)
tw_rand_reverse_unif(lp->rng);
}
break;
case ARRIVAL:
{
if(bf->c2)
{
int i;
int index = floor(N_COLLECT_POINTS*(tw_now(lp)/g_tw_ts_end));
for(i = 0; i < 2 * N_dims; i++)
N_queue_depth[index]-=s->buffer[i][0];
}
msg->my_N_hop--;
tw_rand_reverse_unif(lp->rng);
tw_rand_reverse_unif(lp->rng);
int next_dim = msg->source_dim;
int next_dir = msg->source_direction;
s->next_credit_available_time[next_dir + ( next_dim * 2 )][0] = msg->saved_available_time;
}
break;
case SEND:
{
tw_rand_reverse_unif(lp->rng);
if(bf->c3)
{
int next_dim = msg->saved_src_dim;
int next_dir = msg->saved_src_dir;
s->next_link_available_time[next_dir + ( next_dim * 2 )][0] = msg->saved_available_time;
s->buffer[ next_dir + ( next_dim * 2 ) ][ 0 ] --;
if(bf->c1)
{
int index = floor( N_COLLECT_POINTS * ( tw_now( lp ) / g_tw_ts_end ) );
N_generated_storage[ index ]--;
}
}
}
break;
case WAIT:
{
s->wait_count-=1;
int loc = s->wait_count;
s->waiting_list[loc].dim = -1;
s->waiting_list[loc].dir = -1;
s->waiting_list[loc].packet = NULL;
}
break;
case CREDIT:
{
s->buffer[ msg->source_direction + ( msg->source_dim * 2 ) ][ 0 ]++;
if(bf->c3)
{
tw_rand_reverse_unif(lp->rng);
int loc = msg->wait_loc, i;
int max_count = s->wait_count;
if(s->wait_count >= WAITING_PACK_COUNT)
printf("\n Exceeded maximum count!!! ");
for(i = max_count; i > loc ; i--)
{
s->waiting_list[i].dim = s->waiting_list[i-1].dim;
s->waiting_list[i].dir = s->waiting_list[i-1].dir;
s->waiting_list[i].packet = s->waiting_list[i-1].packet;
}
s->waiting_list[loc].dim = msg->source_dim;
s->waiting_list[loc].dir = msg->source_direction;
s->waiting_list[loc].packet = msg;
s->wait_count = s->wait_count + 1;
}
}
break;
}
}
void
rc_event_handler(nodes_state * s, tw_bf * bf, nodes_message * msg, tw_lp * lp)
{
int index = floor(N_COLLECT_POINTS*(tw_now(lp)/g_tw_ts_end));
switch(msg->type)
{
case GENERATE:
N_generated_storage[index]--;
s->packet_counter--;
tw_rand_reverse_unif(lp->rng);
//tw_rand_reverse_unif(lp->rng);
break;
case ARRIVAL:
s->next_available_time = msg->saved_available_time;
//tw_rand_reverse_unif(lp->rng);
msg->my_N_hop--;
s->N_wait_to_be_processed--;
msg->queueing_times -= s->N_wait_to_be_processed;
/* if ( bf->c2 == 0 )
{
N_dropped--;
N_dropped_storage[index]--;
}
else
{
*/
//s->next_available_time = msg->saved_available_time;
s->node_queue_length[msg->source_direction][msg->source_dim]--;
//s->queue_length_sum -=
//s->node_queue_length[msg->source_direction][msg->source_dim];
msg->my_N_queue-=s->node_queue_length[msg->source_direction][msg->source_dim];
//s->next_available_time = msg->saved_available_time;
/* if ( bf->c6 == 0 )
{
N_finished--;
N_finished_storage[index]--;
total_time -= tw_now(lp) - msg->travel_start_time;
total_hops -= msg->my_N_hop;
}
*/
//}
break;
case SEND:
break;
case PROCESS:
if ( bf->c3 == 0 )
{
N_finished--;
N_finished_storage[index]--;
total_time -= tw_now(lp) - msg->travel_start_time;
total_hops -= msg->my_N_hop;
total_queue_length -= msg->my_N_queue;
//event_queue_length -= msg->queue_length;
queueing_times_sum -= msg->queueing_times;
}
s->node_queue_length[msg->source_direction][msg->source_dim]++;
s->N_wait_to_be_processed++;
break;
}
}
