int main(int argc, char *argv[])
{
  MSG_init(&argc, argv);
  xbt_assert(argc > 2, "Usage: %s platform_file deployment_file\n"
             "\tExample: %s msg_platform.xml msg_deployment.xml\n", argv[0], argv[0]);

  MSG_create_environment(argv[1]);

  //declaring user variables
  TRACE_host_variable_declare("HDD_capacity");
  TRACE_host_variable_declare("HDD_utilization");

  //register functions and launch deployment
  MSG_function_register("master", trace_fun);
  MSG_function_register("worker", trace_fun);
  MSG_launch_application(argv[2]);

  MSG_main();

  //get user declared variables
  unsigned int cursor;
  char *variable;
  xbt_dynar_t host_variables = TRACE_get_host_variables ();
  if (host_variables){
    XBT_INFO ("Declared host variables:");
    xbt_dynar_foreach (host_variables, cursor, variable){
      XBT_INFO ("%s", variable);
    }
    xbt_dynar_free (&host_variables);
  }

int main(int argc, char *argv[]) {
  msg_error_t res = MSG_OK;

  MSG_init(&argc, argv);
  /* Explicit initialization of the action module is required now*/
  MSG_action_init();

  xbt_assert(argc > 3,"Usage: %s platform_file deployment_file [action_files]\n"
             "\texample: %s platform.xml deployment.xml actions # if all actions are in the same file\n"
             "\texample: %s platform.xml deployment.xml # if actions are in separate files, specified in deployment\n",
             argv[0], argv[0], argv[0]);

  MSG_create_environment(argv[1]);
  MSG_launch_application(argv[2]);

  /*   Action registration */
  xbt_replay_action_register("open", action_open);
  xbt_replay_action_register("read", action_read);
  xbt_replay_action_register("close", action_close);

  if (!opened_files)
    opened_files = xbt_dict_new_homogeneous(NULL);
  /* Actually do the simulation using MSG_action_trace_run */
  res = MSG_action_trace_run(argv[3]);  // it's ok to pass a NULL argument here

  XBT_INFO("Simulation time %g", MSG_get_clock());

  if (opened_files)
    xbt_dict_free(&opened_files);

  /* Explicit finalization of the action module is required now*/
  MSG_action_exit();

  return res!=MSG_OK;
}

/** Main function */
int main(int argc, char *argv[])
{
  MSG_init(&argc, argv);
  if (argc < 3) {
    printf("Usage: %s platform_file deployment_file\n", argv[0]);
    exit(1);
  }

  char *platform_file = argv[1];
  char *deployment_file = argv[2];
  MSG_create_environment(platform_file);

  //declaring user variables
  TRACE_host_variable_declare("HDD_capacity");
  TRACE_host_variable_declare("HDD_utilization");

  //register functions and launch deployment
  MSG_function_register("master", master);
  MSG_function_register("slave", master);
  MSG_launch_application(deployment_file);

  MSG_main();

  //get user declared variables
  unsigned int cursor;
  char *variable;
  xbt_dynar_t host_variables = TRACE_get_host_variables ();
  if (host_variables){
    XBT_INFO ("Declared host variables:");
    xbt_dynar_foreach (host_variables, cursor, variable){
      XBT_INFO ("%s", variable);
    }
    xbt_dynar_free (&host_variables);
  }

int main(int argc, char **argv)
{
  int i;
  msg_error_t res = MSG_OK;

  MSG_init(&argc, argv);
  surf_parse = surf_parse_bypass_platform;
  MSG_create_environment(NULL);

  MSG_function_register("host", host);

  xbt_dynar_t hosts = MSG_hosts_as_dynar();
  nb_hosts =  xbt_dynar_length(hosts);

  XBT_INFO("Number of host '%d'",nb_hosts);
  for(i = 0 ; i<nb_hosts; i++)
  {
    char* name_host = bprintf("%d",i);
    MSG_process_create( name_host, host, NULL, xbt_dynar_get_as(hosts,i,msg_host_t) );
    free(name_host);
  }
  xbt_dynar_free(&hosts);

  res = MSG_main();
  XBT_INFO("Simulation time %g", MSG_get_clock());

  if (res == MSG_OK)
    return 0;
  else
    return 1;

}

/**
 * Bittorrent example launcher
 */
int main(int argc, char *argv[])
{
  xbt_dynar_t host_list;
  msg_host_t host;
  unsigned i;

  MSG_init(&argc, argv);

  /* Check the arguments */
  if (argc < 3) {
    printf("Usage: %s platform_file deployment_file \n", argv[0]);
    return -1;
  }

  const char *platform_file = argv[1];
  const char *deployment_file = argv[2];

  MSG_create_environment(platform_file);

  host_list = MSG_hosts_as_dynar();
  xbt_dynar_foreach(host_list, i, host) {
    char descr[512];
    RngStream stream;
    snprintf(descr, sizeof descr, "RngSream<%s>", MSG_host_get_name(host));
    stream = RngStream_CreateStream(descr);
    MSG_host_set_data(host, stream);
  }

int main(int argc, char *argv[])
{
  msg_error_t res = MSG_OK;

#ifdef _MSC_VER
  unsigned int prev_exponent_format =
      _set_output_format(_TWO_DIGIT_EXPONENT);
#endif


  MSG_init(&argc, argv);
  if (argc < 3) {
    printf("Usage: %s platform_file deployment_file\n", argv[0]);
    printf("example: %s msg_platform.xml msg_deployment.xml\n", argv[0]);
    exit(1);
  }
  res = test_all(argv[1], argv[2]);

#ifdef _MSC_VER
  _set_output_format(prev_exponent_format);
#endif

  if (res == MSG_OK)
    return 0;
  else
    return 1;
}

int main(int argc, char *argv[])
{
  msg_error_t res = MSG_OK;
  sg_energy_plugin_init();
  MSG_init(&argc, argv);

  if (argc != 3) {
    XBT_CRITICAL("Usage: %s platform_file deployment_file\n",
              argv[0]);
    XBT_CRITICAL
        ("example: %s msg_platform.xml msg_deployment.xml\n",
         argv[0]);
    exit(1);
  }

  MSG_create_environment(argv[1]);

  /*   Application deployment */
  MSG_function_register("dvfs_test", dvfs);

  MSG_launch_application(argv[2]);

  res = MSG_main();

  XBT_INFO("Total simulation time: %e", MSG_get_clock());

  if (res == MSG_OK)
    return 0;
  else
    return 1;
}

int main(int argc, char *argv[])
{
  msg_error_t res = MSG_OK;

  MSG_init(&argc, argv);

  MSG_create_environment(argv[1]);

  /* Trace categories */
  TRACE_category_with_color("host0", "0 0 1");
  TRACE_category_with_color("host1", "0 1 0");
  TRACE_category_with_color("host2", "0 1 1");
  TRACE_category_with_color("host3", "1 0 0");
  TRACE_category_with_color("host4", "1 0 1");
  TRACE_category_with_color("host5", "0 0 0");
  TRACE_category_with_color("host6", "1 1 0");
  TRACE_category_with_color("host7", "1 1 1");
  TRACE_category_with_color("host8", "0 1 0");

  /*   Application deployment */
  MSG_function_register("broadcaster", broadcaster);
  MSG_function_register("peer", peer);

  MSG_launch_application(argv[2]);

  res = MSG_main();

  XBT_INFO("Total simulation time: %e", MSG_get_clock());

  return res != MSG_OK;
}

int MRSG_main (const char* plat, const char* depl, const char* conf)
{
    char* argv[] = {
	"mrsg",
	"--cfg=tracing:1",
	"--cfg=tracing/buffer:1",
	"--cfg=tracing/filename:tracefile.trace",
	"--cfg=tracing/categorized:1",
	"--cfg=tracing/uncategorized:1",
	"--cfg=viva/categorized:cat.plist",
	"--cfg=viva/uncategorized:uncat.plist"
    };
    int argc = sizeof(argv)/sizeof(argv[0]);

    msg_error_t  res = MSG_OK;

    config.initialized = 0;

    check_config ();

    MSG_init (&argc, argv);
    res = run_simulation (plat, depl, conf);

    if (res == MSG_OK)
	return 0;
    else
	return 1;
}

/** Main function */
int main(int argc, char *argv[])
{
    msg_error_t res = MSG_OK;

    /* Argument checking */
    MSG_init(&argc, argv);
    if (argc < 3) {
        XBT_CRITICAL("Usage: %s platform_file deployment_file\n", argv[0]);
        XBT_CRITICAL("example: %s msg_platform.xml msg_deployment_suspend.xml\n",
                     argv[0]);
        exit(1);
    }

    /* Simulation setting */
    MSG_create_environment(argv[1]);

    /* Application deployment */
    MSG_function_register("emigrant", emigrant);
    MSG_function_register("policeman", policeman);
    MSG_launch_application(argv[2]);

    /* Run the simulation */
    mutex = xbt_mutex_init();
    cond = xbt_cond_init();
    res = MSG_main();
    XBT_INFO("Simulation time %g", MSG_get_clock());
    xbt_cond_destroy(cond);
    xbt_mutex_destroy(mutex);

    if (res == MSG_OK)
        return 0;
    else
        return 1;
}                               /* end_of_main */

/** Main function */
int main(int argc, char *argv[])
{
  root_id = std::this_thread::get_id();

  SIMIX_set_maestro(maestro, NULL);
  MSG_init(&argc, argv);

  if (argc != 2) {
    XBT_CRITICAL("Usage: %s platform_file\n", argv[0]);
    xbt_die("example: %s msg_platform.xml\n",argv[0]);
  }

  MSG_create_environment(argv[1]);

  /* Become one of the simulated process.
   *
   * This must be done after the creation of the platform because we are depending attaching to a host.*/
  MSG_process_attach("sender", NULL, MSG_host_by_name("Tremblay"), NULL);
  ensure_root_tid();

  // Execute the sender code:
  const char* subargv[3] = { "sender", "Jupiter", NULL };
  sender(2, (char**) subargv);

  MSG_process_detach(); // Become root thread again
  XBT_INFO("Detached");
  ensure_root_tid();

  return 0;
}

int MRA_main (const char* plat, const char* depl, const char* conf, const char* trace_vc)
{
    int argc = 8;
    char* argv[] = {
	"mra",
	"--cfg=tracing:1",
	"--cfg=tracing/buffer:1",
	"--cfg=tracing/filename:tracefile.trace",
	"--cfg=tracing/categorized:1",
	"--cfg=tracing/uncategorized:1",
	"--cfg=viva/categorized:cat.plist",
	"--cfg=viva/uncategorized:uncat.plist"
    };

    msg_error_t  res_mra = MSG_OK;

    config_mra.initialized = 0;

    check_config_mra ();

    MSG_init (&argc, argv);

    res_mra = run_mra_simulation (plat, depl, conf, trace_vc);

    if (res_mra == MSG_OK)
	return 0;
    else
	return 1;
}

/** Main function */
int main(int argc, char *argv[])
{
  msg_error_t res = MSG_OK;

  /* Check the given arguments */
  MSG_init(&argc, argv);
  /* Explicit initialization of the action module is required now*/
  MSG_action_init();

  if (argc < 3) {
    printf("Usage: %s platform_file deployment_file [action_files]\n", argv[0]);
    printf
        ("example: %s msg_platform.xml msg_deployment.xml actions # if all actions are in the same file\n",
         argv[0]);
    printf
        ("example: %s msg_platform.xml msg_deployment.xml # if actions are in separate files, specified in deployment\n",
         argv[0]);
    exit(1);
  }
  printf("WARNING: THIS BINARY IS KINDA DEPRECATED\n"
	 "This example is still relevant if you want to learn about MSG-based trace replay, "
	 "but if you want to simulate MPI-like traces, you should use the newer version "
	 "that is in the examples/smpi/replay directory instead.\n");
   
  /*  Simulation setting */
  MSG_create_environment(argv[1]);

  /* No need to register functions as in classical MSG programs: the actions get started anyway */
  MSG_launch_application(argv[2]);

  /*   Action registration */
  xbt_replay_action_register("init", action_init);
  xbt_replay_action_register("finalize", action_finalize);
  xbt_replay_action_register("comm_size", action_comm_size);
  xbt_replay_action_register("send", action_send);
  xbt_replay_action_register("Isend", action_Isend);
  xbt_replay_action_register("recv", action_recv);
  xbt_replay_action_register("Irecv", action_Irecv);
  xbt_replay_action_register("wait", action_wait);
  xbt_replay_action_register("barrier", action_barrier);
  xbt_replay_action_register("bcast", action_bcast);
  xbt_replay_action_register("reduce", action_reduce);
  xbt_replay_action_register("allReduce", action_allReduce);
  xbt_replay_action_register("sleep", action_sleep);
  xbt_replay_action_register("compute", action_compute);


  /* Actually do the simulation using MSG_action_trace_run */
  res = MSG_action_trace_run(argv[3]);  // it's ok to pass a NULL argument here

  XBT_INFO("Simulation time %g", MSG_get_clock());

  /* Explicit finalization of the action module is required now*/
  MSG_action_exit();

  if (res == MSG_OK)
    return 0;
  else
    return 1;
}                               /* end_of_main */

/**
 * \brief Main function.
 */
int main(int argc, char *argv[])
{
#ifdef BENCH_THIS_CODE
    xbt_os_cputimer_t timer = xbt_os_timer_new();
#endif

    MSG_init(&argc, argv);

    char **options = &argv[1];
    const char* platform_file = options[0];
    const char* application_file = options[1];

    MSG_create_environment(platform_file);

    MSG_function_register("node", node);
    MSG_launch_application(application_file);

#ifdef BENCH_THIS_CODE
    xbt_os_cputimer_start(timer);
#endif
    msg_error_t res = MSG_main();
#ifdef BENCH_THIS_CODE
    xbt_os_cputimer_stop(timer);
#endif
    XBT_CRITICAL("Simulated time: %g", MSG_get_clock());

    if (res == MSG_OK)
        return 0;
    else
        return 1;
}

int main(int argc, char **argv)
{
  int i,res;
  MSG_init(&argc, argv);
  MSG_create_environment(argv[1]);
  xbt_dynar_t hosts =  MSG_hosts_as_dynar();
  MSG_function_register("host", host);
  unsigned long nb_hosts = xbt_dynar_length(hosts);
  XBT_INFO("Number of host '%lu'",nb_hosts);
  for(i = 0 ; i<nb_hosts; i++)
  {
    char* name_host = bprintf("%d",i);
    MSG_process_create( name_host, host, NULL, xbt_dynar_get_as(hosts,i,msg_host_t) );
    free(name_host);
  }
  xbt_dynar_free(&hosts);

  res = MSG_main();
  XBT_INFO("Simulation time %g", MSG_get_clock());
  if (res == MSG_OK)
    return 0;
  else
    return 1;

}

int main(int argc, char *argv[])
{
  MSG_init(&argc, argv);
  if (argc != 3) {
    printf("Usage: %s platform_file deployment_file\n", argv[0]);
    printf("example: %s msg_platform.xml msg_deployment.xml\n", argv[0]);
    exit(1);
  }
  const char *platform_file = argv[1];
  const char *application_file = argv[2];
  MSG_create_environment(platform_file);
  MSG_function_register("receiver", receiver);
  MSG_function_register("sender", sender);

  MSG_launch_application(application_file);
#ifndef DISABLE_THE_MUTEX
  mutex = xbt_mutex_init();
#endif
  msg_error_t res = MSG_main();
#ifndef DISABLE_THE_MUTEX
  xbt_mutex_destroy(mutex); mutex = NULL;
#endif
  XBT_INFO("Simulation time %g", MSG_get_clock());

  if (res == MSG_OK)
    return 0;
  else
    return 1;
}

/** Main function */
int main(int argc, char *argv[])
{
  msg_error_t res;
  const char *platform_file;
  const char *application_file;

  MSG_init(&argc, argv);
  if (argc != 3) {
    printf("Usage: %s platform_file deployment_file\n", argv[0]);
    printf("example: %s msg_platform.xml msg_deployment.xml\n", argv[0]);
    exit(1);
  }
  platform_file = argv[1];
  application_file = argv[2];

  {                             /*  Simulation setting */
    MSG_create_environment(platform_file);
  }
  {                             /*   Application deployment */
    MSG_function_register("master", master);
    MSG_function_register("slave", slave);

    MSG_launch_application(application_file);
  }
  res = MSG_main();

  XBT_INFO("Simulation time %g", MSG_get_clock());

  if (res == MSG_OK)
    return 0;
  else
    return 1;
}                               /* end_of_main */

/** Main function */
int main(int argc, char *argv[])
{
  MSG_init(&argc, argv);
  MSG_function_register("app", &app);
  MSG_create_environment(argv[1]);
  MSG_process_create("app", app, NULL, MSG_get_host_by_name("Tremblay"));
  return MSG_main();
}

/** Main function */
int main(int argc, char *argv[])
{
  MSG_init(&argc, argv);
  MSG_function_register("app", &app);
  MSG_create_environment(argv[1]);
  MSG_launch_application(argv[2]);
  return MSG_main();
}

/**
	This function starts and ends simulation workflow.
	`main` accepts following arguments:
	@--cfg=tracing:yes  enables tracing functionality of simgrid
	@--cfg=tracing/platform:yes  enables platform tracing functionality of simgrid
	@--cfg=tracing/filename:<path to trace file>  defines path to file simgrid writes to
	@--cfg=maxmin/concurrency_limit:100000	maximum number of simultaneously running processes in simulation 
	@--cfg=storage/max_file_descriptors:220000"	 maximum number of simultaneously open (and not closed) file descriptors
	
*/
int main(int argc, char *argv[]){

    YAML::Node config = YAML::LoadFile("config.yml");

    const std::string model = config["model"].as<std::string>();
    const std::string platform = config["platform"].as<std::string>();
    const std::string deployment = config["deployment"].as<std::string>();
    path_to_output = config["out.txt"].as<std::string>();
    jobs_file = config["jobs"].as<std::string>();
    input_files_file = config["input"].as<std::string>();

    auto t1 = std::chrono::high_resolution_clock::now();

    MSG_init(&argc, argv);

    MSG_create_environment(platform.c_str());

    declare_trace_variables();

    sem_requester = MSG_sem_init(1);

    MSG_function_register("evil", evil);
    MSG_function_register("scheduler", scheduler);
    MSG_function_register("tier1", tier1);
    MSG_function_register("killer", killer);
    MSG_function_register("tracer", tracer);

    MSG_function_register("initialize", initialize_file_labels);
    MSG_function_register("delete_unpop_file", delete_unpopular_file);
    MSG_launch_application(deployment.c_str());
    current_model = (char*) model.c_str();

    msg_error_t res = MSG_main();
    XBT_INFO("Simulation time %f", MSG_get_clock());

    fclose(FP);
    MSG_sem_destroy(sem_requester);
    MSG_sem_destroy(sem_link);

    // Clear info of name node

    /*std::map<string, FileData*>::iterator file_itr = name_node->begin();
    while (file_itr != name_node->end()){
        delete (*file_itr).second;
        name_node->erase(file_itr);
        file_itr++;
    }*/

    // delete global_queue and name_node
    delete GLOBAL_QUEUE;
    //delete name_node;

    auto t2 = std::chrono::high_resolution_clock::now();
    XBT_INFO("Real time of simulation: %ld seconds", std::chrono::duration_cast<std::chrono::seconds>(t2-t1).count());


    return res != MSG_OK;
}