int MC_protocol_hello(int socket)
{
int e;
if ((e = MC_protocol_send_simple_message(socket, MC_MESSAGE_HELLO)) != 0) {
XBT_ERROR("Could not send HELLO message");
return 1;
}
s_mc_message_t message;
message.type = MC_MESSAGE_NONE;
ssize_t s;
while ((s = MC_receive_message(socket, &message, sizeof(message), 0)) == -1) {
if (errno == EINTR)
continue;
else {
XBT_ERROR("Could not receive HELLO message");
return 2;
}
}
if ((size_t) s < sizeof(message) || message.type != MC_MESSAGE_HELLO) {
XBT_ERROR("Did not receive suitable HELLO message. Who are you?");
return 3;
}
return 0;
}
/* Internal function used to factorize code between
* MSG_task_isend_with_matching() and MSG_task_dsend().
*/
static XBT_INLINE
msg_comm_t MSG_task_isend_internal(msg_task_t task, const char *alias,
int (*match_fun)(void*,void*, smx_synchro_t),
void *match_data, void_f_pvoid_t cleanup,
int detached)
{
simdata_task_t t_simdata = NULL;
msg_process_t process = MSG_process_self();
msg_mailbox_t mailbox = MSG_mailbox_get_by_alias(alias);
int call_end = TRACE_msg_task_put_start(task);
/* Prepare the task to send */
t_simdata = task->simdata;
t_simdata->sender = process;
t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data(process))->m_host;
if (t_simdata->isused != 0) {
if (msg_global->debug_multiple_use){
XBT_ERROR("This task is already used in there:");
xbt_backtrace_display(t_simdata->isused);
XBT_ERROR("And you try to reuse it from here:");
xbt_backtrace_display_current();
} else {
xbt_assert(t_simdata->isused == 0,
"This task is still being used somewhere else. You cannot send it now. Go fix your code! (use --cfg=msg/debug_multiple_use:on to get the backtrace of the other process)");
}
}
if (msg_global->debug_multiple_use)
MSG_BT(t_simdata->isused, "Using Backtrace");
else
t_simdata->isused = (void*)1;
t_simdata->comm = NULL;
msg_global->sent_msg++;
/* Send it by calling SIMIX network layer */
smx_synchro_t act = simcall_comm_isend(SIMIX_process_self(), mailbox, t_simdata->bytes_amount,
t_simdata->rate, task, sizeof(void *),
match_fun, cleanup, NULL, match_data,detached);
t_simdata->comm = act; /* FIXME: is the field t_simdata->comm still useful? */
msg_comm_t comm;
if (detached) {
comm = NULL;
} else {
comm = xbt_new0(s_msg_comm_t, 1);
comm->task_sent = task;
comm->task_received = NULL;
comm->status = MSG_OK;
comm->s_comm = act;
}
if (TRACE_is_enabled())
simcall_set_category(act, task->category);
if (call_end)
TRACE_msg_task_put_end();
return comm;
}
void cputimer_get(int tid, long long int *times, xbt_cpu_timer_t timer)
{
struct msgtemplate msg;
int rep_len;
struct nlattr *na;
struct taskstats *stats;
netlink_sock_send(timer->_id, TASKSTATS_CMD_GET, TASKSTATS_CMD_ATTR_PID, &tid, sizeof(__u32), timer);
rep_len = recv(timer->_nl_sd, &msg, sizeof(msg), 0);
xbt_assert(rep_len >= 0, "error while receiving the answer from netlink socket: %s", strerror(errno));
xbt_assert((msg.n.nlmsg_type != NLMSG_ERROR && NLMSG_OK((&msg.n), rep_len)),
"received a fatal error from the netlink socket: %s", strerror(errno));
rep_len = GENLMSG_PAYLOAD(&msg.n);
na = (struct nlattr *) GENLMSG_DATA(&msg);
int len = 0;
int aggr_len, len2;
while (len < rep_len) {
len += NLA_ALIGN(na->nla_len);
switch (na->nla_type) {
case TASKSTATS_TYPE_AGGR_PID:
aggr_len = NLA_PAYLOAD(na->nla_len);
len2 = 0;
/* For nested attributes, na follows */
na = (struct nlattr *) NLA_DATA(na);
while (len2 < aggr_len) {
switch (na->nla_type) {
case TASKSTATS_TYPE_PID:
break;
case TASKSTATS_TYPE_STATS:
/* here we collect info */
stats = (struct taskstats *) NLA_DATA(na);
//times[0] = (long long int)stats->ac_etime;
times[1] = (long long int) stats->ac_utime; /* User CPU time [usec] */
times[2] = (long long int) stats->ac_stime; /* SYstem CPU time [usec] */
break;
default:
XBT_ERROR("Unknown nested" " nla_type %d\n", na->nla_type);
break;
}
len2 += NLA_ALIGN(na->nla_len);
na = (struct nlattr *) ((char *) na + len2);
}
break;
default:
XBT_ERROR("Unknown nla_type %d\n", na->nla_type);
break;
}
na = (struct nlattr *) ((char *) GENLMSG_DATA(&msg) + len);
}
}
void simdata_task::reportMultipleUse() const
{
if (msg_global->debug_multiple_use){
XBT_ERROR("This task is already used in there:");
// TODO, backtrace
XBT_ERROR("<missing backtrace>");
XBT_ERROR("And you try to reuse it from here:");
xbt_backtrace_display_current();
} else {
xbt_die("This task is still being used somewhere else. You cannot send it now. Go fix your code!"
"(use --cfg=msg/debug-multiple-use:on to get the backtrace of the other process)");
}
}
static int slave(int argc, char *argv[])
{
xbt_ex_t e;
TRY {
XBT_INFO("Slave waiting");
// TODO, This should really be MSG_HOST_FAILURE
MSG_process_sleep(5);
XBT_ERROR("Slave should be off already.");
return 1;
}
CATCH(e) {
XBT_ERROR("Exception caught in the slave");
return 1;
}
return 0;
}
int main(int argc, char **argv)
{
int i;
const char *user_data = "some user_data";
const SD_link_t *links;
/* initialization of SD */
SD_init(&argc, argv);
/* creation of the environment */
SD_create_environment(argv[1]);
links = SD_link_get_list();
int count = SD_link_get_number();
XBT_INFO("Link count: %d", count);
qsort((void *)links, count, sizeof(SD_link_t), cmp_link);
for(i=0; i<SD_link_get_number();i++){
XBT_INFO("%s: latency = %.5f, bandwidth = %f",
SD_link_get_name(links[i]),
SD_link_get_current_latency(links[i]),
SD_link_get_current_bandwidth(links[i]));
SD_link_set_data(links[i], (void*) user_data);
if(strcmp(user_data, (const char*)SD_link_get_data(links[i]))){
XBT_ERROR("User data was corrupted.");
}
}
SD_exit();
return 0;
}
int main(int argc, char **argv)
{
xbt_dynar_t dax;
unsigned int cursor;
SD_task_t task;
/* SD initialization */
SD_init(&argc, argv);
/* Check our arguments */
xbt_assert(argc > 2, "Usage: %s platform_file dax_file [jedule_file]\n"
"\tExample: %s simulacrum_7_hosts.xml Montage_25.xml Montage_25.jed", argv[0], argv[0]);
char *last = strrchr(argv[2], '.');
char * tracefilename = bprintf("%.*s.trace",(int) (last == NULL ? strlen(argv[2]):last - argv[2]), argv[2]);
if (argc == 4)
tracefilename = xbt_strdup(argv[3]);
/* creation of the environment */
SD_create_environment(argv[1]);
/* load the DAX file */
dax = SD_daxload(argv[2]);
if (!dax){
XBT_ERROR("A problem occurred during DAX parsing (cycle or syntax). Do not continue this test");
free(tracefilename);
SD_exit();
exit(255);
}
/* Display all the tasks */
XBT_INFO("------------------- Display all tasks of the loaded DAG ---------------------------");
xbt_dynar_foreach(dax, cursor, task) {
SD_task_dump(task);
}
void xbt_backtrace_display(xbt_ex_t * e)
{
xbt_ex_setup_backtrace(e);
#ifdef HAVE_BACKTRACE
if (e->used == 0) {
fprintf(stderr, "(backtrace not set)\n");
} else {
int i;
fprintf(stderr, "Backtrace (displayed in thread %p):\n",
(void *) xbt_thread_self());
for (i = 1; i < e->used; i++) /* no need to display "xbt_display_backtrace" */
fprintf(stderr, "---> %s\n", e->bt_strings[i] + 4);
}
/* don't fool xbt_ex_free with uninitialized msg field */
e->msg = NULL;
e->remote = 0;
xbt_ex_free(*e);
#else
XBT_ERROR("No backtrace on this arch");
#endif
}
static void worker()
{
XBT_INFO("Worker waiting");
// TODO, This should really be MSG_HOST_FAILURE
simgrid::s4u::this_actor::sleep_for(5);
XBT_ERROR("Worker should be off already.");
}
void surf_parse_error(std::string msg)
{
int lineno = surf_parse_lineno;
cleanup();
XBT_ERROR("Parse error at %s:%d: %s", surf_parsed_filename, lineno, msg.c_str());
surf_exit();
xbt_die("Exiting now");
}
/**
* This function is called by SIMIX_global_init() to initialize the context module.
*/
void SIMIX_context_mod_init()
{
xbt_assert(simix_global->context_factory == nullptr);
#if HAVE_SMPI && (defined(__APPLE__) || defined(__NetBSD__))
std::string priv = simgrid::config::get_value<std::string>("smpi/privatization");
if (context_factory_name == "thread" && (priv == "dlopen" || priv == "yes" || priv == "default" || priv == "1")) {
XBT_WARN("dlopen+thread broken on Apple and BSD. Switching to raw contexts.");
context_factory_name = "raw";
}
#endif
#if HAVE_SMPI && defined(__FreeBSD__)
if (context_factory_name == "thread" && simgrid::config::get_value<std::string>("smpi/privatization") != "no") {
XBT_WARN("mmap broken on FreeBSD, but dlopen+thread broken too. Switching to dlopen+raw contexts.");
context_factory_name = "raw";
}
#endif
/* select the context factory to use to create the contexts */
if (simgrid::kernel::context::factory_initializer != nullptr) { // Give Java a chance to hijack the factory mechanism
simix_global->context_factory = simgrid::kernel::context::factory_initializer();
return;
}
/* use the factory specified by --cfg=contexts/factory:value */
for (auto const& factory : context_factories)
if (context_factory_name == factory.first) {
simix_global->context_factory = factory.second();
break;
}
if (simix_global->context_factory == nullptr) {
XBT_ERROR("Invalid context factory specified. Valid factories on this machine:");
#if HAVE_RAW_CONTEXTS
XBT_ERROR(" raw: high performance context factory implemented specifically for SimGrid");
#else
XBT_ERROR(" (raw contexts were disabled at compilation time on this machine -- check configure logs for details)");
#endif
#if HAVE_UCONTEXT_CONTEXTS
XBT_ERROR(" ucontext: classical system V contexts (implemented with makecontext, swapcontext and friends)");
#else
XBT_ERROR(" (ucontext was disabled at compilation time on this machine -- check configure logs for details)");
#endif
#if HAVE_BOOST_CONTEXTS
XBT_ERROR(" boost: this uses the boost libraries context implementation");
#else
XBT_ERROR(" (boost was disabled at compilation time on this machine -- check configure logs for details. Did you install the libboost-context-dev package?)");
#endif
XBT_ERROR(" thread: slow portability layer using pthreads as provided by gcc");
xbt_die("Please use a valid factory.");
}
}
void surf_parse_error(const char *fmt, ...) {
va_list va;
va_start(va,fmt);
int lineno = surf_parse_lineno;
char *msg = bvprintf(fmt,va);
va_end(va);
cleanup();
XBT_ERROR("Parse error at %s:%d: %s", surf_parsed_filename, lineno, msg);
surf_exit();
xbt_die("Exiting now");
}
/** @brief Ensures that the pointed stack value is an host userdatum and returns it.
*
* \param L a Lua state
* \param index an index in the Lua stack
* \return the C host corresponding to this Lua host
*/
sg_host_t sglua_check_host(lua_State * L, int index)
{
luaL_checktype(L, index, LUA_TTABLE);
lua_getfield(L, index, HOST_FIELDNAME);
sg_host_t *pi = (sg_host_t *) luaL_checkudata(L, lua_gettop(L), HOST_MODULE_NAME);
lua_pop(L, 1);
if (pi == nullptr)
XBT_ERROR("luaL_checkudata() returned nullptr");
sg_host_t ht = *pi;
if (!ht)
luaL_error(L, "null Host");
return ht;
}
static void *armageddon_sigwaiter(_XBT_GNUC_UNUSED void *arg)
{
xbt_os_mutex_acquire(sigwaiter_mutex);
/* Inform main thread that it started. */
xbt_os_cond_signal(sigwaiter_cond);
/* Wait for ending signal... */
xbt_os_cond_wait(sigwaiter_cond, sigwaiter_mutex);
if (armageddon_requested) {
XBT_ERROR("Test suite `%s': caught signal %d", testsuite_name, caught_signum);
rctx_armageddon(rctx, 3);
}
xbt_os_mutex_release(sigwaiter_mutex);
return NULL;
}
static void handler()
{
// Avoid doing crazy things if we get an uncaught exception inside
// an uncaught exception
static std::atomic_flag lock = ATOMIC_FLAG_INIT;
if (lock.test_and_set()) {
XBT_ERROR("Multiple uncaught exceptions");
std::abort();
}
// Get the current backtrace and exception
auto e = std::current_exception();
auto bt = backtrace();
try {
std::rethrow_exception(e);
}
// We manage C++ exception ourselves
catch (std::exception& e) {
logException(xbt_log_priority_critical, "Uncaught exception", e);
showBacktrace(bt);
std::abort();
}
// We don't know how to manage other exceptions
catch (...) {
// If there was another handler let's delegate to it
if (previous_terminate_handler)
previous_terminate_handler();
else {
XBT_ERROR("Unknown uncaught exception");
showBacktrace(bt);
std::abort();
}
}
}
int main(int argc, char **argv)
{
xbt_dynar_t dax, changed;
unsigned int cursor;
SD_task_t task;
/* initialisation of SD */
SD_init(&argc, argv);
/* Check our arguments */
if (argc < 3) {
XBT_INFO("Usage: %s platform_file dax_file [trace_file]", argv[0]);
XBT_INFO
("example: %s ../sd_platform.xml Montage_50.xml Montage_50.mytrace",
argv[0]);
exit(1);
}
char *tracefilename;
if (argc == 3) {
char *last = strrchr(argv[2], '.');
tracefilename =
bprintf("%.*s.trace",
(int) (last == NULL ? strlen(argv[2]) : last - argv[2]),
argv[2]);
} else {
tracefilename = xbt_strdup(argv[3]);
}
/* creation of the environment */
SD_create_environment(argv[1]);
/* load the DAX file */
dax = SD_daxload(argv[2]);
if (!dax){
XBT_ERROR("A problem occurred during DAX parsing (cycle or syntax). Do not continue this test");
free(tracefilename);
SD_exit();
exit(255);
}
/* Display all the tasks */
XBT_INFO
("------------------- Display all tasks of the loaded DAG ---------------------------");
xbt_dynar_foreach(dax, cursor, task) {
SD_task_dump(task);
}
/**
* \brief Like luaL_checkudata, with additional debug logs.
*
* This function is for debugging purposes only.
*
* \param L a lua state
* \param ud index of the userdata to check in the stack
* \param tname key of the metatable of this userdata in the registry
*/
void* sglua_checkudata_debug(lua_State* L, int ud, const char* tname)
{
XBT_DEBUG("Checking the userdata: ud = %d", ud);
sglua_stack_dump(L, "my_checkudata: ");
void* p = lua_touserdata(L, ud);
lua_getfield(L, LUA_REGISTRYINDEX, tname);
const void* correct_mt = lua_topointer(L, -1);
int has_mt = lua_getmetatable(L, ud);
XBT_DEBUG("Checking the userdata: has metatable ? %d", has_mt);
const void* actual_mt = nullptr;
if (has_mt) {
actual_mt = lua_topointer(L, -1);
lua_pop(L, 1);
}
XBT_DEBUG("Checking the task's metatable: expected %p, found %p", correct_mt, actual_mt);
sglua_stack_dump(L, "my_checkudata: ");
if (p == nullptr || !lua_getmetatable(L, ud) || !lua_rawequal(L, -1, -2))
XBT_ERROR("Error: Userdata is nullptr, couldn't find metatable or top of stack does not equal element below it.");
lua_pop(L, 2);
return p;
}
static int do_parent(int socket, pid_t child)
{
XBT_DEBUG("Inside the parent process");
if (mc_server)
xbt_die("MC server already present");
try {
mc_mode = MC_MODE_SERVER;
mc_server = new s_mc_server(child, socket);
mc_server->start();
MC_init_model_checker(child, socket);
if (_sg_mc_comms_determinism || _sg_mc_send_determinism)
MC_modelcheck_comm_determinism();
else if (!_sg_mc_property_file || _sg_mc_property_file[0] == '\0')
MC_modelcheck_safety();
else
MC_modelcheck_liveness();
mc_server->shutdown();
mc_server->exit();
}
catch(std::exception& e) {
XBT_ERROR("Exception: %s", e.what());
}
exit(MC_SERVER_ERROR);
}
void smpi_sample_1(int global, const char *file, int line, int iters, double threshold)
{
char *loc = sample_location(global, file, line);
local_data_t *data;
smpi_bench_end(); /* Take time from previous, unrelated computation into account */
if (!samples)
samples = xbt_dict_new_homogeneous(free);
data = xbt_dict_get_or_null(samples, loc);
if (!data) {
xbt_assert(threshold>0 || iters>0,
"You should provide either a positive amount of iterations to bench, or a positive maximal stderr (or both)");
data = (local_data_t *) xbt_new(local_data_t, 1);
data->count = 0;
data->sum = 0.0;
data->sum_pow2 = 0.0;
data->iters = iters;
data->threshold = threshold;
data->benching = 1; // If we have no data, we need at least one
data->mean = 0;
xbt_dict_set(samples, loc, data, NULL);
XBT_DEBUG("XXXXX First time ever on benched nest %s.",loc);
} else {
if (data->iters != iters || data->threshold != threshold) {
XBT_ERROR("Asked to bench block %s with different settings %d, %f is not %d, %f. How did you manage to give two numbers at the same line??",
loc, data->iters, data->threshold, iters,threshold);
THROW_IMPOSSIBLE;
}
// if we already have some data, check whether sample_2 should get one more bench or whether it should emulate the computation instead
data->benching = !sample_enough_benchs(data);
XBT_DEBUG("XXXX Re-entering the benched nest %s. %s",loc, (data->benching?"more benching needed":"we have enough data, skip computes"));
}
free(loc);
}
int main(int argc, char **argv)
{
sg_host_t host_list[2];
double computation_amount[2];
double communication_amount[4] = { 0 };
/* initialization of SD */
SD_init(&argc, argv);
xbt_assert(argc > 1, "Usage: %s platform_file\n\nExample: %s two_clusters.xml", argv[0], argv[0]);
SD_create_environment(argv[1]);
/* test the estimation functions */
const sg_host_t *hosts = sg_host_list();
sg_host_t h1 = hosts[0];
sg_host_t h2 = hosts[1];
const char *name1 = sg_host_get_name(h1);
const char *name2 = sg_host_get_name(h2);
double comp_amount1 = 2000000;
double comp_amount2 = 1000000;
double comm_amount12 = 2000000;
double comm_amount21 = 3000000;
XBT_INFO("Computation time for %f flops on %s: %f", comp_amount1, name1, comp_amount1/sg_host_speed(h1));
XBT_INFO("Computation time for %f flops on %s: %f", comp_amount2, name2, comp_amount2/sg_host_speed(h2));
XBT_INFO("Route between %s and %s:", name1, name2);
SD_link_t *route = SD_route_get_list(h1, h2);
int route_size = SD_route_get_size(h1, h2);
for (int i = 0; i < route_size; i++)
XBT_INFO(" Link %s: latency = %f, bandwidth = %f", sg_link_name(route[i]), sg_link_latency(route[i]),
sg_link_bandwidth(route[i]));
xbt_free(route);
XBT_INFO("Route latency = %f, route bandwidth = %f", SD_route_get_latency(h1, h2), SD_route_get_bandwidth(h1, h2));
XBT_INFO("Communication time for %f bytes between %s and %s: %f", comm_amount12, name1, name2,
SD_route_get_latency(h1, h2) + comm_amount12 / SD_route_get_bandwidth(h1, h2));
XBT_INFO("Communication time for %f bytes between %s and %s: %f", comm_amount21, name2, name1,
SD_route_get_latency(h2, h1) + comm_amount21 / SD_route_get_bandwidth(h2, h1));
/* creation of the tasks and their dependencies */
SD_task_t taskA = SD_task_create("Task A", NULL, 10.0);
SD_task_t taskB = SD_task_create("Task B", NULL, 40.0);
SD_task_t taskC = SD_task_create("Task C", NULL, 30.0);
SD_task_t taskD = SD_task_create("Task D", NULL, 60.0);
/* try to attach and retrieve user data to a task */
SD_task_set_data(taskA, static_cast<void*>(&comp_amount1));
if (fabs(comp_amount1 - (*(static_cast<double*>(SD_task_get_data(taskA))))) > 1e-12)
XBT_ERROR("User data was corrupted by a simple set/get");
SD_task_dependency_add(NULL, NULL, taskB, taskA);
SD_task_dependency_add(NULL, NULL, taskC, taskA);
SD_task_dependency_add(NULL, NULL, taskD, taskB);
SD_task_dependency_add(NULL, NULL, taskD, taskC);
SD_task_dependency_add(NULL, NULL, taskB, taskC);
try {
SD_task_dependency_add(NULL, NULL, taskA, taskA); /* shouldn't work and must raise an exception */
xbt_die("Hey, I can add a dependency between Task A and Task A!");
} catch (xbt_ex& ex) {
if (ex.category != arg_error)
throw; /* this is a serious error */
}
try {
SD_task_dependency_add(NULL, NULL, taskB, taskA); /* shouldn't work and must raise an exception */
xbt_die("Oh oh, I can add an already existing dependency!");
} catch (xbt_ex& ex) {
if (ex.category != arg_error)
throw;
}
try {
SD_task_dependency_remove(taskA, taskC); /* shouldn't work and must raise an exception */
xbt_die("Dude, I can remove an unknown dependency!");
} catch (xbt_ex& ex) {
if (ex.category != arg_error)
throw;
}
try {
SD_task_dependency_remove(taskC, taskC); /* shouldn't work and must raise an exception */
xbt_die("Wow, I can remove a dependency between Task C and itself!");
} catch (xbt_ex& ex) {
if (ex.category != arg_error)
throw;
}
/* if everything is ok, no exception is forwarded or rethrown by main() */
/* watch points */
SD_task_watch(taskD, SD_DONE);
SD_task_watch(taskB, SD_DONE);
SD_task_unwatch(taskD, SD_DONE);
/* scheduling parameters */
host_list[0] = h1;
host_list[1] = h2;
computation_amount[0] = comp_amount1;
computation_amount[1] = comp_amount2;
communication_amount[1] = comm_amount12;
communication_amount[2] = comm_amount21;
/* estimated time */
SD_task_t task = taskD;
XBT_INFO("Estimated time for '%s': %f", SD_task_get_name(task), SD_task_get_execution_time(task, 2, host_list,
computation_amount, communication_amount));
SD_task_schedule(taskA, 2, host_list, computation_amount, communication_amount, -1);
SD_task_schedule(taskB, 2, host_list, computation_amount, communication_amount, -1);
SD_task_schedule(taskC, 2, host_list, computation_amount, communication_amount, -1);
SD_task_schedule(taskD, 2, host_list, computation_amount, communication_amount, -1);
std::set<SD_task_t> *changed_tasks = simgrid::sd::simulate(-1.0);
for (auto task: *changed_tasks){
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));
}
XBT_DEBUG("Destroying tasks...");
SD_task_destroy(taskA);
SD_task_destroy(taskB);
SD_task_destroy(taskC);
SD_task_destroy(taskD);
XBT_DEBUG("Tasks destroyed. Exiting SimDag...");
SD_exit();
return 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);
}
JNIEXPORT void JNICALL Java_org_simgrid_msg_Msg_error(JNIEnv * env, jclass cls, jstring js)
{
const char *s = env->GetStringUTFChars(js, 0);
XBT_ERROR("%s", s);
env->ReleaseStringUTFChars(js, s);
}
static int error(lua_State* L) {
const char* str = luaL_checkstring(L, 1);
XBT_ERROR("%s", str);
return 0;
}
msg_error_t
MSG_mailbox_put_with_timeout(msg_mailbox_t mailbox, msg_task_t task,
double timeout)
{
msg_error_t ret = MSG_OK;
simdata_task_t t_simdata = NULL;
msg_process_t process = MSG_process_self();
simdata_process_t p_simdata = SIMIX_process_self_get_data(process);
int call_end = TRACE_msg_task_put_start(task); //must be after CHECK_HOST()
/* Prepare the task to send */
t_simdata = task->simdata;
t_simdata->sender = process;
t_simdata->source = ((simdata_process_t) SIMIX_process_self_get_data(process))->m_host;
if (t_simdata->isused != 0) {
if (msg_global->debug_multiple_use){
XBT_ERROR("This task is already used in there:");
xbt_backtrace_display(t_simdata->isused);
XBT_ERROR("And you try to reuse it from here:");
xbt_backtrace_display_current();
} else {
xbt_assert(t_simdata->isused == 0,
"This task is still being used somewhere else. You cannot send it now. Go fix your code! (use --cfg=msg/debug_multiple_use:on to get the backtrace of the other process)");
}
}
if (msg_global->debug_multiple_use)
MSG_BT(t_simdata->isused, "Using Backtrace");
else
t_simdata->isused = (void*)1;
t_simdata->comm = NULL;
msg_global->sent_msg++;
p_simdata->waiting_task = task;
xbt_ex_t e;
/* Try to send it by calling SIMIX network layer */
TRY {
smx_synchro_t comm = NULL; /* MC needs the comm to be set to NULL during the simix call */
comm = simcall_comm_isend(SIMIX_process_self(), mailbox,t_simdata->bytes_amount,
t_simdata->rate, task, sizeof(void *),
NULL, NULL, NULL, task, 0);
if (TRACE_is_enabled())
simcall_set_category(comm, task->category);
t_simdata->comm = comm;
simcall_comm_wait(comm, timeout);
}
CATCH(e) {
switch (e.category) {
case cancel_error:
ret = MSG_HOST_FAILURE;
break;
case network_error:
ret = MSG_TRANSFER_FAILURE;
break;
case timeout_error:
ret = MSG_TIMEOUT;
break;
default:
RETHROW;
}
xbt_ex_free(e);
/* If the send failed, it is not used anymore */
if (msg_global->debug_multiple_use && t_simdata->isused!=0)
xbt_ex_free(*(xbt_ex_t*)t_simdata->isused);
t_simdata->isused = 0;
}
p_simdata->waiting_task = NULL;
if (call_end)
TRACE_msg_task_put_end();
MSG_RETURN(ret);
}
int main(int argc, char **argv) {
unsigned int flag, cursor, cursor2;
char *platform_file = NULL, *daxname = NULL, *priority=NULL;
int total_nworkstations = 0;
const SD_workstation_t *workstations = NULL;
xbt_dynar_t daxes = NULL, current_dax = NULL;
int completed_daxes = 0;
SD_task_t task;
scheduling_globals_t globals;
WorkstationAttribute attr;
double total_cost = 0.0, score = 0.0;
SD_init(&argc, argv);
/* get rid off some logs that are useless */
xbt_log_control_set("sd_daxparse.thresh:critical");
xbt_log_control_set("surf_workstation.thresh:critical");
xbt_log_control_set("root.fmt:[%9.3r]%e[%13c/%7p]%e%m%n");
globals = new_scheduling_globals();
daxes = xbt_dynar_new(sizeof(xbt_dynar_t), NULL);
opterr = 0;
while (1){
static struct option long_options[] = {
{"alg", 1, 0, 'a'},
{"platform", 1, 0, 'b'},
{"dax", 1, 0, 'c'},
{"priority", 1, 0, 'd'},
{"deadline", 1, 0, 'e'},
{"budget", 1, 0, 'f'},
{"price", 1, 0, 'g'},
{"period", 1, 0, 'h'},
{"uh", 1, 0, 'i'},
{"ul", 1, 0, 'j'},
{"provisioning_delay", 1, 0, 'k'},
{"silent", 0, 0, 'y'},
{"dump", 1, 0, 'z'},
{0, 0, 0, 0}
};
int option_index = 0;
flag = getopt_long (argc, argv, "",
long_options, &option_index);
/* Detect the end of the options. */
if (flag == -1)
break;
switch (flag) {
case 0:
/* If this option set a flag, do nothing else now. */
if (long_options[option_index].flag != 0)
break;
printf ("option %s", long_options[option_index].name);
if (optarg)
printf (" with arg %s", optarg);
printf ("\n");
break;
case 'a': /* Algorithm name */
/* DPDS, WA-DPDS, SPSS, Ours*/
globals->alg = getAlgorithmByName(optarg);
break;
case 'b':
platform_file = optarg;
SD_create_environment(platform_file);
total_nworkstations = SD_workstation_get_number();
workstations = SD_workstation_get_list();
/* Sort the hosts by name for sake of simplicity */
qsort((void *)workstations,total_nworkstations, sizeof(SD_workstation_t),
nameCompareWorkstations);
for(cursor=0; cursor<total_nworkstations; cursor++){
SD_workstation_allocate_attribute(workstations[cursor]);
}
break;
case 'c':
/* List of DAGs to schedule concurrently (just file names here) */
daxname = optarg;
XBT_DEBUG("Loading %s", daxname);
current_dax = SD_daxload(daxname);
xbt_dynar_foreach(current_dax,cursor,task) {
if (SD_task_get_kind(task) == SD_TASK_COMP_SEQ){
SD_task_watch(task, SD_DONE);
}
SD_task_allocate_attribute(task);
SD_task_set_dax_name(task, daxname);
}
xbt_dynar_push(daxes,¤t_dax);
break;
case 'd':
priority = optarg;
if (!strcmp(priority,"random"))
globals->priority_method = RANDOM;
else if (!strcmp(priority, "sorted"))
globals->priority_method = SORTED;
else {
XBT_ERROR("Unknown priority setting method.");
exit(1);
}
break;
case 'e':
globals->deadline = atof(optarg);
break;
case 'f':
globals->budget = atof(optarg);
break;
case 'g':
globals->price = atof(optarg);
break;
case 'h':
globals->period = atof(optarg);
break;
case 'i':
globals->uh = atof(optarg);
break;
case 'j':
globals->ul = atof(optarg);
break;
case 'k':
globals->provisioning_delay = atof(optarg);
break;
case 'y':
xbt_log_control_set("root.thresh:critical");
break;
case 'z':
break;
}
}
/* Display some information about the current run */
XBT_INFO("Algorithm: %s",getAlgorithmName(globals->alg));
XBT_INFO(" Priority method: %s",
globals->priority_method ? "SORTED" : "RANDOM");
XBT_INFO(" Dynamic provisioning period: %.0fs", globals->period);
XBT_INFO(" Lower utilization threshold: %.2f%%", globals->ul);
XBT_INFO(" Upper utilization threshold: %.2f%%", globals->uh);
XBT_INFO("Platform: %s (%d potential VMs)", platform_file,
SD_workstation_get_number());
XBT_INFO(" VM hourly cost: $%f", globals->price);
XBT_INFO(" VM provisioning delay: %.0fs", globals->provisioning_delay);
if (ceil(globals->budget/((globals->deadline/3600.)*globals->price))>
SD_workstation_get_number()){
XBT_ERROR("The platform file doesn't have enough nodes. Stop here");
exit(1);
}
/* Assign price and provisioning delay to workstation/VM (for the sake of
* simplicity) */
for(cursor=0; cursor<total_nworkstations; cursor++){
SD_workstation_set_price(workstations[cursor], globals->price);
SD_workstation_set_provisioning_delay(workstations[cursor],
globals->provisioning_delay);
}
XBT_INFO("Ensemble: %lu DAXes", xbt_dynar_length(daxes));
/* Assign priorities to the DAXes composing the ensemble according to the
* chosen method: RANDOM (default) or SORTED.
* Then display the result.
*/
assign_dax_priorities(daxes, globals->priority_method);
xbt_dynar_foreach(daxes, cursor, current_dax){
task = get_root(current_dax);
XBT_INFO(" %s", SD_task_get_dax_name(task));
XBT_INFO(" Priority: %d", SD_task_get_dax_priority(task));
}
int main(int argc, char **argv)
{
int i;
unsigned int ctr;
const char *platform_file;
const SD_workstation_t *workstations;
const char *name1;
const char *name2;
double computation_amount1;
double computation_amount2;
double communication_amount12;
double communication_amount21;
const SD_link_t *route;
int route_size;
SD_task_t task, taskA, taskB, taskC, taskD, checkB, checkD;
xbt_dynar_t changed_tasks;
xbt_ex_t ex;
const int workstation_number = 2;
SD_workstation_t workstation_list[2];
double computation_amount[2];
double communication_amount[4] = { 0 };
double rate = -1.0;
SD_workstation_t w1, w2;
/* initialization of SD */
SD_init(&argc, argv);
/* xbt_log_control_set("sd.thres=debug"); */
if (argc < 2) {
XBT_INFO("Usage: %s platform_file", argv[0]);
XBT_INFO("example: %s sd_platform.xml", argv[0]);
exit(1);
}
/* creation of the environment */
platform_file = argv[1];
SD_create_environment(platform_file);
/* test the estimation functions */
workstations = SD_workstation_get_list();
w1 = workstations[0];
w2 = workstations[1];
SD_workstation_set_access_mode(w2, SD_WORKSTATION_SEQUENTIAL_ACCESS);
name1 = SD_workstation_get_name(w1);
name2 = SD_workstation_get_name(w2);
computation_amount1 = 2000000;
computation_amount2 = 1000000;
communication_amount12 = 2000000;
communication_amount21 = 3000000;
XBT_INFO("Computation time for %f flops on %s: %f", computation_amount1,
name1, SD_workstation_get_computation_time(w1,
computation_amount1));
XBT_INFO("Computation time for %f flops on %s: %f", computation_amount2,
name2, SD_workstation_get_computation_time(w2,
computation_amount2));
XBT_INFO("Route between %s and %s:", name1, name2);
route = SD_route_get_list(w1, w2);
route_size = SD_route_get_size(w1, w2);
for (i = 0; i < route_size; i++) {
XBT_INFO(" Link %s: latency = %f, bandwidth = %f",
SD_link_get_name(route[i]),
SD_link_get_current_latency(route[i]),
SD_link_get_current_bandwidth(route[i]));
}
XBT_INFO("Route latency = %f, route bandwidth = %f",
SD_route_get_current_latency(w1, w2),
SD_route_get_current_bandwidth(w1, w2));
XBT_INFO("Communication time for %f bytes between %s and %s: %f",
communication_amount12, name1, name2,
SD_route_get_communication_time(w1, w2, communication_amount12));
XBT_INFO("Communication time for %f bytes between %s and %s: %f",
communication_amount21, name2, name1,
SD_route_get_communication_time(w2, w1, communication_amount21));
/* creation of the tasks and their dependencies */
taskA = SD_task_create("Task A", NULL, 10.0);
taskB = SD_task_create("Task B", NULL, 40.0);
taskC = SD_task_create("Task C", NULL, 30.0);
taskD = SD_task_create("Task D", NULL, 60.0);
/* try to attach and retrieve user data to a task */
SD_task_set_data(taskA, (void*) &computation_amount1);
if (computation_amount1 != (*((double*) SD_task_get_data(taskA))))
XBT_ERROR("User data was corrupted by a simple set/get");
SD_task_dependency_add(NULL, NULL, taskB, taskA);
SD_task_dependency_add(NULL, NULL, taskC, taskA);
SD_task_dependency_add(NULL, NULL, taskD, taskB);
SD_task_dependency_add(NULL, NULL, taskD, taskC);
/* SD_task_dependency_add(NULL, NULL, taskA, taskD); /\* deadlock */
TRY {
SD_task_dependency_add(NULL, NULL, taskA, taskA); /* shouldn't work and must raise an exception */
xbt_die("Hey, I can add a dependency between Task A and Task A!");
}
CATCH(ex) {
if (ex.category != arg_error)
RETHROW; /* this is a serious error */
xbt_ex_free(ex);
}
TRY {
SD_task_dependency_add(NULL, NULL, taskB, taskA); /* shouldn't work and must raise an exception */
xbt_die("Oh oh, I can add an already existing dependency!");
}
CATCH(ex) {
if (ex.category != arg_error)
RETHROW;
xbt_ex_free(ex);
}
TRY {
SD_task_dependency_remove(taskA, taskC); /* shouldn't work and must raise an exception */
xbt_die("Dude, I can remove an unknown dependency!");
}
CATCH(ex) {
if (ex.category != arg_error)
RETHROW;
xbt_ex_free(ex);
}
TRY {
SD_task_dependency_remove(taskC, taskC); /* shouldn't work and must raise an exception */
xbt_die("Wow, I can remove a dependency between Task C and itself!");
}
CATCH(ex) {
if (ex.category != arg_error)
RETHROW;
xbt_ex_free(ex);
}
/* if everything is ok, no exception is forwarded or rethrown by main() */
/* watch points */
SD_task_watch(taskD, SD_DONE);
SD_task_watch(taskB, SD_DONE);
SD_task_unwatch(taskD, SD_DONE);
/* scheduling parameters */
workstation_list[0] = w1;
workstation_list[1] = w2;
computation_amount[0] = computation_amount1;
computation_amount[1] = computation_amount2;
communication_amount[1] = communication_amount12;
communication_amount[2] = communication_amount21;
/* estimated time */
task = taskD;
XBT_INFO("Estimated time for '%s': %f", SD_task_get_name(task),
SD_task_get_execution_time(task, workstation_number,
workstation_list, computation_amount,
communication_amount));
/* let's launch the simulation! */
SD_task_schedule(taskA, workstation_number, workstation_list,
computation_amount, communication_amount, rate);
SD_task_schedule(taskB, workstation_number, workstation_list,
computation_amount, communication_amount, rate);
SD_task_schedule(taskC, workstation_number, workstation_list,
computation_amount, communication_amount, rate);
SD_task_schedule(taskD, workstation_number, workstation_list,
computation_amount, communication_amount, rate);
changed_tasks = SD_simulate(-1.0);
xbt_dynar_foreach(changed_tasks, ctr, 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));
}
xbt_dynar_t SD_dotload_generic(const char* filename, bool sequential, bool schedule)
{
xbt_assert(filename, "Unable to use a null file descriptor\n");
FILE *in_file = fopen(filename, "r");
xbt_assert(in_file != nullptr, "Failed to open file: %s", filename);
SD_task_t root;
SD_task_t end;
SD_task_t task;
std::vector<SD_task_t>* computer;
std::unordered_map<std::string, std::vector<SD_task_t>*> computers;
bool schedule_success = true;
std::unordered_map<std::string, SD_task_t> jobs;
xbt_dynar_t result = xbt_dynar_new(sizeof(SD_task_t), dot_task_p_free);
Agraph_t * dag_dot = agread(in_file, NIL(Agdisc_t *));
/* Create all the nodes */
Agnode_t *node = nullptr;
for (node = agfstnode(dag_dot); node; node = agnxtnode(dag_dot, node)) {
char *name = agnameof(node);
double amount = atof(agget(node, (char*)"size"));
if (jobs.find(name) == jobs.end()) {
if (sequential) {
XBT_DEBUG("See <job id=%s amount =%.0f>", name, amount);
task = SD_task_create_comp_seq(name, nullptr , amount);
} else {
double alpha = atof(agget(node, (char *) "alpha"));
XBT_DEBUG("See <job id=%s amount =%.0f alpha = %.3f>", name, amount, alpha);
task = SD_task_create_comp_par_amdahl(name, nullptr , amount, alpha);
}
jobs.insert({std::string(name), task});
if (strcmp(name,"root") && strcmp(name,"end"))
xbt_dynar_push(result, &task);
if ((sequential) &&
((schedule && schedule_success) || XBT_LOG_ISENABLED(sd_dotparse, xbt_log_priority_verbose))) {
/* try to take the information to schedule the task only if all is right*/
char *char_performer = agget(node, (char *) "performer");
char *char_order = agget(node, (char *) "order");
/* Tasks will execute on in a given "order" on a given set of "performer" hosts */
int performer = ((not char_performer || not strcmp(char_performer, "")) ? -1 : atoi(char_performer));
int order = ((not char_order || not strcmp(char_order, "")) ? -1 : atoi(char_order));
if ((performer != -1 && order != -1) && performer < static_cast<int>(sg_host_count())) {
/* required parameters are given and less performers than hosts are required */
XBT_DEBUG ("Task '%s' is scheduled on workstation '%d' in position '%d'", task->name, performer, order);
auto comp = computers.find(char_performer);
if (comp != computers.end()) {
computer = comp->second;
} else {
computer = new std::vector<SD_task_t>;
computers.insert({char_performer, computer});
}
if (static_cast<unsigned int>(order) < computer->size()) {
SD_task_t task_test = computer->at(order);
if (task_test && task_test != task) {
/* the user gave the same order to several tasks */
schedule_success = false;
XBT_VERB("Task '%s' wants to start on performer '%s' at the same position '%s' as task '%s'",
task_test->name, char_performer, char_order, task->name);
continue;
}
} else
computer->resize(order);
computer->insert(computer->begin() + order, task);
} else {
/* one of required parameters is not given */
schedule_success = false;
XBT_VERB("The schedule is ignored, task '%s' can not be scheduled on %d hosts", task->name, performer);
}
}
} else {
XBT_WARN("Task '%s' is defined more than once", name);
}
}
/*Check if 'root' and 'end' nodes have been explicitly declared. If not, create them. */
if (jobs.find("root") == jobs.end())
root = (sequential ? SD_task_create_comp_seq("root", nullptr, 0)
: SD_task_create_comp_par_amdahl("root", nullptr, 0, 0));
else
root = jobs.at("root");
SD_task_set_state(root, SD_SCHEDULABLE); /* by design the root task is always SCHEDULABLE */
xbt_dynar_insert_at(result, 0, &root); /* Put it at the beginning of the dynar */
if (jobs.find("end") == jobs.end())
end = (sequential ? SD_task_create_comp_seq("end", nullptr, 0)
: SD_task_create_comp_par_amdahl("end", nullptr, 0, 0));
else
end = jobs.at("end");
/* Create edges */
std::vector<Agedge_t*> edges;
for (node = agfstnode(dag_dot); node; node = agnxtnode(dag_dot, node)) {
edges.clear();
for (Agedge_t* edge = agfstout(dag_dot, node); edge; edge = agnxtout(dag_dot, edge))
edges.push_back(edge);
/* Be sure edges are sorted */
std::sort(edges.begin(), edges.end(), [](const Agedge_t* a, const Agedge_t* b) { return AGSEQ(a) < AGSEQ(b); });
for (Agedge_t* edge : edges) {
char *src_name=agnameof(agtail(edge));
char *dst_name=agnameof(aghead(edge));
double size = atof(agget(edge, (char *) "size"));
SD_task_t src = jobs.at(src_name);
SD_task_t dst = jobs.at(dst_name);
if (size > 0) {
std::string name = std::string(src_name) + "->" + dst_name;
XBT_DEBUG("See <transfer id=%s amount = %.0f>", name.c_str(), size);
if (jobs.find(name) == jobs.end()) {
if (sequential)
task = SD_task_create_comm_e2e(name.c_str(), nullptr, size);
else
task = SD_task_create_comm_par_mxn_1d_block(name.c_str(), nullptr, size);
SD_task_dependency_add(src, task);
SD_task_dependency_add(task, dst);
jobs.insert({name, task});
xbt_dynar_push(result, &task);
} else {
XBT_WARN("Task '%s' is defined more than once", name.c_str());
}
} else {
SD_task_dependency_add(src, dst);
}
}
}
XBT_DEBUG("All tasks have been created, put %s at the end of the dynar", end->name);
xbt_dynar_push(result, &end);
/* Connect entry tasks to 'root', and exit tasks to 'end'*/
unsigned i;
xbt_dynar_foreach (result, i, task){
if (task->predecessors->empty() && task->inputs->empty() && task != root) {
XBT_DEBUG("Task '%s' has no source. Add dependency from 'root'", task->name);
SD_task_dependency_add(root, task);
}
if (task->successors->empty() && task->outputs->empty() && task != end) {
XBT_DEBUG("Task '%s' has no destination. Add dependency to 'end'", task->name);
SD_task_dependency_add(task, end);
}
}
agclose(dag_dot);
fclose(in_file);
if(schedule){
if (schedule_success) {
std::vector<simgrid::s4u::Host*> hosts = simgrid::s4u::Engine::get_instance()->get_all_hosts();
for (auto const& elm : computers) {
SD_task_t previous_task = nullptr;
for (auto const& cur_task : *elm.second) {
/* add dependency between the previous and the task to avoid parallel execution */
if (cur_task) {
if (previous_task && not SD_task_dependency_exists(previous_task, cur_task))
SD_task_dependency_add(previous_task, cur_task);
SD_task_schedulel(cur_task, 1, hosts[std::stod(elm.first)]);
previous_task = cur_task;
}
}
delete elm.second;
}
} else {
XBT_WARN("The scheduling is ignored");
for (auto const& elm : computers)
delete elm.second;
xbt_dynar_free(&result);
result = nullptr;
}
}
if (result && not acyclic_graph_detail(result)) {
std::string base = simgrid::xbt::Path(filename).get_base_name();
XBT_ERROR("The DOT described in %s is not a DAG. It contains a cycle.", base.c_str());
xbt_dynar_free(&result);
result = nullptr;
}
return result;
}
int main(int argc, char **argv)
{
int i;
const char *platform_file;
const SD_workstation_t *workstations;
int kind;
SD_task_t task, taskA, taskB, taskC;
xbt_dynar_t changed_tasks;
SD_workstation_t workstation_list[2];
double computation_amount[2];
double communication_amount[4] = { 0 };
double rate = -1.0;
SD_workstation_t w1, w2;
/* SD initialization */
SD_init(&argc, argv);
/* xbt_log_control_set("sd.thres=debug"); */
if (argc < 2) {
XBT_INFO("Usage: %s platform_file", argv[0]);
XBT_INFO("example: %s sd_platform.xml", argv[0]);
exit(1);
}
/* creation of the environment */
platform_file = argv[1];
SD_create_environment(platform_file);
/* Change the access mode of the workstations */
workstations = SD_workstation_get_list();
w1 = workstations[0];
w2 = workstations[1];
for (i = 0; i < 2; i++) {
SD_workstation_set_access_mode(workstations[i],
SD_WORKSTATION_SEQUENTIAL_ACCESS);
XBT_INFO("Access mode of %s is %s",
SD_workstation_get_name(workstations[i]),
(SD_workstation_get_access_mode(workstations[i]) ==
SD_WORKSTATION_SEQUENTIAL_ACCESS) ? "sequential" : "shared");
}
/* creation of the tasks and their dependencies */
taskA = SD_task_create_comp_seq("Task A", NULL, 2e9);
taskB = SD_task_create_comm_e2e("Task B", NULL, 2e9);
taskC = SD_task_create_comp_seq("Task C", NULL, 1e9);
TRACE_category ("taskA");
TRACE_category ("taskB");
TRACE_category ("taskC");
TRACE_sd_set_task_category (taskA, "taskA");
TRACE_sd_set_task_category (taskB, "taskB");
TRACE_sd_set_task_category (taskC, "taskC");
/* if everything is ok, no exception is forwarded or rethrown by main() */
/* watch points */
SD_task_watch(taskA, SD_RUNNING);
SD_task_watch(taskB, SD_RUNNING);
SD_task_watch(taskC, SD_RUNNING);
SD_task_watch(taskC, SD_DONE);
/* scheduling parameters */
workstation_list[0] = w1;
workstation_list[1] = w2;
computation_amount[0] = SD_task_get_amount(taskA);
computation_amount[1] = SD_task_get_amount(taskB);
communication_amount[1] = SD_task_get_amount(taskC);
communication_amount[2] = 0.0;
SD_task_schedule(taskA, 1, &w1,
&(computation_amount[0]), SD_SCHED_NO_COST, rate);
SD_task_schedule(taskB, 2, workstation_list,
SD_SCHED_NO_COST, communication_amount, rate);
SD_task_schedule(taskC, 1, &w1,
&(computation_amount[1]), SD_SCHED_NO_COST, rate);
/* let's launch the simulation! */
while (!xbt_dynar_is_empty(changed_tasks = SD_simulate(-1.0))) {
for (i = 0; i < 2; i++) {
task = SD_workstation_get_current_task(workstations[i]);
if (task)
kind = SD_task_get_kind(task);
else {
XBT_INFO("There is no task running on %s",
SD_workstation_get_name(workstations[i]));
continue;
}
switch (kind) {
case SD_TASK_COMP_SEQ:
XBT_INFO("%s is currently running on %s (SD_TASK_COMP_SEQ)",
SD_task_get_name(task),
SD_workstation_get_name(workstations[i]));
break;
case SD_TASK_COMM_E2E:
XBT_INFO("%s is currently running on %s (SD_TASK_COMM_E2E)",
SD_task_get_name(task),
SD_workstation_get_name(workstations[i]));
break;
case SD_TASK_NOT_TYPED:
XBT_INFO("Task running on %s has no type",
SD_workstation_get_name(workstations[i]));
break;
default:
XBT_ERROR("Shouldn't be here");
}
}
xbt_dynar_free_container(&changed_tasks);
}
xbt_dynar_free_container(&changed_tasks);
XBT_DEBUG("Destroying tasks...");
SD_task_destroy(taskA);
SD_task_destroy(taskB);
SD_task_destroy(taskC);
XBT_DEBUG("Tasks destroyed. Exiting SimDag...");
SD_exit();
return 0;
}
void AsNone::getGraph(xbt_graph_t /*graph*/, xbt_dict_t /*nodes*/, xbt_dict_t /*edges*/)
{
XBT_ERROR("No routing no graph");
}
