int main(int argc, char** argv)
{
int status = 0;
SIMIX_global_init(&argc, argv);
XBT_INFO("Basic testing posix");
status += test_parmap_basic(XBT_PARMAP_POSIX);
XBT_INFO("Basic testing futex");
#ifdef HAVE_FUTEX_H
status += test_parmap_basic(XBT_PARMAP_FUTEX);
#endif
XBT_INFO("Basic testing busy wait");
status += test_parmap_basic(XBT_PARMAP_BUSY_WAIT);
XBT_INFO("Extended testing posix");
status += test_parmap_extended(XBT_PARMAP_POSIX);
XBT_INFO("Extended testing futex");
#ifdef HAVE_FUTEX_H
status += test_parmap_extended(XBT_PARMAP_FUTEX);
#endif
XBT_INFO("Extended testing busy wait");
status += test_parmap_extended(XBT_PARMAP_BUSY_WAIT);
return status == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}
Engine::Engine(int* argc, char** argv) : pimpl(new kernel::EngineImpl())
{
xbt_assert(Engine::instance_ == nullptr, "It is currently forbidden to create more than one instance of s4u::Engine");
TRACE_global_init();
SIMIX_global_init(argc, argv);
Engine::instance_ = this;
}
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;
}
int main(int argc, char** argv)
{
SIMIX_global_init(&argc, argv);
simgrid::mc::Variable* var;
simgrid::mc::Type* type;
simgrid::mc::Process process(getpid(), -1);
process.init();
test_global_variable(process, process.binary_info.get(),
"some_local_variable", &some_local_variable, sizeof(int));
var = test_global_variable(process, process.binary_info.get(),
"test_some_array", &test_some_array, sizeof(test_some_array));
auto i = process.binary_info->types.find(var->type_id);
xbt_assert(i != process.binary_info->types.end(), "Missing type");
type = &i->second;
xbt_assert(type->element_count == 6*5*4,
"element_count mismatch in test_some_array : %i / %i",
type->element_count, 6*5*4);
var = test_global_variable(process, process.binary_info.get(),
"test_some_struct", &test_some_struct, sizeof(test_some_struct));
i = process.binary_info->types.find(var->type_id);
xbt_assert(i != process.binary_info->types.end(), "Missing type");
type = &i->second;
assert(type);
assert(find_member(*type, "first")->offset() == 0);
assert(find_member(*type, "second")->offset()
== ((const char*)&test_some_struct.second) - (const char*)&test_some_struct);
unw_context_t context;
unw_cursor_t cursor;
unw_getcontext(&context);
unw_init_local(&cursor, &context);
test_local_variable(process.binary_info.get(), "main", "argc", &argc, &cursor);
{
int lexical_block_variable = 50;
test_local_variable(process.binary_info.get(), "main",
"lexical_block_variable", &lexical_block_variable, &cursor);
}
s_foo my_foo;
test_type_by_name(process, my_foo);
_exit(0);
}
int main(int argc, char *argv[])
{
int nthreads;
unsigned modes = MODES_DEFAULT;
SIMIX_global_init(&argc, argv);
if (argc != 2 && argc != 3) {
fprintf(stderr,
"Usage: %s nthreads [modes]\n"
" nthreads - number of working threads\n"
" modes - bitmask of modes to test\n",
argv[0]);
return EXIT_FAILURE;
}
nthreads = atoi(argv[1]);
if (nthreads < 1) {
fprintf(stderr, "ERROR: invalid thread count: %d\n", nthreads);
return EXIT_FAILURE;
}
if (argc == 3)
modes = strtol(argv[2], NULL, 0);
printf("Parmap benchmark with %d workers (modes = %#x)...\n\n",
nthreads, modes);
fun_to_apply = fun_small_comp;
printf("Benchmark for parmap create+apply+destroy (small comp):\n");
bench_all_modes(bench_parmap_full, nthreads, modes);
printf("\n");
printf("Benchmark for parmap apply only (small comp):\n");
bench_all_modes(bench_parmap_apply, nthreads, modes);
printf("\n");
fun_to_apply = fun_big_comp;
printf("Benchmark for parmap create+apply+destroy (big comp):\n");
bench_all_modes(bench_parmap_full, nthreads, modes);
printf("\n");
printf("Benchmark for parmap apply only (big comp):\n");
bench_all_modes(bench_parmap_apply, nthreads, modes);
printf("\n");
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
SIMIX_global_init(&argc, argv);
if (argc != 2) {
printf("Usage: %s platform_and_deployment.xml\n", argv[0]);
exit(EXIT_FAILURE);
}
SIMIX_function_register("master", master);
SIMIX_create_environment(argv[1]);
SIMIX_launch_application(argv[1]);
SIMIX_run();
return 0;
}
/**
* \ingroup msg_simulation
* \brief Initialize MSG with less verifications
* You should use the MSG_init() function instead. Failing to do so may turn into PEBKAC some day. You've been warned.
*/
void MSG_init_nocheck(int *argc, char **argv) {
TRACE_global_init(argc, argv);
xbt_getpid = MSG_process_self_PID;
if (!msg_global) {
msg_global = xbt_new0(s_MSG_Global_t, 1);
xbt_cfg_register_boolean("msg/debug-multiple-use", "no", _sg_cfg_cb_msg_debug_multiple_use,
"Print backtraces of both processes when there is a conflict of multiple use of a task");
SIMIX_global_init(argc, argv);
msg_global->sent_msg = 0;
msg_global->task_copy_callback = nullptr;
msg_global->process_data_cleanup = nullptr;
SIMIX_function_register_process_create(MSG_process_create_from_SIMIX);
SIMIX_function_register_process_cleanup(MSG_process_cleanup_from_SIMIX);
simgrid::surf::on_postparse.connect(MSG_post_create_environment);
simgrid::s4u::Host::onCreation.connect([](simgrid::s4u::Host& host) {
MSG_host_create_(&host);
});
MSG_HOST_LEVEL = simgrid::s4u::Host::extension_create([](void *p) {
__MSG_host_priv_free((msg_host_priv_t) p);
});
}
if(MC_is_active()){
/* Ignore total amount of messages sent during the simulation for heap comparison */
MC_ignore_heap(&(msg_global->sent_msg), sizeof(msg_global->sent_msg));
}
XBT_DEBUG("ADD MSG LEVELS");
MSG_STORAGE_LEVEL = xbt_lib_add_level(storage_lib, (void_f_pvoid_t) __MSG_storage_destroy);
MSG_FILE_LEVEL = xbt_lib_add_level(file_lib, (void_f_pvoid_t) __MSG_file_destroy);
if(xbt_cfg_get_boolean("clean-atexit"))
atexit(MSG_exit);
}
/**
* \ingroup msg_simulation
* \brief Initialize MSG with less verifications
* You should use the MSG_init() function instead. Failing to do so may turn into PEBKAC some day. You've been warned.
*/
void MSG_init_nocheck(int *argc, char **argv) {
#ifdef HAVE_TRACING
TRACE_global_init(argc, argv);
#endif
xbt_getpid = MSG_process_self_PID;
if (!msg_global) {
msg_global = xbt_new0(s_MSG_Global_t, 1);
xbt_cfg_register(&_sg_cfg_set, "msg/debug_multiple_use",
"Print backtraces of both processes when there is a conflict of multiple use of a task",
xbt_cfgelm_boolean, 1, 1, _sg_cfg_cb_msg_debug_multiple_use, NULL);
xbt_cfg_setdefault_boolean(_sg_cfg_set, "msg/debug_multiple_use", "no");
SIMIX_global_init(argc, argv);
#ifdef MSG_USE_DEPRECATED
msg_global->max_channel = 0;
#endif
msg_global->sent_msg = 0;
msg_global->task_copy_callback = NULL;
msg_global->process_data_cleanup = NULL;
SIMIX_function_register_process_create(MSG_process_create_from_SIMIX);
SIMIX_function_register_process_cleanup(MSG_process_cleanup_from_SIMIX);
sg_platf_postparse_add_cb(MSG_post_create_environment);
}
if(MC_is_active()){
/* Ignore total amount of messages sent during the simulation for heap comparison */
MC_ignore_heap(&(msg_global->sent_msg), sizeof(msg_global->sent_msg));
}
XBT_DEBUG("ADD MSG LEVELS");
MSG_HOST_LEVEL = xbt_lib_add_level(host_lib, (void_f_pvoid_t) __MSG_host_priv_free);
MSG_STORAGE_LEVEL = xbt_lib_add_level(storage_lib, (void_f_pvoid_t) __MSG_storage_destroy);
MSG_FILE_LEVEL = xbt_lib_add_level(file_lib, (void_f_pvoid_t) __MSG_file_destroy);
if(sg_cfg_get_boolean("clean_atexit")) atexit(MSG_exit);
}
/** \ingroup msg_simulation
* \brief Initialize some MSG internal data.
*/
void MSG_global_init(int *argc, char **argv)
{
#ifdef HAVE_TRACING
TRACE_global_init(argc, argv);
#endif
xbt_getpid = MSG_process_self_PID;
if (!msg_global) {
/* Connect our log channels: that must be done manually under windows */
XBT_LOG_CONNECT(msg_gos, msg);
XBT_LOG_CONNECT(msg_kernel, msg);
XBT_LOG_CONNECT(msg_mailbox, msg);
XBT_LOG_CONNECT(msg_process, msg);
SIMIX_global_init(argc, argv);
msg_global = xbt_new0(s_MSG_Global_t, 1);
msg_global->max_channel = 0;
msg_global->PID = 1;
msg_global->sent_msg = 0;
/* initialization of the action module */
_MSG_action_init();
SIMIX_function_register_process_create(MSG_process_create_from_SIMIX);
SIMIX_function_register_process_cleanup(MSG_process_cleanup_from_SIMIX);
SIMIX_function_register_process_kill(MSG_process_kill_from_SIMIX);
}
#ifdef HAVE_TRACING
TRACE_start();
#endif
XBT_DEBUG("ADD MSG LEVELS");
MSG_HOST_LEVEL = xbt_lib_add_level(host_lib,free);
}
int smpi_main(int (*realmain) (int argc, char *argv[]), int argc, char *argv[])
{
srand(SMPI_RAND_SEED);
if (getenv("SMPI_PRETEND_CC") != NULL) {
/* Hack to ensure that smpicc can pretend to be a simple compiler. Particularly handy to pass it to the
* configuration tools */
return 0;
}
smpi_init_logs();
TRACE_global_init(&argc, argv);
TRACE_add_start_function(TRACE_smpi_alloc);
TRACE_add_end_function(TRACE_smpi_release);
SIMIX_global_init(&argc, argv);
MSG_init(&argc,argv);
SMPI_switch_data_segment = smpi_switch_data_segment;
smpi_init_options();
// parse the platform file: get the host list
SIMIX_create_environment(argv[1]);
SIMIX_comm_set_copy_data_callback(&smpi_comm_copy_buffer_callback);
SIMIX_function_register_default(realmain);
SIMIX_launch_application(argv[2]);
smpi_global_init();
smpi_check_options();
if(smpi_privatize_global_variables)
smpi_initialize_global_memory_segments();
/* Clean IO before the run */
fflush(stdout);
fflush(stderr);
if (MC_is_active()) {
MC_run();
} else {
SIMIX_run();
xbt_os_walltimer_stop(global_timer);
if (xbt_cfg_get_boolean("smpi/display-timing")){
double global_time = xbt_os_timer_elapsed(global_timer);
XBT_INFO("Simulated time: %g seconds. \n\n"
"The simulation took %g seconds (after parsing and platform setup)\n"
"%g seconds were actual computation of the application",
SIMIX_get_clock(), global_time , smpi_total_benched_time);
if (smpi_total_benched_time/global_time>=0.75)
XBT_INFO("More than 75%% of the time was spent inside the application code.\n"
"You may want to use sampling functions or trace replay to reduce this.");
}
}
int count = smpi_process_count();
int i, ret=0;
for (i = 0; i < count; i++) {
if(process_data[i]->return_value!=0){
ret=process_data[i]->return_value;//return first non 0 value
break;
}
}
smpi_global_destroy();
TRACE_end();
return ret;
}