mc-agent.cc

模拟器提供了一个简单易用的平台

    MeshMember *mm = mesh_neighbor_list.GetAt(pos);
    if (mm->gotrt == false) {
      //purge_from_neighbor_list(mm);
      cleanup_rt(mm->ainfo.agent_id);

      #ifdef LOG_TIMEOUTS
        printf("[rtx-timeout] at %8.4f < ag %d nd %d > detects-for < ag %d nd %d >\n",Scheduler::Clock(),id,n->id,mm->ainfo.agent_id,mm->ainfo.node_id);
      #endif // LOG_TIMEOUTS

    }
    else mm->gotrt = false; 
  }
  return; 
}

void mcAgent::handle_mesh_setup_neighbor_timeout(MeshMember *mm) {

  void *pos = mesh_setup_neighbor_timer_list.Locate(mm->ainfo.agent_id); 

/* Suman's correction */
  assert (pos != NULL);
  // printf ("[timer-debug] Timeout happened at %8.3f for %d at %d\n", Scheduler::Clock(), mm->ainfo.agent_id, id);

  MeshSetupNeighborTimer *timer = mesh_setup_neighbor_timer_list.GetAt(pos); 
  delete timer;
  mesh_setup_neighbor_timer_list.RemoveAt(pos); 

  #ifdef LOG_TIMEOUTS
    printf("[setup-neigh-timeout] at %8.4f < ag %d nd %d > detects < ag %d nd %d >\n",Scheduler::Clock(),id,n->id,mm->ainfo.agent_id,mm->ainfo.node_id); 
  #endif // LOG_TIMEOUTS

  purge_from_setup_neighbor_list(mm); 
  return; 
}
  
void mcAgent::cleanup_rt(int lostagent) {
  
  if ((meshrt.pathlen[lostagent] > 1) && (meshrt.valid[lostagent])) {
    free(meshrt.path[lostagent]);
    meshrt.path[lostagent] = NULL;
  }
  meshrt.valid[lostagent] = false;
  for (int i = 0; i < MAXMESHMEMBERS; i++) {
    if ((meshrt.valid[i]) && (meshrt.pathlen[i] > 1) && (meshrt.path[i][0].agent_id = lostagent)) {
      meshrt.valid[i] = false;       
      free(meshrt.path[i]);
      meshrt.path[i] = NULL; 
    }
  }
  return; 
}
//

void mcAgent::handle_mesh_member_refresh (AppPacket *ap) {

  // Ignore message originating from self
  if (ap->u.meshrefresh_p.origin.agent_id == id)
    return;

  MeshMember *mm = find_mesh_member_info (ap->src_agent);
  if (mm == NULL) // Do not accept anything from non-neighbors
    return;
  if (mm->last_seq_no >= ap->u.meshrefresh_p.neighbor_seq_no)
    return;

  if (ap->u.meshrefresh_p.is_alive)
    handle_mesh_member_refresh_alive(ap);
  else
    handle_mesh_member_refresh_dead(ap);
  return;
}

void mcAgent::remove_mesh_member (int ag_id) {

  void *pos = all_agent_list.Locate(ag_id);
  assert (pos != NULL);
  MeshMember *mm = all_agent_list.GetAt(pos);
  all_agent_list.RemoveAt(pos);
  if (mm->neighbor_setup_pending == true) {
    void *setup_pos = setup_neighbor_list.Locate(ag_id);
    assert (setup_pos != NULL);
    setup_neighbor_list.RemoveAt(setup_pos);
  }
  if (mm->is_neighbor == true) {
    void *neighbor_pos = mesh_neighbor_list.Locate(ag_id);
    assert (neighbor_pos != NULL);
    mesh_neighbor_list.RemoveAt(neighbor_pos);
  }
  if (mm->is_stopped == true) {
    void *stop_pos = stopped_member_list.Locate(ag_id);
    assert (stop_pos != NULL);
    stopped_member_list.RemoveAt(stop_pos);
  }
 return;
}

// Handle information about a dead member
void mcAgent::handle_mesh_member_refresh_dead (AppPacket *ap) {

  MeshMember *mm = find_mesh_member_info(ap->u.meshrefresh_p.origin.agent_id);
  if (mm == NULL)
    return;

  // If this is a valid refresh message ....
  if (ap->u.meshrefresh_p.origin_seq_no <= mm->last_seq_no)
    return;

  if (mm->is_neighbor == true) {

    purge_from_neighbor_list(mm);
    //sri's code
    cleanup_rt(mm->ainfo.agent_id);
    //
    add_to_setup_neighbor_list(mm);
    MeshSetupNeighborTimer *msnt = new MeshSetupNeighborTimer(this,mm);
    msnt->SetTimer(CONST_MESH_SETUP_NEIGHBOR_TIMEOUT);

/* Suman's correction */
      // printf ("[timer-debug] About to add timer at %8.3f for %d at %d\n", Scheduler::Clock(), mm->ainfo.agent_id, id);

    mesh_setup_neighbor_timer_list.Add(msnt, mm->ainfo.agent_id); 
    tx_mesh_neighbor_setup_req(mm);
  }
  if (mm->is_stopped == false)
    add_to_stopped_member_list(mm);

  mm->last_seq_no = ap->u.meshrefresh_p.origin_seq_no;

  #ifdef LOG_APP_REFRESH
  printf ("[mesh-member] at %8.4f < ag %d nd %d > detects-lost-member < ag %d nd %d >\n", Scheduler::Clock(), id, n->id, mm->ainfo.agent_id, mm->ainfo.node_id);
  #endif // LOG_APP_REFRESH

  forward_mesh_refresh(mm->ainfo.agent_id,mm->ainfo.node_id, ap->u.meshrefresh_p.origin_seq_no,ap->src_agent,false);
  return;
}

void mcAgent::handle_mesh_member_refresh_alive (AppPacket *ap) {

  MeshMember *member = find_mesh_member_info (ap->u.meshrefresh_p.origin.agent_id);
  if (member == NULL) {
    member = create_new_mesh_member_info(ap->u.meshrefresh_p.origin.agent_id,ap->u.meshrefresh_p.origin.node_id);
  }

  // If this is a valid refresh message ....
  if (ap->u.meshrefresh_p.origin_seq_no > member->last_seq_no) {

    if (member->is_stopped == true)
      purge_from_stopped_member_list(member);
    member->last_seq_no = ap->u.meshrefresh_p.origin_seq_no;
    member->last_refresh = Scheduler::Clock(); 
    forward_mesh_refresh(member->ainfo.agent_id,member->ainfo.node_id, ap->u.meshrefresh_p.origin_seq_no,ap->src_agent,true);
  }
return;
}

MeshMember *mcAgent::find_mesh_member_info (int aid) {

  void *pos = all_agent_list.Locate(aid);
  if (pos == NULL)
    return NULL;
  else
    return all_agent_list.GetAt(pos);
}

void mcAgent::add_to_setup_neighbor_list (MeshMember *mm) {

  assert (mm->neighbor_setup_pending == false);
  assert (setup_neighbor_list.Locate(mm->ainfo.agent_id) == NULL);
  mm->neighbor_setup_pending = true;
  setup_neighbor_list.Add(mm,mm->ainfo.agent_id);
  return;
}

void mcAgent::purge_from_setup_neighbor_list (MeshMember *mm) {

  assert (mm->neighbor_setup_pending == true);
  mm->neighbor_setup_pending = false;
  void *pos = setup_neighbor_list.Locate(mm->ainfo.agent_id);
  assert (pos != NULL);
  setup_neighbor_list.RemoveAt(pos);
  return;
}

void mcAgent::add_to_stopped_member_list (MeshMember *mm) {

  assert (mm->is_stopped == false);
  assert (stopped_member_list.Locate(mm->ainfo.agent_id) == NULL);
  mm->is_stopped = true;
  stopped_member_list.Add(mm,mm->ainfo.agent_id);
  return;
}

void mcAgent::purge_from_stopped_member_list (MeshMember *mm) {

  assert (mm->is_stopped == true);
  mm->is_stopped = false;
  void *pos = stopped_member_list.Locate(mm->ainfo.agent_id);
  assert (pos != NULL);
  stopped_member_list.RemoveAt(pos);
  return;
}

void mcAgent::add_to_neighbor_list (MeshMember *mm) {

  #ifdef LOG_APP_NEIGHBOR
    printf ("[mesh-neighbor] at %8.4f < ag %d nd %d > adds-new-neighbor < ag %d nd %d >\n", Scheduler::Clock(), id, n->id, mm->ainfo.agent_id, mm->ainfo.node_id);
  #endif // LOG_APP_NEIGHBOR

  assert (mm->is_neighbor == false);
  assert (mesh_neighbor_list.Locate(mm->ainfo.agent_id) == NULL);
  mm->is_neighbor = true;
  mesh_neighbor_list.Add(mm,mm->ainfo.agent_id);
  //sri's code
  meshrt.cost[mm->ainfo.agent_id] = n->rt->get_path_cost(mm->ainfo.node_id);
  meshrt.valid[mm->ainfo.agent_id] = true; 
  meshrt.pathlen[mm->ainfo.agent_id] = 1; 
  meshrt.path[mm->ainfo.agent_id] = NULL;
  mm->gotrt = true;
  mm->consensuscost = LINKDROPTHRESHOLD + 1;   
  //
  return;
}

void mcAgent::purge_from_neighbor_list (MeshMember *mm) {

  assert (mm->is_neighbor == true);
  mm->is_neighbor = false;
  void *pos = mesh_neighbor_list.Locate(mm->ainfo.agent_id);
  assert (pos != NULL);
  mesh_neighbor_list.RemoveAt(pos);

  #ifdef LOG_PURGE_NEIGHBOR
    printf("[purge-neigh] at %8.4f < ag %d nd %d > removes < ag %d nd %d >\n",Scheduler::Clock(),id,n->id,mm->ainfo.agent_id,mm->ainfo.node_id);
  #endif // LOG_PURGE_NEIGHBOR

  return;
}

// Process the neighbor setup request
void mcAgent::handle_mesh_neighbor_setup_req (AppPacket *ap) {

  bool accept = true;
  MeshMember *mm = find_mesh_member_info(ap->src_agent);
  if (mm == NULL) {
    mm = create_new_mesh_member_info(ap->src_agent,ap->src);
  }
  else {
    mm->last_refresh = Scheduler::Clock();
    if (mm->neighbor_setup_pending == true) {
      void *pos = mesh_setup_neighbor_timer_list.Locate(mm->ainfo.agent_id); 
      assert (pos != NULL);
      MeshSetupNeighborTimer *timer = mesh_setup_neighbor_timer_list.GetAt(pos); 
      timer->CancelTimer(); 
      delete timer;
      mesh_setup_neighbor_timer_list.RemoveAt(pos); 
      purge_from_setup_neighbor_list(mm);
    }
    if (mm->is_stopped == true) {
      purge_from_stopped_member_list(mm);
    }
  }

  if (accept == true) {
    if (mm->is_neighbor == false) {
      add_to_neighbor_list(mm);
    }
  }
  tx_mesh_neighbor_setup_resp(mm,accept);
  return;
}
      
// Process the neighbor setup response
void mcAgent::handle_mesh_neighbor_setup_resp (AppPacket *ap) {     
   
  MeshMember *mm = find_mesh_member_info(ap->src_agent);
  if (mm == NULL) {
    mm = create_new_mesh_member_info(ap->src_agent,ap->src);
  }

  void *pos = mesh_setup_neighbor_timer_list.Locate(ap->src_agent); 

  /* Suman's correction */
  // printf ("[timer-debug] About to delete timer at %8.3f for %d at %d\n", Scheduler::Clock(), ap->src_agent, id);

  if (pos != NULL) {
    MeshSetupNeighborTimer *timer = mesh_setup_neighbor_timer_list.GetAt(pos);  
    timer->CancelTimer(); 
    delete timer; 
    mesh_setup_neighbor_timer_list.RemoveAt(pos); 
  }  

  if (mm->neighbor_setup_pending == true) {
    // Act only if neighbor setup is pending
    purge_from_setup_neighbor_list(mm);
    if (mm->is_stopped == true)
      purge_from_stopped_member_list(mm);
    assert (mm->is_neighbor == false);
    if (ap->u.meshneighborsetupresp_p.accept == true) {

      #ifdef LOG_APP_NEIGHBOR
        printf ("[mesh-neighbor] at %8.4f < ag %d nd %d > detects-new-neighbor < ag %d nd %d >\n", Scheduler::Clock(), id, n->id, mm->ainfo.agent_id, mm->ainfo.node_id);
      #endif // LOG_APP_NEIGHBOR

      add_to_neighbor_list(mm);
      mm->last_refresh = Scheduler::Clock();
    }
  }
  return;
}

void mcAgent::handle_mesh_refresh_timeout (void) {

  for (void *pos = all_agent_list.GetHeadPosition();
       pos != NULL;
       all_agent_list.GetNext(pos) ) {

    MeshMember *mm = all_agent_list.GetAt(pos);
    if (mm->last_refresh < (Scheduler::Clock() - CONST_MESH_NEIGHBOR_REFRESH_TIMEOUT)) {
      // This member is lost ...
      if (mm->is_stopped == false) {
	add_to_stopped_member_list(mm);
        //sri's code
        cleanup_rt(mm->ainfo.agent_id);
      }

      if (mm->is_neighbor == true) {

        #ifdef LOG_APP_REFRESH
	  printf ("[mesh-neighbor] at %8.4f < ag %d nd %d > detects-lost-neighbor < ag %d nd %d >\n", Scheduler::Clock(), id, n->id, mm->ainfo.agent_id, mm->ainfo.node_id);
	#endif // LOG_APP_REFRESH

	purge_from_neighbor_list(mm);
	// This neighbor is lost ... so inform all other members
	// forward_mesh_refresh(mm->ainfo.agent_id,mm->ainfo.node_id, -1 ,-1,false);
	mm->last_seq_no ++;
	forward_mesh_refresh(mm->ainfo.agent_id,mm->ainfo.node_id, mm->last_seq_no,-1,false);
	// If number of neighbors is low, try to add some new ones ?
      }

      if (mm->neighbor_setup_pending == true) {
        void *pos = mesh_setup_neighbor_timer_list.Locate(mm->ainfo.agent_id); 
        assert (pos != NULL);
        MeshSetupNeighborTimer *timer = mesh_setup_neighbor_timer_list.GetAt(pos); 
        timer->CancelTimer(); 
        delete timer;
        mesh_setup_neighbor_timer_list.RemoveAt(pos); 
	purge_from_setup_neighbor_list(mm);
      }
    }
  }

  /* Reset the timer */
  mesh_refresh_timer->SetTimer(CONST_MESH_NEIGHBOR_REFRESH_TIMEOUT);
  return;
}

void mcAgent::handle_stopped_member_timeout (void) {

}

//sri's code

void MeshRefreshTimeoutTimer::EventHandler (void) {

  mca->handle_mesh_refresh_timeout(); 
  return;
}

void MeshKeepAliveTimer::EventHandler (void) {

  mca->tx_mesh_refresh ();
  mca->mesh_keepalive_timer->SetTimer(CONST_MESH_NEIGHBOR_KEEPALIVE_PERIOD);
  return;
}

//sri's code 
void MeshLinkAddTimer::EventHandler (void) {

  mca->tx_mesh_link_add ();
  mca->mesh_link_add_timer->SetTimer(CONST_MESH_LINK_ADD_PERIOD);
  return;
}

void MeshLinkDropTimer::EventHandler (void) {

  mca->tx_mesh_link_drop ();
  mca->mesh_link_drop_timer->SetTimer(CONST_MESH_LINK_DROP_PERIOD);
  return;
}

void MeshRTExchangeTimer::EventHandler (void) {

  mca->tx_mesh_rt_exchange ();
  mca->mesh_rt_exchange_timer->SetTimer(CONST_MESH_RT_EXCHANGE_PERIOD);
  return;
}

void MeshRTExchangeCheckTimer::EventHandler (void) {

  mca->handle_mesh_rt_exchange_timeout ();
  mca->mesh_rt_exchange_check_timer->SetTimer(CONST_MESH_RT_EXCHANGE_TIMEOUT);
  return; 
} 

void MeshSetupNeighborTimer::EventHandler (void) {

  mca->handle_mesh_setup_neighbor_timeout(mm); 
  return; 
}

void DataTimer::EventHandler (void) {
  
  mca->tx_data(); 
  mca->data_timer->SetTimer(mca->get_time_till_next_transmit()); 
  return; 
}
//

void StoppedMemberTimer::EventHandler (void) {

  mca->handle_stopped_member_timeout();
  return;
}

double mcAgent::get_time_till_next_transmit (void) {

  return CONST_DATA_TRANSMIT_INTERVAL; 
}