void AsFloyd::getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst, sg_platf_route_cbarg_t res, double *lat)
{
/* set utils vars */
size_t table_size = xbt_dynar_length(p_indexNetworkElm);
this->srcDstCheck(src, dst);
/* create a result route */
xbt_dynar_t route_stack = xbt_dynar_new(sizeof(sg_platf_route_cbarg_t), NULL);
int pred;
int cur = dst->getId();
do {
pred = TO_FLOYD_PRED(src->getId(), cur);
if (pred == -1)
THROWF(arg_error, 0, "No route from '%s' to '%s'", src->getName(), dst->getName());
xbt_dynar_push_as(route_stack, sg_platf_route_cbarg_t, TO_FLOYD_LINK(pred, cur));
cur = pred;
} while (cur != src->getId());
if (p_hierarchy == SURF_ROUTING_RECURSIVE) {
res->gw_src = xbt_dynar_getlast_as(route_stack, sg_platf_route_cbarg_t)->gw_src;
res->gw_dst = xbt_dynar_getfirst_as(route_stack, sg_platf_route_cbarg_t)->gw_dst;
}
sg_routing_edge_t prev_dst_gw = NULL;
while (!xbt_dynar_is_empty(route_stack)) {
sg_platf_route_cbarg_t e_route = xbt_dynar_pop_as(route_stack, sg_platf_route_cbarg_t);
xbt_dynar_t links;
void *link;
unsigned int cpt;
if (p_hierarchy == SURF_ROUTING_RECURSIVE && prev_dst_gw != NULL
&& strcmp(prev_dst_gw->getName(), e_route->gw_src->getName())) {
routing_get_route_and_latency(prev_dst_gw, e_route->gw_src,
&res->link_list, lat);
}
links = e_route->link_list;
xbt_dynar_foreach(links, cpt, link) {
xbt_dynar_push_as(res->link_list, sg_routing_link_t, link);
if (lat)
*lat += static_cast<NetworkLinkPtr>(link)->getLatency();
}
prev_dst_gw = e_route->gw_dst;
}
int main(int argc, char **argv)
{
int res;
xbt_dynar_t all_hosts;
msg_host_t first_host;
MSG_init(&argc, argv);
MSG_create_environment(argv[1]);
MSG_function_register("host", host);
all_hosts = MSG_hosts_as_dynar();
first_host = xbt_dynar_pop_as(all_hosts,msg_host_t);
MSG_process_create( "host", host, NULL, first_host);
xbt_dynar_free(&all_hosts);
res = MSG_main();
XBT_INFO("Simulation time %g", MSG_get_clock());
if (res == MSG_OK)
return 0;
else
return 1;
}
static void action_wait(const char *const *action){
double clock = smpi_process_simulated_elapsed();
MPI_Request request;
MPI_Status status;
smpi_replay_globals_t globals =
(smpi_replay_globals_t) smpi_process_get_user_data();
xbt_assert(xbt_dynar_length(globals->irecvs),
"action wait not preceded by any irecv: %s",
xbt_str_join_array(action," "));
request = xbt_dynar_pop_as(globals->irecvs,MPI_Request);
#ifdef HAVE_TRACING
int rank = request && request->comm != MPI_COMM_NULL
? smpi_comm_rank(request->comm)
: -1;
TRACE_smpi_computing_out(rank);
MPI_Group group = smpi_comm_group(request->comm);
int src_traced = smpi_group_rank(group, request->src);
int dst_traced = smpi_group_rank(group, request->dst);
int is_wait_for_receive = request->recv;
TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__);
#endif
smpi_mpi_wait(&request, &status);
#ifdef HAVE_TRACING
TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__);
if (is_wait_for_receive) {
TRACE_smpi_recv(rank, src_traced, dst_traced);
}
TRACE_smpi_computing_in(rank);
#endif
if (XBT_LOG_ISENABLED(smpi_replay, xbt_log_priority_verbose)){
char *name = xbt_str_join_array(action, " ");
XBT_VERB("%s %f", name, smpi_process_simulated_elapsed()-clock);
free(name);
}
}
static void send_one(int from, int to) {
//XBT_DEBUG("send_one(%d, %d)",from,to);
if (count %100000 == 0)
XBT_INFO("Sending task #%d",count);
count++;
bcast_task_t bt;
if (!xbt_dynar_is_empty(reclaimed)) {
bt = xbt_dynar_pop_as(reclaimed,bcast_task_t);
} else {
bt = xbt_new(s_bcast_task_t,1);
}
bt->i=from;
bt->j=(from+to)/2;
bt->k=to;
SD_task_t task = SD_task_create_comm_e2e(NULL,bt,424242);
XBT_DEBUG("Schedule task between %d and %d",bt->i,bt->j);
SD_task_schedulel(task,2,ws_list[bt->i],ws_list[bt->j]);
SD_task_watch(task,SD_DONE);
}
static void action_wait(const char *const *action){
CHECK_ACTION_PARAMS(action, 0, 0);
double clock = smpi_process_simulated_elapsed();
MPI_Request request;
MPI_Status status;
xbt_assert(xbt_dynar_length(get_reqq_self()),
"action wait not preceded by any irecv or isend: %s",
xbt_str_join_array(action," "));
request = xbt_dynar_pop_as(get_reqq_self(),MPI_Request);
if (!request){
/* Assuming that the trace is well formed, this mean the comm might have
* been caught by a MPI_test. Then just return.
*/
return;
}
int rank = request->comm != MPI_COMM_NULL
? smpi_comm_rank(request->comm)
: -1;
MPI_Group group = smpi_comm_group(request->comm);
int src_traced = smpi_group_rank(group, request->src);
int dst_traced = smpi_group_rank(group, request->dst);
int is_wait_for_receive = request->recv;
instr_extra_data extra = xbt_new0(s_instr_extra_data_t,1);
extra->type = TRACING_WAIT;
TRACE_smpi_ptp_in(rank, src_traced, dst_traced, __FUNCTION__, extra);
smpi_mpi_wait(&request, &status);
TRACE_smpi_ptp_out(rank, src_traced, dst_traced, __FUNCTION__);
if (is_wait_for_receive)
TRACE_smpi_recv(rank, src_traced, dst_traced);
log_timed_action (action, clock);
}
