Exemple #1
0
int main(int argc, char **argv)
{
  xbt_dict_cursor_t cursor = NULL;
  char *key, *data;
  char noexist[] = "NoProp";
  const char *value;
  char exist[] = "Hdd";

  /* SD initialization */
  SD_init(&argc, argv);
  xbt_assert(argc > 1, "Usage: %s platform_file\n\tExample: %s ../../platforms/prop.xml", argv[0], argv[0]);

  SD_create_environment(argv[1]);

  /* init of platform elements */
  sg_host_t h1 = sg_host_by_name("host1");
  sg_host_t h2 = sg_host_by_name("host2");
  const char *name1 = sg_host_get_name(h1);
  const char *name2 = sg_host_get_name(h2);

  /* Get the property list of 'host1' */
  XBT_INFO("Property list for host %s", name1);
  xbt_dict_t props = sg_host_get_properties(h1);

  /* Trying to set a new property */
  xbt_dict_set(props, "NewProp", strdup("newValue"), NULL);

  /* Print the properties of 'host1' */
  xbt_dict_foreach(props, cursor, key, data) {
    XBT_INFO("\tProperty: %s has value: %s", key, data);
  }
Exemple #2
0
int main(int argc, char **argv)
{
  double now = -1.0;
  int running;

  surf_init(&argc, argv);       /* Initialize some common structures */

  xbt_cfg_set_parse("network/model:CM02");
  xbt_cfg_set_parse("cpu/model:Cas01");

  xbt_assert(argc > 1, "Usage: %s platform.xml\n", argv[0]);
  parse_platform_file(argv[1]);

  /*********************** HOST ***********************************/
  simgrid::s4u::Host* hostA = sg_host_by_name("Cpu A");
  simgrid::s4u::Host* hostB = sg_host_by_name("Cpu B");

  /* Let's do something on it */
  hostA->pimpl_cpu->execution_start(1000.0);
  hostB->pimpl_cpu->execution_start(1000.0);
  hostB->pimpl_cpu->sleep(7.32);

  surf_network_model->communicate(hostA, hostB, 150.0, -1.0);

  surf_solve(-1.0);                 /* Takes traces into account. Returns 0.0 */
  do {
    surf_action_t action = nullptr;
    running = 0;

    now = surf_get_clock();
    XBT_INFO("Next Event : %g", now);

    for (auto model: *all_existing_models) {
      if (surf_model_running_action_set_size(model)) {
        XBT_DEBUG("\t Running that model");
        running = 1;
      }

      action = surf_model_extract_failed_action_set(model);
      while (action != nullptr) {
        XBT_INFO("   * Done Action");
        XBT_DEBUG("\t * Failed Action: %p", action);
        action->unref();
        action = surf_model_extract_failed_action_set(model);
      }

      action = surf_model_extract_done_action_set(model);
      while (action != nullptr){
        XBT_INFO("   * Done Action");
        XBT_DEBUG("\t * Done Action: %p", action);
        action->unref();
        action = surf_model_extract_done_action_set(model);
      }
    }
  } while (running && surf_solve(-1.0) >= 0.0);

  XBT_INFO("Simulation Terminated");
  return 0;
}
Exemple #3
0
LinkDynar getRoute(char *srcName, char *dstName) {
  RoutingEdge *src = sg_host_edge(sg_host_by_name(srcName));
  RoutingEdge *dst = sg_host_edge(sg_host_by_name(dstName));
  xbt_assert(src,"Cannot get the route from a NULL source");
  xbt_assert(dst,"Cannot get the route to a NULL destination");
  xbt_dynar_t route = xbt_dynar_new(sizeof(RoutingEdge*), NULL);
  routing_platf->getRouteAndLatency(src, dst, &route, NULL);
  return route;
}
Exemple #4
0
/**
 * \brief Add a "host_link" to the network element list
 */
static void parse_S_host_link(sg_platf_host_link_cbarg_t host)
{
  RoutingEdge *info = sg_host_edge(sg_host_by_name(host->id));
  xbt_assert(info, "Host '%s' not found!", host->id);
  xbt_assert(current_routing->p_modelDesc == &routing_models[SURF_MODEL_CLUSTER] ||
      current_routing->p_modelDesc == &routing_models[SURF_MODEL_VIVALDI],
      "You have to be in model Cluster to use tag host_link!");

  s_surf_parsing_link_up_down_t link_up_down;
  link_up_down.link_up = Link::byName(host->link_up);
  link_up_down.link_down = Link::byName(host->link_down);

  xbt_assert(link_up_down.link_up, "Link '%s' not found!",host->link_up);
  xbt_assert(link_up_down.link_down, "Link '%s' not found!",host->link_down);

  if(!current_routing->p_linkUpDownList)
    current_routing->p_linkUpDownList = xbt_dynar_new(sizeof(s_surf_parsing_link_up_down_t),NULL);

  // If dynar is is greater than edge id and if the host_link is already defined
  if((int)xbt_dynar_length(current_routing->p_linkUpDownList) > info->getId() &&
      xbt_dynar_get_as(current_routing->p_linkUpDownList, info->getId(), void*))
	surf_parse_error("Host_link for '%s' is already defined!",host->id);

  XBT_DEBUG("Push Host_link for host '%s' to position %d", info->getName(), info->getId());
  xbt_dynar_set_as(current_routing->p_linkUpDownList, info->getId(), s_surf_parsing_link_up_down_t, link_up_down);
}
Exemple #5
0
/** @brief Add an "host" to the current AS */
void sg_platf_new_host(sg_platf_host_cbarg_t host)
{
  xbt_assert(! sg_host_by_name(host->id),
      "Refusing to create a second host named '%s'.", host->id);

  simgrid::surf::AsImpl* current_routing = routing_get_current();
  if (current_routing->hierarchy_ == simgrid::surf::AsImpl::RoutingMode::unset)
    current_routing->hierarchy_ = simgrid::surf::AsImpl::RoutingMode::base;

  simgrid::surf::NetCard *netcard =
      new simgrid::surf::NetCardImpl(host->id, SURF_NETWORK_ELEMENT_HOST, current_routing);

  netcard->setId(current_routing->addComponent(netcard));
  sg_host_t h = simgrid::s4u::Host::by_name_or_create(host->id);
  h->pimpl_netcard = netcard;
  simgrid::surf::netcardCreatedCallbacks(netcard);

  if(mount_list){
    xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);
    mount_list = NULL;
  }

  if (host->coord && strcmp(host->coord, "")) {
    unsigned int cursor;
    char*str;

    if (!COORD_HOST_LEVEL)
      xbt_die ("To use host coordinates, please add --cfg=network/coordinates:yes to your command line");
    /* Pre-parse the host coordinates -- FIXME factorize with routers by overloading the routing->parse_PU function*/
    xbt_dynar_t ctn_str = xbt_str_split_str(host->coord, " ");
    xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);
    xbt_dynar_foreach(ctn_str,cursor, str) {
      double val = xbt_str_parse_double(str, "Invalid coordinate: %s");
      xbt_dynar_push(ctn,&val);
    }
Exemple #6
0
/** @brief Retrieve a routing edge from its name
 *
 * Routing edges are either host and routers, whatever
 */
RoutingEdge *sg_routing_edge_by_name_or_null(const char *name) {
  sg_host_t h = sg_host_by_name(name);
  RoutingEdge *net_elm = h==NULL?NULL: sg_host_edge(h);
  if (!net_elm)
	net_elm = (RoutingEdge*) xbt_lib_get_or_null(as_router_lib, name, ROUTING_ASR_LEVEL);
  return net_elm;
}
Exemple #7
0
int console_host_set_property(lua_State *L) {
  const char* name ="";
  const char* prop_id = "";
  const char* prop_value = "";
  lua_ensure(lua_istable(L, -1), "Bad Arguments to create link, Should be a table with named arguments");

  // get Host id
  lua_pushstring(L, "host");
  lua_gettable(L, -2);
  name = lua_tostring(L, -1);
  lua_pop(L, 1);

  // get prop Name
  lua_pushstring(L, "prop");
  lua_gettable(L, -2);
  prop_id = lua_tostring(L, -1);
  lua_pop(L, 1);
  //get args
  lua_pushstring(L,"value");
  lua_gettable(L, -2);
  prop_value = lua_tostring(L,-1);
  lua_pop(L, 1);

  sg_host_t host = sg_host_by_name(name);
  lua_ensure(host, "no host '%s' found",name);
  xbt_dict_t props = sg_host_get_properties(host);
  xbt_dict_set(props,prop_id,xbt_strdup(prop_value),nullptr);

  return 0;
}
Exemple #8
0
/**
 * \brief Add a "host" to the network element list
 */
static void parse_S_host(sg_platf_host_cbarg_t host)
{
  if (current_routing->p_hierarchy == SURF_ROUTING_NULL)
    current_routing->p_hierarchy = SURF_ROUTING_BASE;
  xbt_assert(!sg_host_by_name(host->id),
		     "Reading a host, processing unit \"%s\" already exists", host->id);

  RoutingEdge *info = new RoutingEdgeImpl(xbt_strdup(host->id),
		                                    -1,
		                                    SURF_NETWORK_ELEMENT_HOST,
		                                    current_routing);
  info->setId(current_routing->parsePU(info));
  sg_host_edge_set(sg_host_by_name_or_create(host->id), info);
  XBT_DEBUG("Having set name '%s' id '%d'", host->id, info->getId());

  if(mount_list){
    xbt_lib_set(storage_lib, host->id, ROUTING_STORAGE_HOST_LEVEL, (void *) mount_list);
    mount_list = NULL;
  }

  if (host->coord && strcmp(host->coord, "")) {
    unsigned int cursor;
    char*str;

    if (!COORD_HOST_LEVEL)
      xbt_die ("To use host coordinates, please add --cfg=network/coordinates:yes to your command line");
    /* Pre-parse the host coordinates -- FIXME factorize with routers by overloading the routing->parse_PU function*/
    xbt_dynar_t ctn_str = xbt_str_split_str(host->coord, " ");
    xbt_dynar_t ctn = xbt_dynar_new(sizeof(double),NULL);
    xbt_dynar_foreach(ctn_str,cursor, str) {
      double val = atof(str);
      xbt_dynar_push(ctn,&val);
    }
/** @brief Retrieve a netcard from its name
 *
 * Netcards are the thing that connect host or routers to the network
 */
simgrid::routing::NetCard *sg_netcard_by_name_or_null(const char *name)
{
  sg_host_t h = sg_host_by_name(name);
  simgrid::routing::NetCard *netcard = h==nullptr ? nullptr: h->pimpl_netcard;
  if (!netcard)
    netcard = (simgrid::routing::NetCard*) xbt_lib_get_or_null(as_router_lib, name, ROUTING_ASR_LEVEL);
  return netcard;
}
Exemple #10
0
int main(int argc, char* argv[])
{
  SIMIX_global_init(&argc, argv);
  xbt_assert(argc == 2, "Usage: %s platform.xml\n", argv[0]);
  simgrid_load_platform(argv[1]);
  simcall_process_create("master", example::master, NULL, sg_host_by_name("Tremblay"), NULL);
  SIMIX_run();
  return 0;
}
Exemple #11
0
Host *HostCLM03Model::createHost(const char *name){
  sg_host_t sg_host = sg_host_by_name(name);
  Host *host = new HostCLM03(surf_host_model, name, NULL,
		  (xbt_dynar_t)xbt_lib_get_or_null(storage_lib, name, ROUTING_STORAGE_HOST_LEVEL),
		  sg_host_edge(sg_host),
		  sg_host_surfcpu(sg_host));
  XBT_DEBUG("Create host %s with %ld mounted disks", name, xbt_dynar_length(host->p_storage));
  xbt_lib_set(host_lib, name, SURF_HOST_LEVEL, host);
  return host;
}
Exemple #12
0
/**
 * @brief Internal function to create a SIMIX host.
 * @param name name of the host to create
 * @param data some user data (may be nullptr)
 */
sg_host_t SIMIX_vm_create(const char *name, sg_host_t ind_phys_host)
{
  /* Create surf associated resource */
  surf_vm_model_create(name, ind_phys_host);
  sg_host_t host = sg_host_by_name(name);
  SIMIX_host_create(host);

  /* We will be able to register the VM to its physical host, so that we can promptly
   * retrieve the list VMs on the physical host. */

  return host;
}
Exemple #13
0
/* Update the physical host of the given VM */
void VMHL13::migrate(sg_host_t host_dest)
{
   HostImpl *surfHost_dst = host_dest->extension<HostImpl>();
   const char *vm_name = getName();
   const char *pm_name_src = hostPM_->name().c_str();
   const char *pm_name_dst = surfHost_dst->getName();

   /* update net_elm with that of the destination physical host */
   sg_host_by_name(vm_name)->pimpl_netcard = sg_host_by_name(pm_name_dst)->pimpl_netcard;

   hostPM_ = host_dest;

   /* Update vcpu's action for the new pm */
   {
     /* create a cpu action bound to the pm model at the destination. */
     CpuAction *new_cpu_action = static_cast<CpuAction*>(host_dest->pimpl_cpu->execution_start(0));

     Action::State state = action_->getState();
     if (state != Action::State::done)
       XBT_CRITICAL("FIXME: may need a proper handling, %d", static_cast<int>(state));
     if (action_->getRemainsNoUpdate() > 0)
       XBT_CRITICAL("FIXME: need copy the state(?), %f", action_->getRemainsNoUpdate());

     /* keep the bound value of the cpu action of the VM. */
     double old_bound = action_->getBound();
     if (old_bound != 0) {
       XBT_DEBUG("migrate VM(%s): set bound (%f) at %s", vm_name, old_bound, pm_name_dst);
       new_cpu_action->setBound(old_bound);
     }

     XBT_ATTRIB_UNUSED int ret = action_->unref();
     xbt_assert(ret == 1, "Bug: some resource still remains");

     action_ = new_cpu_action;
   }

   XBT_DEBUG("migrate VM(%s): change PM (%s to %s)", vm_name, pm_name_src, pm_name_dst);
}
Exemple #14
0
/**
 * \brief Returns a host given its name. This is a lua function.
 *
 * \param L a Lua state
 * \return number of values returned to Lua
 *
 * - Argument 1 (string): name of a host
 * - Return value (host): the corresponding host will be pushed onto the stack
 */
static int l_host_get_by_name(lua_State * L)
{
  const char *name = luaL_checkstring(L, 1);
  lua_remove(L, 1); /* remove the args from the stack */

  sg_host_t host = sg_host_by_name(name);
  lua_ensure(host, "No host name '%s' found.", name);

  lua_newtable(L);                        /* table */
  sg_host_t *lua_host = (sg_host_t *) lua_newuserdata(L, sizeof(sg_host_t)); /* table userdatum */
  *lua_host = host;
  luaL_getmetatable(L, HOST_MODULE_NAME); /* table userdatum metatable */
  lua_setmetatable(L, -2);                /* table userdatum */
  lua_setfield(L, -2, HOST_FIELDNAME);    /* table -- put the userdata as field of the table */

  return 1;
}
Exemple #15
0
/* Creates a workstation and registers it in SD.
 */
SD_workstation_t __SD_workstation_create(void *surf_workstation,
                                         void *data)
{

  SD_workstation_priv_t workstation;
  const char *name;

  workstation = xbt_new(s_SD_workstation_priv_t, 1);
  workstation->data = data;     /* user data */
  workstation->access_mode = SD_WORKSTATION_SHARED_ACCESS;      /* default mode is shared */
  workstation->task_fifo = NULL;
  workstation->current_task = NULL;

  name = surf_resource_name(surf_workstation);
  sg_host_t sg_host = sg_host_by_name(name);
  sg_host_sd_set(sg_host,workstation);
  return sg_host;
}
Exemple #16
0
int main(int argc, char **argv)
{
  double now = -1.0;
  surf_init(&argc, argv);       /* Initialize some common structures */
  xbt_cfg_set_parse("cpu/model:Cas01");
  xbt_cfg_set_parse("network/model:CM02");

  xbt_assert(argc > 1, "Usage: %s platform.xml\n", argv[0]);
  parse_platform_file(argv[1]);

  XBT_DEBUG("CPU model: %p", surf_cpu_model_pm);
  XBT_DEBUG("Network model: %p", surf_network_model);
  simgrid::s4u::Host* hostA = sg_host_by_name("Cpu A");
  simgrid::s4u::Host* hostB = sg_host_by_name("Cpu B");

  /* Let's do something on it */
  simgrid::surf::Action* actionA = hostA->pimpl_cpu->execution_start(1000.0);
  simgrid::surf::Action* actionB = hostB->pimpl_cpu->execution_start(1000.0);
  simgrid::surf::Action* actionC = hostB->pimpl_cpu->sleep(7.32);

  simgrid::surf::Action::State stateActionA = actionA->getState();
  simgrid::surf::Action::State stateActionB = actionB->getState();
  simgrid::surf::Action::State stateActionC = actionC->getState();

  /* And just look at the state of these tasks */
  XBT_INFO("actionA state: %s", string_action(stateActionA));
  XBT_INFO("actionB state: %s", string_action(stateActionB));
  XBT_INFO("actionC state: %s", string_action(stateActionC));


  /* Let's do something on it */
  surf_network_model->communicate(hostA, hostB, 150.0, -1.0);

  surf_solve(-1.0);
  do {
    simgrid::surf::ActionList *action_list = nullptr;
    now = surf_get_clock();
    XBT_INFO("Next Event : %g", now);
    XBT_DEBUG("\t CPU actions");

    action_list = surf_cpu_model_pm->getFailedActionSet();
    for(simgrid::surf::ActionList::iterator it(action_list->begin()), itNext = it, itend(action_list->end()) ;
        it != itend ; it=itNext) {
      ++itNext;
      simgrid::surf::Action *action = static_cast<simgrid::surf::CpuAction*>(&*it);
       XBT_INFO("   CPU Failed action");
       XBT_DEBUG("\t * Failed : %p", action);
       action->unref();
    }

    action_list = surf_cpu_model_pm->getDoneActionSet();
    for(simgrid::surf::ActionList::iterator it(action_list->begin()), itNext = it, itend(action_list->end()) ;
        it != itend ; it=itNext) {
      ++itNext;
      simgrid::surf::Action *action = static_cast<simgrid::surf::CpuAction*>(&*it);
      XBT_INFO("   CPU Done action");
      XBT_DEBUG("\t * Done : %p", action);
      action->unref();
    }

    action_list = surf_network_model->getFailedActionSet();
    for(simgrid::surf::ActionList::iterator it(action_list->begin()), itNext = it, itend(action_list->end()) ;
        it != itend ; it=itNext) {
      ++itNext;
      simgrid::surf::Action *action = static_cast<simgrid::surf::NetworkAction*>(&*it);
       XBT_INFO("   Network Failed action");
       XBT_DEBUG("\t * Failed : %p", action);
       action->unref();
    }

    action_list = surf_network_model->getDoneActionSet();
    for(simgrid::surf::ActionList::iterator it(action_list->begin()), itNext = it, itend(action_list->end()) ;
        it != itend ; it=itNext) {
      ++itNext;
      simgrid::surf::Action *action = static_cast<simgrid::surf::NetworkAction*>(&*it);
      XBT_INFO("   Network Done action");
      XBT_DEBUG("\t * Done : %p", action);
      action->unref();
    }

  } while ((surf_network_model->getRunningActionSet()->size() ||
           surf_cpu_model_pm->getRunningActionSet()->size()) && surf_solve(-1.0) >= 0.0);

  XBT_DEBUG("Simulation Terminated");

  return 0;
}
Exemple #17
0
/* This function acts as a main in the parsing area. */
void parse_platform_file(const char *file)
{
#if HAVE_LUA
  int is_lua = (file != NULL && strlen(file) > 3 && file[strlen(file)-3] == 'l' && file[strlen(file)-2] == 'u'
        && file[strlen(file)-1] == 'a');
#endif

  sg_platf_init();

#if HAVE_LUA
  /* Check if file extension is "lua". If so, we will use
   * the lua bindings to parse the platform file (since it is
   * written in lua). If not, we will use the (old?) XML parser
   */
  if (is_lua) {
    lua_State* L = luaL_newstate();
    luaL_openlibs(L);

    luaL_loadfile(L, file); // This loads the file without executing it.

    /* Run the script */
    if (lua_pcall(L, 0, 0, 0)) {
        XBT_ERROR("FATAL ERROR:\n  %s: %s\n\n", "Lua call failed. Errormessage:", lua_tostring(L, -1));
        xbt_die("Lua call failed. See Log");
    }
  }
  else
#endif
  { // Use XML parser

    int parse_status;

    /* init the flex parser */
    surfxml_buffer_stack_stack_ptr = 1;
    surfxml_buffer_stack_stack[0] = 0;
    after_config_done = 0;
    surf_parse_open(file);

    traces_set_list = xbt_dict_new_homogeneous(NULL);
    trace_connect_list_host_avail = xbt_dict_new_homogeneous(free);
    trace_connect_list_host_speed = xbt_dict_new_homogeneous(free);
    trace_connect_list_link_avail = xbt_dict_new_homogeneous(free);
    trace_connect_list_link_bw = xbt_dict_new_homogeneous(free);
    trace_connect_list_link_lat = xbt_dict_new_homogeneous(free);

    /* Init my data */
    if (!surfxml_bufferstack_stack)
      surfxml_bufferstack_stack = xbt_dynar_new(sizeof(char *), NULL);

    /* Do the actual parsing */
    parse_status = surf_parse();

    /* connect all traces relative to hosts */
    xbt_dict_cursor_t cursor = NULL;
    char *trace_name, *elm;

    xbt_dict_foreach(trace_connect_list_host_avail, cursor, trace_name, elm) {
      tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
      xbt_assert(trace, "Trace %s undefined", trace_name);

      simgrid::s4u::Host *host = sg_host_by_name(elm);
      xbt_assert(host, "Host %s undefined", elm);
      simgrid::surf::Cpu *cpu = host->pimpl_cpu;

      cpu->setStateTrace(trace);
    }
    xbt_dict_foreach(trace_connect_list_host_speed, cursor, trace_name, elm) {
      tmgr_trace_t trace = (tmgr_trace_t) xbt_dict_get_or_null(traces_set_list, trace_name);
      xbt_assert(trace, "Trace %s undefined", trace_name);

      simgrid::s4u::Host *host = sg_host_by_name(elm);
      xbt_assert(host, "Host %s undefined", elm);
      simgrid::surf::Cpu *cpu = host->pimpl_cpu;

      cpu->setSpeedTrace(trace);
    }
Exemple #18
0
int main(int argc, char **argv)
{
  double computation_amount[1];
  double communication_amount[2] = { 0 };
  sg_host_t hosts[1];

  /* initialization of SD */
  SD_init(&argc, argv);

  /* creation of the environment */
  SD_create_environment(argv[1]);

  /* creation of a single task that will poorly fail when the workstation will stop */
  XBT_INFO("First test: COMP_SEQ task");
  SD_task_t task = SD_task_create_comp_seq("Poor task", NULL, 2e10);
  SD_task_watch(task, SD_FAILED);
  SD_task_watch(task, SD_DONE);

  XBT_INFO("Schedule task '%s' on 'Faulty Host'", SD_task_get_name(task));

  SD_task_schedulel(task, 1, sg_host_by_name("Faulty Host"));

  xbt_dynar_t tasks = SD_simulate(-1.0);
  xbt_dynar_free(&tasks);

  SD_task_dump(task);

  XBT_INFO("Task '%s' has failed. %.f flops remain to be done", SD_task_get_name(task),
           SD_task_get_remaining_amount(task));

  XBT_INFO("let's unschedule task '%s' and reschedule it on the 'Safe Host'", SD_task_get_name(task));
  SD_task_unschedule(task);
  SD_task_schedulel(task, 1, sg_host_by_name("Safe Host"));

  XBT_INFO("Run the simulation again");
  tasks = SD_simulate(-1.0);
  xbt_dynar_free(&tasks);

  SD_task_dump(task);
  XBT_INFO("Task '%s' start time: %f, finish time: %f", SD_task_get_name(task), SD_task_get_start_time(task),
           SD_task_get_finish_time(task));

  SD_task_destroy(task);
  task=NULL;

  XBT_INFO("Second test: NON TYPED task");

  task = SD_task_create("Poor parallel task", NULL, 2e10);
  SD_task_watch(task, SD_FAILED);
  SD_task_watch(task, SD_DONE);

  computation_amount[0] = 2e10;

  XBT_INFO("Schedule task '%s' on 'Faulty Host'", SD_task_get_name(task));

  hosts[0] = sg_host_by_name("Faulty Host");
  SD_task_schedule(task, 1, hosts, computation_amount, communication_amount,-1);

  tasks = SD_simulate(-1.0);
  xbt_dynar_free(&tasks);

  SD_task_dump(task);

  XBT_INFO("Task '%s' has failed. %.f flops remain to be done", SD_task_get_name(task),
            SD_task_get_remaining_amount(task));

  XBT_INFO("let's unschedule task '%s' and reschedule it on the 'Safe Host'", SD_task_get_name(task));
  SD_task_unschedule(task);

  hosts[0] = sg_host_by_name("Safe Host");

  SD_task_schedule(task, 1, hosts, computation_amount, communication_amount,-1);

  XBT_INFO("Run the simulation again");
  tasks = SD_simulate(-1.0);
  xbt_dynar_free(&tasks);

  SD_task_dump(task);
  XBT_INFO("Task '%s' start time: %f, finish time: %f", SD_task_get_name(task), SD_task_get_start_time(task),
           SD_task_get_finish_time(task));

  SD_task_destroy(task);
  SD_exit();
  return 0;
}
Exemple #19
0
int main(int argc, char **argv)
{
  sg_host_t hostA = NULL;
  sg_host_t hostB = NULL;
  double now = -1.0;
  int running;

  surf_init(&argc, argv);       /* Initialize some common structures */

  xbt_cfg_set_parse("network/model:CM02");
  xbt_cfg_set_parse("cpu/model:Cas01");

  xbt_assert(argc >1, "Usage : %s platform.txt\n", argv[0]);
  parse_platform_file(argv[1]);

  /*********************** HOST ***********************************/
  hostA = sg_host_by_name("Cpu A");
  hostB = sg_host_by_name("Cpu B");

  /* Let's check that those two processors exist */
  XBT_DEBUG("%s : %p", sg_host_get_name(hostA), hostA);
  XBT_DEBUG("%s : %p", sg_host_get_name(hostB), hostB);

  /* Let's do something on it */
  hostA->pimpl_cpu->execution_start(1000.0);
  hostB->pimpl_cpu->execution_start(1000.0);
  surf_host_sleep(hostB, 7.32);

  surf_network_model_communicate(surf_network_model, hostA, hostB, 150.0, -1.0);

  surf_solve(-1.0);                 /* Takes traces into account. Returns 0.0 */
  do {
    surf_action_t action = NULL;
    unsigned int iter;
    surf_model_t model = NULL;
    running = 0;

    now = surf_get_clock();
    XBT_INFO("Next Event : %g", now);

    xbt_dynar_foreach(all_existing_models, iter, model) {
      if (surf_model_running_action_set_size((surf_model_t)model)) {
        XBT_DEBUG("\t Running that model");
        running = 1;
      }
      while ((action = surf_model_extract_failed_action_set((surf_model_t)model))) {
        XBT_INFO("   * Done Action");
        XBT_DEBUG("\t * Failed Action: %p", action);
        action->unref();
      }
      while ((action = surf_model_extract_done_action_set((surf_model_t)model))) {
        XBT_INFO("   * Done Action");
        XBT_DEBUG("\t * Done Action: %p", action);
        action->unref();
      }
    }
  } while (running && surf_solve(-1.0) >= 0.0);

  XBT_INFO("Simulation Terminated");
  surf_exit();
  return 0;
}
Exemple #20
0
void test(char *platform)
{
  sg_host_t cpuA = NULL;
  sg_host_t cpuB = NULL;
  surf_action_t actionA = NULL;
  surf_action_t actionB = NULL;
  surf_action_t actionC = NULL;
  e_surf_action_state_t stateActionA;
  e_surf_action_state_t stateActionB;
  e_surf_action_state_t stateActionC;
  double now = -1.0;
  xbt_cfg_set_parse(_sg_cfg_set, "cpu/model:Cas01");
  xbt_cfg_set_parse(_sg_cfg_set, "network/model:CM02");
  parse_platform_file(platform);

  /*********************** CPU ***********************************/
  XBT_DEBUG("%p", surf_cpu_model_pm);
  cpuA = sg_host_by_name("Cpu A");
  cpuB = sg_host_by_name("Cpu B");

  /* Let's check that those two processors exist */
  XBT_DEBUG("%s : %p", surf_cpu_name(sg_host_surfcpu(cpuA)), cpuA);
  XBT_DEBUG("%s : %p", surf_cpu_name(sg_host_surfcpu(cpuB)), cpuB);

  /* Let's do something on it */
  actionA = surf_cpu_execute(cpuA, 1000.0);
  actionB = surf_cpu_execute(cpuB, 1000.0);
  actionC = surf_cpu_sleep(cpuB, 7.32);

  /* Use whatever calling style you want... */
  stateActionA = surf_action_get_state(actionA);     /* When you know actionA model type */
  stateActionB = surf_action_get_state(actionB);        /* If you're unsure about it's model type */
  stateActionC = surf_action_get_state(actionC);     /* When you know actionA model type */

  /* And just look at the state of these tasks */
  XBT_DEBUG("actionA : %p (%s)", actionA, string_action(stateActionA));
  XBT_DEBUG("actionB : %p (%s)", actionB, string_action(stateActionB));
  XBT_DEBUG("actionC : %p (%s)", actionB, string_action(stateActionC));

  /*********************** Network *******************************/
  XBT_DEBUG("%p", surf_network_model);

  /* Let's do something on it */
  surf_network_model_communicate(surf_network_model, cpuA, cpuB, 150.0, -1.0);

  surf_solve(-1.0);                 /* Takes traces into account. Returns 0.0 */
  do {
    surf_action_t action = NULL;
    now = surf_get_clock();
    XBT_DEBUG("Next Event : %g", now);
    XBT_DEBUG("\t CPU actions");
    while ((action =
            surf_model_extract_failed_action_set((surf_model_t)surf_cpu_model_pm))) {
      XBT_DEBUG("\t * Failed : %p", action);
      surf_action_unref(action);
    }
    while ((action =
            surf_model_extract_done_action_set((surf_model_t)surf_cpu_model_pm))) {
      XBT_DEBUG("\t * Done : %p", action);
      surf_action_unref(action);
    }
    XBT_DEBUG("\t Network actions");
    while ((action =
            surf_model_extract_failed_action_set((surf_model_t)surf_network_model))) {
      XBT_DEBUG("\t * Failed : %p", action);
      surf_action_unref(action);
    }
    while ((action =
            surf_model_extract_done_action_set((surf_model_t)surf_network_model))) {
      XBT_DEBUG("\t * Done : %p", action);
      surf_action_unref(action);
    }

  } while ((surf_model_running_action_set_size((surf_model_t)surf_network_model) ||
            surf_model_running_action_set_size((surf_model_t)surf_cpu_model_pm)) &&
           surf_solve(-1.0) >= 0.0);

  XBT_DEBUG("Simulation Terminated");
}
Exemple #21
0
void setCpu(char *name, Cpu *cpu) {
	sg_host_surfcpu_set(sg_host_by_name(name), cpu);
}