Example #1
0
void
phold_init(phold_state * s, tw_lp * lp)
{
	int              i;

	if( stagger )
	  {
	    for (i = 0; i < g_phold_start_events; i++)
	      {
		tw_event_send(
			      tw_event_new(lp->gid,
					   tw_rand_exponential(lp->rng, mean) + lookahead + (tw_stime)(lp->gid % (unsigned int)g_tw_ts_end),
					   lp));
	      }
	  }
	else
	  {
	    for (i = 0; i < g_phold_start_events; i++)
	      {
		tw_event_send(
			      tw_event_new(lp->gid,
					   tw_rand_exponential(lp->rng, mean) + lookahead,
					   lp));
	      }
	  }
}
void traffic_light_intersection_startup(intersection_state* SV, tw_lp* LP) {
    tw_stime ts = 0;
    tw_event* current_event;
    message_data* new_message;

    // Initialize the total number of cars arrived:
    SV->total_cars_arrived = 0;
    SV->total_cars_finished = 0;

    // Initialize the number of cars arriving into the intersection:
    SV->num_cars_south = 0;
    SV->num_cars_west = 0;
    SV->num_cars_north = 0;
    SV->num_cars_east = 0;

    SV->num_cars_south_left = 0;
    SV->num_cars_west_left = 0;
    SV->num_cars_north_left = 0;
    SV->num_cars_east_left = 0;

    SV->north_south_green_until = -1;
    SV->north_south_left_green_until = -1;
    SV->east_west_green_until = -1;
    SV->east_west_left_green_until = -1;

    // Initialize a random direction to be green
    SV->traffic_direction = tw_rand_ulong(LP->rng, NORTH_SOUTH, EAST_WEST_LEFT);

    // Schedule the first light change
    current_event = tw_event_new(LP->gid, ts, LP);
    new_message = (message_data*)tw_event_data(current_event);
    new_message->event_type = LIGHT_CHANGE;
    tw_event_send(current_event);

    // Put cars on the road
    int i;
    for(i = 0; i < g_traffic_start_events; i++) {
        // Arrival time
        ts = tw_rand_exponential(LP->rng, INITIAL_ARRIVAL_MEAN);

        current_event = tw_event_new(LP->gid, ts, LP);
        new_message = (message_data*)tw_event_data(current_event);

        new_message->event_type = CAR_ARRIVES;

        assign_rand_dest:
        new_message->car.x_to_go = tw_rand_integer(LP->rng, -MAX_TRAVEL_DISTANCE, MAX_TRAVEL_DISTANCE);
        new_message->car.y_to_go = tw_rand_integer(LP->rng, -MAX_TRAVEL_DISTANCE, MAX_TRAVEL_DISTANCE);
        new_message->car.x_to_go_original = new_message->car.x_to_go;
        new_message->car.y_to_go_original = new_message->car.y_to_go;
        if (new_message->car.y_to_go == 0)
            new_message->car.has_turned = 1;
        else
            new_message->car.has_turned = 0;
        new_message->car.start_time = tw_now(LP);

        tw_event_send(current_event);
    }
}
Example #3
0
void Airport_EventHandler(Airport_State *SV, tw_bf *CV, Msg_Data *M, 
		      tw_lp *lp) {
  tw_stime ts;
  tw_event *CurEvent;
  Msg_Data *NewM;

  *(int *)CV = (int)0;

  switch(M->event_type) {
    
  case ARRIVAL: 
    // Schedule a landing in the future
    SV->InTheAir++;
    
    if((CV->c1 = (SV->RunwayFree == 1))){
      SV->RunwayFree = 0;
   
      ts = tw_rand_exponential(lp->id, R);
      CurEvent = tw_event_new(lp, ts, lp);
      NewM = (Msg_Data *)tw_event_data(CurEvent);
      NewM->event_type = LAND;
      tw_event_send(CurEvent);
    }
    break;
      
  case LAND: 
    SV->InTheAir--;
    SV->OnTheGround++;
    SV->NumLanded++;
    
    ts = tw_rand_exponential(lp->id, G);
    CurEvent = tw_event_new(lp, ts, lp);
    NewM = (Msg_Data *)tw_event_data(CurEvent);
    NewM->event_type = DEPARTURE;
    tw_event_send(CurEvent);
    
    if ((CV->c1 = (SV->InTheAir > 0))){
      ts = tw_rand_exponential(lp->id, R);
      CurEvent = tw_event_new(lp, ts, lp);
      NewM = (Msg_Data *)tw_event_data(CurEvent);
      NewM->event_type = LAND;
      tw_event_send(CurEvent);
    }
    else
      SV->RunwayFree = 1;
    break;
    
  case DEPARTURE: 
    SV->OnTheGround--;
    
    ts = tw_rand_exponential(lp->id, A);
    CurEvent = tw_event_new(tw_getlp((lp->id + 1) % 3) , ts, lp);
    NewM = (Msg_Data *) tw_event_data(CurEvent);
    NewM->event_type = ARRIVAL;
    tw_event_send(CurEvent);
    break;
  }
}
Example #4
0
void
mem_init(mem_state * s, tw_lp * lp)
{
    tw_event	*e;
    tw_memory	*b;

    int              i;

    for (i = 0; i < g_mem_start_events; i++)
    {
        e = tw_event_new(lp->gid, tw_rand_exponential(lp->rng, mean), lp);

        for(i = 0; i < nbufs; i++)
        {
            b = mem_alloc(lp);
            mem_fill(b);
            tw_event_memory_set(e, b, my_fd);

            s->stats.s_mem_alloc++;
        }

        tw_event_send(e);
        s->stats.s_sent++;
    }
}
Example #5
0
int ForwardPacket (tw_lp * srcLp, tw_lp * dstLp, Packet * p, tw_stime t)
{
  tw_event * e;
  EventMsg * em;
  double now = tw_now (dstLp);
  
  if (t + now >= g_tw_ts_end) return 0;  /* Otherwise the program will exit when
                                          * creating event */
  
#ifdef DEBUG_PKT_FWD
  printf ("%lf : pkt(%d:%lu) from %d to %d (in-port %d) at %lf\n", 
          tw_now (srcLp), _addrToIdx[p->srcAddr_],
          p->od_.sqn_, srcLp->id, dstLp->id, p->inPort_, now + t);
  fflush (stdout);
#endif  
  
  if ((e = tw_event_new (dstLp, t, dstLp)) == NULL) {
    printf ("Failed to create event for packet.\n");
    tw_exit (-1);
  }
  
  (em = (EventMsg *) tw_event_data (e))->type_ = DATA_PKT;  
  memcpy ((void *) &(em->content_.pkt_), (void *) p, sizeof (Packet));
  
  tw_event_send (e);
  
  return 1;
}
Example #6
0
/*Sends a 8-byte credit back to the torus node LP that sent the message */
void 
credit_send( nodes_state * s, 
	    tw_bf * bf, 
	    tw_lp * lp, 
	    nodes_message * msg)
{
    //if(lp->gid == TRACK_LP)
    //	printf("\n (%lf) sending credit tmp_dir %d tmp_dim %d %lf ", tw_now(lp), msg->source_direction, msg->source_dim, credit_delay );
    
    tw_event * buf_e;
    nodes_message *m;
    tw_stime ts;
    
    int src_dir = msg->source_direction;
    int src_dim = msg->source_dim;

    msg->saved_available_time = s->next_credit_available_time[(2 * src_dim) + src_dir][0];
    s->next_credit_available_time[(2 * src_dim) + src_dir][0] = max(s->next_credit_available_time[(2 * src_dim) + src_dir][0], tw_now(lp));
    ts =  credit_delay + tw_rand_exponential(lp->rng, credit_delay/1000);
    s->next_credit_available_time[(2 * src_dim) + src_dir][0] += ts;

    buf_e = tw_event_new( msg->sender_lp, s->next_credit_available_time[(2 * src_dim) + src_dir][0] - tw_now(lp), lp);

    m = tw_event_data(buf_e);
    m->source_direction = msg->source_direction;
    m->source_dim = msg->source_dim;

    m->type = CREDIT;
    tw_event_send( buf_e );
}
Example #7
0
void packet_buffer_process( nodes_state * s, tw_bf * bf, nodes_message * msg, tw_lp * lp )
{
   msg->wait_loc = -1;
   s->buffer[ msg->source_direction + ( msg->source_dim * 2 ) ][  0 ]-=1;
  
  tw_event * e_h;
  nodes_message * m;
  tw_stime ts;
  bf->c3 = 0;
  int loc=s->wait_count, j=0;
  for(j = 0; j < loc; j++)
   {
    if( s->waiting_list[j].dim == msg->source_dim && s->waiting_list[j].dir == msg->source_direction)
     {
        bf->c3=1;
	ts = tw_rand_exponential(lp->rng, MEAN_INTERVAL/100);
        e_h = tw_event_new( lp->gid, ts, lp );
        m = tw_event_data( e_h );
     	memcpy(m, s->waiting_list[j].packet, sizeof(nodes_message));
        
//        For reverse computation, also copy data to the msg 
   	memcpy(msg, s->waiting_list[j].packet, sizeof(nodes_message));
	msg->wait_loc = j;
	msg->type = CREDIT;
	m->type = SEND;
        tw_event_send(e_h);
        waiting_packet_free(s, j);
        break;
    }
  }
}
Example #8
0
	/*
	 * Create and send new boundary particle
	 */
tw_event	*
rm_particle_send(tw_lpid gid, tw_stime offset, tw_lp * src_lp)
{
	tw_event	*e;
	//tw_memory	*b;

	rm_message	*m;
	//rm_particle	*p;

	//printf("%ld: sending particle to cell %ld \n", src_lp->id, gid);

	if(gid == 0)
		tw_error(TW_LOC, "here");
	e = tw_event_new(gid, offset, src_lp);
	m = tw_event_data(e);

	m->type = RM_PARTICLE;

#if DWB
	b = tw_memory_alloc(src_lp, g_rm_fd);
	tw_event_memory_set(e, b, g_rm_fd);

	p = tw_memory_data(b);
	p->user_lp = src_lp;
#endif

	tw_event_send(e);

	return e;
}
Example #9
0
void
torus_init(nodes_state * s, tw_lp * lp)
{
  tw_event *e;
  tw_stime ts;
  nodes_message *m;

  /*
   * Set up the initial state for each LP (node)
   * according to the number of dimensions
   */
  torus_setup(s, lp);

  /*
   * Start a GENERATE event on each LP
   */
  //ts = tw_rand_exponential(lp->rng, MEAN_INTERVAL);
  ts = tw_rand_exponential(lp->rng, 10);
  int i;
  for(i=0;i<N_nodes;i++)
    {
      e = tw_event_new(lp->gid, ts, lp);
      m = tw_event_data(e);
      m->type = GENERATE;
      
      m->next_stop = i;
      
      m->dest_lp = lp->gid;
      tw_event_send(e);
    }
}
Example #10
0
void event_handler(ping_pong_state * s, tw_bf * bf, ping_pong_message * in_m, tw_lp * lp)
{
	tw_stime ts;
	tw_event *e;
	ping_pong_message *m;
	int dest=0;
	ts=1;

//	if(g_tw_mynode == 0)
	if(lp->gid == 0)
	{
		dest = 1;
	}
//	else if (g_tw_mynode == 1)
	else if (lp->gid == 1)

	{
		dest = 0;
	}
	else
	{
		cout<<"invalid core number"<<endl;
		assert(false);
	}
	e = tw_event_new(dest, ts, lp);
	m = (ping_pong_message *)tw_event_data(e);
	tw_event_send(e);
}
Example #11
0
/*
 * epi_agent_send: create new event, and pack on the agent membuf and
 * associated pathogen membufs
 */
void
epi_agent_send(tw_lp * src, tw_memory * buf, tw_stime offset, tw_lpid dst)
{
	tw_event	*e;
	tw_memory	*b;
	tw_memory	*next;

	epi_agent	*a;

	e = tw_event_new(dst, 0.0, src);
	a = tw_memory_data(buf);

	printf("%lld: Sending agent to %lld (%d, %lld) at %lf\n", 
		src->id, dst, a->curr, a->loc[a->curr], tw_now(src));

	// place agent membuf on event, and pack pathogen membufs on after that
	// in case this event/agent is sent over the network.
	for(next = b = a->pathogens; b; b = next)
	{
		next = b->next;
		tw_event_memory_set(e, b, g_epi_pathogen_fd);
	}

	tw_event_memory_set(e, buf, g_epi_fd);
	a->pathogens = NULL;

	tw_event_send(e);
}
Example #12
0
/**
 * Initializer for OLSR
 */
void olsr_init(node_state *s, tw_lp *lp)
{
    hello *h;
    tw_event *e;
    olsr_msg_data *msg;
    tw_stime ts;
    
    //s->num_tuples = 0;
    s->num_neigh  = 0;
    s->num_two_hop = 0;
    s->local_address = lp->gid;
    s->lng = tw_rand_unif(lp->rng) * GRID_MAX;
    s->lat = tw_rand_unif(lp->rng) * GRID_MAX;
    
    ts = tw_rand_unif(lp->rng) * STAGGER_MAX;
    
    e = tw_event_new(lp->gid, ts, lp);
    msg = tw_event_data(e);
    msg->type = HELLO_TX;
    msg->originator = s->local_address;
    msg->lng = s->lng;
    msg->lat = s->lat;
    h = &msg->mt.h;
    h->num_neighbors = 0;
    //h->neighbor_addrs[0] = s->local_address;
    tw_event_send(e);
}
Example #13
0
void cont_create_process( CON_state* s, tw_bf* bf, MsgData* msg, tw_lp* lp )
{
  tw_event * e;
  tw_stime ts;
  MsgData * m;

#ifdef TRACE
  printf("create %d process at controller travel time is %lf\n",
         msg->message_CN_source,
         tw_now(lp) - msg->travel_start_time );
#endif
  ts = CONT_CONT_msg_prep_time;

  e = tw_event_new( lp->gid, ts , lp );
  m = tw_event_data(e);
  m->event_type = CREATE_ACK;

  m->travel_start_time = msg->travel_start_time;

  m->io_offset = msg->io_offset;
  m->io_payload_size = msg->io_payload_size;
  m->collective_group_size = msg->collective_group_size;
  m->collective_group_rank = msg->collective_group_rank;

  m->collective_master_node_id = msg->collective_master_node_id;
  m->io_type = msg->io_type;

  m->message_ION_source = msg->message_ION_source;
  m->message_FS_source = msg->message_FS_source;
  m->message_CN_source = msg->message_CN_source;
  m->io_tag = msg->io_tag;

  tw_event_send(e);

}
Example #14
0
void wifi_station_arrival(wifi_access_point_state * s, tw_bf * bf, wifi_message * m, tw_lp * lp)
{
  unsigned int rng_calls=0;
  tw_event *e=NULL;
  wifi_message *m_new=NULL;

  // packets coming from access point have much more power and so better snr
  s->stations[m->station].total_packets++;
  s->stations[m->station].station_snr = tw_rand_normal_sd(lp->rng,4.0,8.0, &rng_calls);
  // New Function - to add prop loss, but not ready yet.
  //s->stations[m->station].station_snr = calcRxPower (txPowerDbm, distance, minDistance, lambda, systemLoss);
  s->stations[m->station].station_success_rate =
    WiFi_80211b_DsssDqpskCck11_SuccessRate(s->stations[m->station].station_snr, num_of_bits);
  if( tw_rand_normal_sd(lp->rng,0.5,0.1, &rng_calls) <
      s->stations[m->station].station_success_rate)
    {
      bf->c1 = 1;
      s->stations[m->station].failed_packets++;
    }

  // schedule event back to AP w/ exponential service time
  e = tw_event_new(lp->gid, tw_rand_exponential(lp->rng, 10.0), lp);
  m_new = (wifi_message *) tw_event_data(e);
  m_new->type = WIFI_PACKET_ARRIVAL_AT_ACCESS_POINT;
  m_new->station = m->station;
  tw_event_send(e);
}
Example #15
0
void
mem_event_handler(mem_state * s, tw_bf * bf, mem_message * m, tw_lp * lp)
{
    tw_lpid		 dest;
    tw_event	*e;
    tw_memory	*b;

    int		 i;

    s->stats.s_recv++;

    // read membufs off inbound event, check it and free it
    for(i = 0; i < nbufs; i++)
    {
        b = tw_event_memory_get(lp);

        if(!b)
            tw_error(TW_LOC, "Missing memory buffers: %d of %d",
                     i+1, nbufs);

        mem_verify(b);
        tw_memory_free(lp, b, my_fd);

        s->stats.s_mem_free++;
        s->stats.s_mem_get++;
    }

    if(tw_rand_unif(lp->rng) <= percent_remote)
    {
        bf->c1 = 1;
        dest = tw_rand_integer(lp->rng, 0, ttl_lps - 1);

        dest += offset_lpid;

        if(dest >= ttl_lps)
            dest -= ttl_lps;
    } else
    {
        bf->c1 = 0;
        dest = lp->gid;
    }

    e = tw_event_new(dest, tw_rand_exponential(lp->rng, mean), lp);

    // allocate membufs and attach them to the event
    for(i = 0; i < nbufs; i++)
    {
        b = mem_alloc(lp);

        if(!b)
            tw_error(TW_LOC, "no membuf allocated!");

        mem_fill(b);
        tw_event_memory_set(e, b, my_fd);
        s->stats.s_mem_alloc++;
    }

    tw_event_send(e);
}
Example #16
0
// Helpers
void raid_controller_gen_send( tw_lpid dest, Event event_type, tw_stime event_time, tw_lp* lp )
{
    // Generate and send message to dest
    tw_event* event = tw_event_new( dest, event_time, lp );
    MsgData* message = (MsgData*)tw_event_data( event );
    message->event_type = event_type;
    tw_event_send( event );
}
Example #17
0
void
tmr_event_handler(tmr_state * s, tw_bf * bf, tmr_message * m, tw_lp * lp)
{
	tw_lpid	 dest;

	* (int *) bf = 0;

	if(s->timer)
	{
		// if current event being processed is the timer
		if(tw_event_data(s->timer) == m)
		{
			bf->c1 = 1;

			m->old_timer = s->timer;
			s->timer = NULL;

			fprintf(f, "%lld: tmr fired at %lf\n", 
				lp->gid, tw_now(lp));

			return;
		} else
		{
			bf->c2 = 1;

			m->old_time = s->timer->recv_ts;
			tw_timer_reset(lp, &s->timer, tw_now(lp) + 100.0);

			if(s->timer == NULL)
				fprintf(f, "%lld: reset tmr failed %lf\n", 
					lp->gid, tw_now(lp) + 100.0);
			else
				fprintf(f, "%lld: reset tmr to %lf\n", 
					lp->gid, tw_now(lp) + 100.0);
		}
	}

	if(tw_rand_unif(lp->rng) <= percent_remote)
	{
		bf->c3 = 1;
		dest = tw_rand_integer(lp->rng, 0, ttl_lps - 1);

		dest += offset_lpid;

		if(dest >= ttl_lps)
			dest -= ttl_lps;
	} else
	{
		bf->c3 = 0;
		dest = lp->gid;
	}

	if(!lp->gid)
		dest = 0;

	tw_event_send(tw_event_new(dest, tw_rand_exponential(lp->rng, mean), lp));
}
Example #18
0
void lsm_io_event(
        const char * lp_io_category,
        uint64_t io_object,
        int64_t  io_offset,
        uint64_t io_size_bytes,
        int      io_type,
        tw_stime delay,
        tw_lp *sender,
        struct codes_mctx const * map_ctx,
        int return_tag,
        msg_header const * return_header,
        struct codes_cb_info const * cb)
{
    assert(strlen(lp_io_category) < CATEGORY_NAME_MAX-1);
    assert(strlen(lp_io_category) > 0);
    SANITY_CHECK_CB(cb, lsm_return_t);

    tw_lpid lsm_id = codes_mctx_to_lpid(map_ctx, LSM_NAME, sender->gid);

    tw_stime delta = delay + codes_local_latency(sender);
    if (lsm_in_sequence) {
        tw_stime tmp = lsm_msg_offset;
        lsm_msg_offset += delta;
        delta += tmp;
    }

    tw_event *e = tw_event_new(lsm_id, delta, sender);
    lsm_message_t *m = tw_event_data(e);
    m->magic = lsm_magic;
    m->event = (lsm_event_t) io_type;
    m->data.object = io_object;
    m->data.offset = io_offset;
    m->data.size   = io_size_bytes;
    strcpy(m->data.category, lp_io_category);

    // get the priority count for checking
    int num_prios = lsm_get_num_priorities(map_ctx, sender->gid);
    // prio checks and sets
    if (num_prios <= 0) // disabled scheduler - ignore
        m->data.prio = 0;
    else if (temp_prio < 0) // unprovided priority - defer to max possible
        m->data.prio = num_prios-1;
    else if (temp_prio < num_prios) // valid priority
        m->data.prio = temp_prio;
    else
        tw_error(TW_LOC,
                "LP %lu, LSM LP %lu: Bad priority (%d supplied, %d lanes)\n",
                sender->gid, lsm_id, temp_prio, num_prios);
    // reset temp_prio
    temp_prio = -1;

    m->cb.info = *cb;
    m->cb.h = *return_header;
    m->cb.tag = return_tag;

    tw_event_send(e);
}
Example #19
0
/**
 * Forward event handler for SRW.  Supported operations are currently:
 * - GPS
 * - MOVEMENT
 * - COMMUNICATION
 */
void srw_event(srw_state *s, tw_bf *bf, srw_msg_data *m, tw_lp *lp)
{
  tw_stime ts;
  tw_event *e;
  srw_msg_data *msg;

  switch(m->type) {
  case GPS:
    
    // Schedule next event
    e = tw_event_new(lp->gid, SRW_GPS_RATE, lp);
    msg = tw_event_data(e);
    msg->node_id = m->node_id;
    msg->type = GPS;
    tw_event_send(e);
    break;

  case MOVEMENT:
    s->movements++;
    (s->nodes[m->node_id]).movements++;

    // Schedule next event
    ts = tw_rand_exponential(lp->rng, SRW_MOVE_MEAN);
    e = tw_event_new(lp->gid, ts, lp);
    msg = tw_event_data(e);
    msg->node_id = m->node_id;
    msg->type = MOVEMENT;
    tw_event_send(e);
    break;

  case COMMUNICATION:
    s->comm_try++;
    (s->nodes[m->node_id]).comm_try++;

    // Schedule next event
    ts = tw_rand_exponential(lp->rng, SRW_COMM_MEAN);
    e = tw_event_new(lp->gid, ts, lp);
    msg = tw_event_data(e);
    msg->node_id = m->node_id;
    msg->type = COMMUNICATION;
    tw_event_send(e);
    break;
  }
}
Example #20
0
static void st_create_sample_event(tw_lp *lp)
{
    if (tw_now(lp) + g_st_vt_interval <= g_st_sampling_end)
    {
        tw_event *e = tw_event_new(lp->gid, g_st_vt_interval, lp);
        analysis_msg *m = (analysis_msg*) tw_event_data(e);
        m->src = lp->gid;
        tw_event_send(e);
    }
}
Example #21
0
void
packet_process(nodes_state * s, tw_bf * bf, nodes_message * msg, tw_lp * lp)
{
  int i;
  tw_event *e;
  nodes_message *m;

  bf->c3 = 1;
  // One packet leaves the queue
  s->node_queue_length[msg->source_direction][msg->source_dim]--;
  s->N_wait_to_be_processed--;
  
  if(lp->gid==msg->dest_lp)
    {
      // one packet arrives and dies
      bf->c3 = 0;
	N_finished++;
	int index = floor(N_COLLECT_POINTS*(tw_now(lp)/g_tw_ts_end));
	N_finished_storage[index]++;
	total_time += tw_now(lp) - msg->travel_start_time;
	if (max_latency<tw_now(lp) - msg->travel_start_time)
	  max_latency=tw_now(lp) - msg->travel_start_time;
	total_hops += msg->my_N_hop;
	total_queue_length += msg->my_N_queue;
	queueing_times_sum += msg->queueing_times;
	//total_queue_length += msg->accumulate_queue_length;
    }
  else
    {
      e = tw_event_new(lp->gid, MEAN_PROCESS, lp);
      m = tw_event_data(e);
      m->type = SEND;
      
      // Carry on the message info
      for( i = 0; i < N_dims; i++ )
	m->dest[i] = msg->dest[i];
      m->dest_lp = msg->dest_lp;
      m->transmission_time = msg->transmission_time;
      
      m->source_dim = msg->source_dim;
      m->source_direction = msg->source_direction;
      
      m->packet_ID = msg->packet_ID;	  
      m->travel_start_time = msg->travel_start_time;

      m->my_N_hop = msg->my_N_hop;
      m->my_N_queue = msg->my_N_queue;
      m->queueing_times = msg->queueing_times;

      tw_event_send(e);
      
    }
  
}
Example #22
0
//Init function
// - called once for each LP
// ! LP can only send messages to itself during init !
void decrement_init (decrement_state *s, tw_lp *lp) {
  int self = lp->gid;

  // init state data
  s->decrement_value = 1;
  s->round_count = 0;

  // Init message to myself
  tw_event *e = tw_event_new(self, 2, lp);
  message *msg = tw_event_data(e);
  msg->type = WAKEUP;
  tw_event_send(e);
}
/* Trigger getting next event at LP */
static void codes_issue_next_event(tw_lp* lp)
{
   tw_event *e;
   nw_message* msg;

   tw_stime ts;

   ts = g_tw_lookahead + 0.1 + tw_rand_exponential(lp->rng, noise);
   e = tw_event_new( lp->gid, ts, lp );
   msg = tw_event_data(e);

   msg->msg_type = MPI_OP_GET_NEXT;
   tw_event_send(e);
}
Example #24
0
void
packet_send(nodes_state * s, tw_bf * bf, nodes_message * msg, tw_lp * lp)
{
  int i;
  tw_lpid dst_lp;
  tw_stime ts;
  tw_event *e;
  nodes_message *m;

  ts = LINK_DELAY+msg->transmission_time;
  
  /*
   * Routing in the torus, start from the first dimension
   */
  
  if (lp->gid !=  msg->dest_lp )  
    {
      bf->c3 = 1;
      dimension_order_routing(s,msg,&dst_lp);
      msg->source_dim = s->source_dim;
      msg->source_direction = s->direction;
    }
  else
    {
      bf->c3 = 0;
      dst_lp = lp->gid;
    }
  
  e = tw_event_new(dst_lp, ts, lp);
  m = tw_event_data(e);
  m->type = ARRIVAL;
  
  // Carry on the message info
  for( i = 0; i < N_dims; i++ )
    m->dest[i] = msg->dest[i];
  m->dest_lp = msg->dest_lp;
  m->transmission_time = msg->transmission_time;
  
  m->source_dim = msg->source_dim;
  m->source_direction = msg->source_direction;
  
  m->packet_ID = msg->packet_ID;	  
  m->travel_start_time = msg->travel_start_time;

  m->my_N_hop = msg->my_N_hop;
  m->my_N_queue = msg->my_N_queue;
  m->queueing_times = msg->queueing_times;
  
  tw_event_send(e);
}
Example #25
0
//Forward event handler
void decrement_event (decrement_state *s, tw_bf *bf, message *in_msg, tw_lp *lp) {
  int self = lp->gid;

  if (in_msg->type != WAKEUP) {
    tw_error(TW_LOC, "Decrement LP received wrong message type");
  }

  s->round_count++;

  int i;
  for (i = 0; i < total_receivers; i++) {
    tw_event *e = tw_event_new(i+2, 1, lp);
    message *msg = tw_event_data(e);
    msg->type = DECREMENT;
    msg->value = s->decrement_value;
    tw_event_send(e);
  }

  // Wakeup self
  tw_event *e = tw_event_new(self, 2, lp);
  message *msg = tw_event_data(e);
  msg->type = WAKEUP;
  tw_event_send(e);
}
Example #26
0
void  Intersection_StartUp(Intersection_State *SV, tw_lp * lp) {
	//printf("begin init\n");
	int i;
	tw_event *CurEvent;
	tw_stime ts;
	Msg_Data *NewM;

	SV->total_cars_arrived = 0;
	SV->total_cars_finished = 0;
	SV->num_in_west_left = 0;
	SV->num_in_west_straight = 0;
	SV->num_in_west_right = 0;
	SV->num_in_north_left = 0;
	SV->num_in_north_straight = 0;
	SV->num_in_north_right = 0;
	SV->num_in_south_left = 0;
	SV->num_in_south_straight = 0;
	SV->num_in_south_right = 0;
	SV->num_in_east_left = 0;
	SV->num_in_east_straight = 0;
	SV->num_in_east_right = 0;
	SV->num_out_west_left = 0;
	SV->num_out_west_straight = 0;
	SV->num_out_west_right = 0;
	SV->num_out_north_left = 0;
	SV->num_out_north_straight = 0;
	SV->num_out_north_right = 0;
	SV->num_out_south_left = 0;
	SV->num_out_south_straight = 0;
	SV->num_out_south_right = 0;
	SV->num_out_east_left = 0;
	SV->num_out_east_straight = 0;
	SV->num_out_east_right = 0;

	for(i = 0; i < g_traffic_start_events; i++)
	{
		ts = tw_rand_exponential(lp->rng, MEAN_SERVICE );
		CurEvent = tw_event_new(lp->gid, ts, lp);
		NewM = (Msg_Data *)tw_event_data(CurEvent);
		NewM->event_type = ARIVAL;
		NewM->car.x_to_go = rand() % 200 - 99;
		NewM->car.y_to_go = rand() % 200 - 99;
		NewM->car.current_lane = rand() % 12;
		NewM->car.sent_back = 0;
		NewM->car.in_out = IN;
		tw_event_send(CurEvent);
	}
}
//Init function
// - called once for each LP
// ! LP can only send messages to itself during init !
void model_init (state *s, tw_lp *lp) {
  int self = lp->gid;

  // init state data
  s->rcvd_count_H = 0;
  s->rcvd_count_G = 0;
  s->value = -1;

  // Init message to myself
  tw_event *e = tw_event_new(self, 1, lp);
  message *msg = tw_event_data(e);
  msg->type = HELLO;
  msg->contents = tw_rand_unif(lp->rng);
  msg->sender = self;
  tw_event_send(e);
}
Example #28
0
	/*
	 * The event being processed that caused this function to be
	 * called is a user model event.  Therefore, I cannot use it
	 * for state saving.  Solution: create my own event and send
	 * it with a 0.0 offset timestamp.
	 */
void
tlm_wave_initiate(double * position, double signal, tw_lp * lp)
{
	tw_lpid		 gid = tlm_getcell(position);
	tw_event	*e;

	tlm_message	*m;

	e = tw_event_new(gid, g_tlm_scatter_ts, lp);

	m = tw_event_data(e);
	m->type = RM_WAVE_INIT;
	m->displacement = signal;
	m->id = lp->gid;

	tw_event_send(e);
}
Example #29
0
/* initialize MPI process LP */
void 
mpi_init( mpi_process * p, 
	 tw_lp * lp)
{
    tw_event *e;
    tw_stime ts;
    nodes_message *m;
    p->message_counter = 0;

    /* Start a MPI send event on each MPI LP */
    ts =  tw_rand_exponential(lp->rng, MEAN_INTERVAL);
    e = tw_event_new( lp->gid, ts, lp );
    m = tw_event_data( e );
    m->type = MPI_SEND;

    p->available_time = 0.0;
    tw_event_send( e );
}
Example #30
0
void
phold_pre_run(phold_state * s, tw_lp * lp)
{
    tw_lpid	 dest;

	if(tw_rand_unif(lp->rng) <= percent_remote)
	{
		dest = tw_rand_integer(lp->rng, 0, ttl_lps - 1);
	} else
	{
		dest = lp->gid;
	}

	if(dest >= (g_tw_nlp * tw_nnodes()))
		tw_error(TW_LOC, "bad dest");

	tw_event_send(tw_event_new(dest, tw_rand_exponential(lp->rng, mean) + lookahead, lp));
}