#include "xbt/log.h"
#include "xbt/str.h"
#include "xbt/ex.h" /* ex_backtrace_display */
+#include "mc/mc.h"
XBT_LOG_EXTERNAL_CATEGORY(simix);
XBT_LOG_EXTERNAL_CATEGORY(simix_action);
smx_global_t simix_global = NULL;
static xbt_heap_t simix_timers = NULL;
+static void* SIMIX_action_mallocator_new_f(void);
+static void SIMIX_action_mallocator_free_f(void* action);
+static void SIMIX_action_mallocator_reset_f(void* action);
+
+extern void smx_ctx_raw_new_sr(void);
+
/* FIXME: Yeah, I'll do it in a portable maner one day [Mt] */
#include <signal.h>
static void _XBT_CALL inthandler(int ignored)
{
- INFO0("CTRL-C pressed. Displaying status and bailing out");
+ XBT_INFO("CTRL-C pressed. Displaying status and bailing out");
SIMIX_display_process_status();
exit(1);
}
simix_global = xbt_new0(s_smx_global_t, 1);
simix_global->host = xbt_dict_new();
- simix_global->process_to_run =
- xbt_swag_new(xbt_swag_offset(proc, synchro_hookup));
+ simix_global->process_to_run = xbt_dynar_new(sizeof(void *), NULL);
simix_global->process_list =
xbt_swag_new(xbt_swag_offset(proc, process_hookup));
simix_global->process_to_destroy =
simix_global->maestro_process = NULL;
simix_global->registered_functions = xbt_dict_new();
- simix_global->create_process_function = NULL;
- simix_global->kill_process_function = NULL;
+ simix_global->create_process_function = SIMIX_process_create;
+ simix_global->kill_process_function = SIMIX_process_kill;
simix_global->cleanup_process_function = SIMIX_process_cleanup;
-
-#ifdef HAVE_LATENCY_BOUND_TRACKING
- simix_global->latency_limited_dict = xbt_dict_new();
-#endif
+ simix_global->action_mallocator = xbt_mallocator_new(65536,
+ SIMIX_action_mallocator_new_f, SIMIX_action_mallocator_free_f,
+ SIMIX_action_mallocator_reset_f);
surf_init(argc, argv); /* Initialize SURF structures */
SIMIX_context_mod_init();
if (!simix_timers) {
simix_timers = xbt_heap_new(8, &free);
}
+
+ XBT_DEBUG("ADD SIMIX LEVELS");
+ SIMIX_HOST_LEVEL = xbt_lib_add_level(host_lib,free);
}
/**
*/
void SIMIX_clean(void)
{
+#ifdef TIME_BENCH
+ smx_ctx_raw_new_sr();
+#endif
+
/* Kill everyone (except maestro) */
- SIMIX_process_killall();
+ SIMIX_process_killall(simix_global->maestro_process);
/* Exit the SIMIX network module */
SIMIX_network_exit();
xbt_heap_free(simix_timers);
/* Free the remaining data structures */
- xbt_swag_free(simix_global->process_to_run);
+ xbt_dynar_free(&simix_global->process_to_run);
xbt_swag_free(simix_global->process_to_destroy);
xbt_swag_free(simix_global->process_list);
simix_global->process_list = NULL;
xbt_dict_free(&(simix_global->registered_functions));
xbt_dict_free(&(simix_global->host));
-#ifdef HAVE_LATENCY_BOUND_TRACKING
- xbt_dict_free(&(simix_global->latency_limited_dict));
-#endif
-
/* Let's free maestro now */
SIMIX_context_free(simix_global->maestro_process->context);
xbt_free(simix_global->maestro_process->running_ctx);
surf_exit();
+ xbt_mallocator_free(simix_global->action_mallocator);
xbt_free(simix_global);
simix_global = NULL;
*/
XBT_INLINE double SIMIX_get_clock(void)
{
- return surf_get_clock();
+ if(MC_IS_ENABLED){
+ return MC_process_clock_get(SIMIX_process_self());
+ }else{
+ return surf_get_clock();
+ }
}
void SIMIX_run(void)
unsigned int iter;
do {
+ XBT_DEBUG("New Schedule Round; size(queue)=%lu",
+ xbt_dynar_length(simix_global->process_to_run));
+#ifdef TIME_BENCH
+ smx_ctx_raw_new_sr();
+#endif
do {
- DEBUG0("New Schedule Round");
+ XBT_DEBUG("New Sub-Schedule Round; size(queue)=%lu",
+ xbt_dynar_length(simix_global->process_to_run));
SIMIX_context_runall(simix_global->process_to_run);
while ((req = SIMIX_request_pop())) {
- DEBUG1("Handling request %p", req);
- SIMIX_request_pre(req);
+ XBT_DEBUG("Handling request %p", req);
+ SIMIX_request_pre(req, 0);
}
- } while (xbt_swag_size(simix_global->process_to_run));
+ } while (xbt_dynar_length(simix_global->process_to_run));
time = surf_solve(SIMIX_timer_next());
}
} while (time != -1.0);
+ if (xbt_swag_size(simix_global->process_list) != 0) {
+
+ XBT_WARN("Oops ! Deadlock or code not perfectly clean.");
+ SIMIX_display_process_status();
+ xbt_abort();
+ }
}
/**
}
/**
- * \brief Registers a function to create a process.
- *
- * This function registers an user function to be called when a new process is created. The user function have to call the SIMIX_create_process function.
- * \param function Create process function
+ * \brief Registers a function to create a process.
*
+ * This function registers a function to be called
+ * when a new process is created. The function has
+ * to call SIMIX_process_create().
+ * \param function create process function
*/
XBT_INLINE void SIMIX_function_register_process_create(smx_creation_func_t
function)
{
- xbt_assert0((simix_global->create_process_function == NULL),
- "Data already set");
-
simix_global->create_process_function = function;
}
/**
- * \brief Registers a function to kill a process.
+ * \brief Registers a function to kill a process.
*
- * This function registers an user function to be called when a new process is killed. The user function have to call the SIMIX_kill_process function.
- * \param function Kill process function
+ * This function registers a function to be called when a
+ * process is killed. The function has to call the SIMIX_process_kill().
*
+ * \param function Kill process function
*/
-XBT_INLINE void SIMIX_function_register_process_kill(void_f_pvoid_t
+XBT_INLINE void SIMIX_function_register_process_kill(void_pfn_smxprocess_t
function)
{
- xbt_assert0((simix_global->kill_process_function == NULL),
- "Data already set");
-
simix_global->kill_process_function = function;
}
/**
- * \brief Registers a function to cleanup a process.
+ * \brief Registers a function to cleanup a process.
*
- * This function registers an user function to be called when a new process ends properly.
- * \param function cleanup process function
+ * This function registers a user function to be called when
+ * a process ends properly.
*
+ * \param function cleanup process function
*/
XBT_INLINE void SIMIX_function_register_process_cleanup(void_pfn_smxprocess_t
function)
return;
}
- /*smx_process_t process = NULL;
- xbt_fifo_item_t item = NULL;
- smx_action_t act;*/
+ smx_process_t process = NULL;
int nbprocess = xbt_swag_size(simix_global->process_list);
- INFO1("%d processes are still running, waiting for something.", nbprocess);
+ XBT_INFO("%d processes are still running, waiting for something.", nbprocess);
/* List the process and their state */
- /* FIXME: reimplement me
- INFO0
+ XBT_INFO
("Legend of the following listing: \"<process> on <host>: <status>.\"");
xbt_swag_foreach(process, simix_global->process_list) {
- char *who, *who2;
-
- asprintf(&who, "%s on %s: %s",
- process->name,
- process->smx_host->name,
- (process->blocked) ? "[BLOCKED] "
- : ((process->suspended) ? "[SUSPENDED] " : ""));
if (process->waiting_action) {
- who2 = bprintf("Waiting for action %p to finish", process->waiting_action);
- }
- if (process->mutex) {
- who2 =
- bprintf("%s Blocked on mutex %p", who,
- (XBT_LOG_ISENABLED(simix_kernel, xbt_log_priority_verbose)) ?
- process->mutex : (void *) 0xdead);
- free(who);
- who = who2;
- } else if (process->cond) {
- who2 =
- bprintf
- ("%s Blocked on condition %p; Waiting for the following actions:",
- who,
- (XBT_LOG_ISENABLED(simix_kernel, xbt_log_priority_verbose)) ?
- process->cond : (void *) 0xdead);
- free(who);
- who = who2;
- xbt_fifo_foreach(process->cond->actions, item, act, smx_action_t) {
- who2 =
- bprintf("%s '%s'(%p)", who, act->name,
- (XBT_LOG_ISENABLED(simix_kernel, xbt_log_priority_verbose))
- ? act : (void *) 0xdead);
- free(who);
- who = who2;
- }
- } else if (process->sem) {
- who2 =
- bprintf
- ("%s Blocked on semaphore %p; Waiting for the following actions:",
- who,
- (XBT_LOG_ISENABLED(simix_kernel, xbt_log_priority_verbose)) ?
- process->sem : (void *) 0xdead);
- free(who);
- who = who2;
- xbt_fifo_foreach(process->sem->actions, item, act, smx_action_t) {
- who2 =
- bprintf("%s '%s'(%p)", who, act->name,
- (XBT_LOG_ISENABLED(simix_kernel, xbt_log_priority_verbose))
- ? act : (void *) 0xdead);
- free(who);
- who = who2;
- }
+ const char* action_description = "unknown";
+ switch (process->waiting_action->type) {
+
+ case SIMIX_ACTION_EXECUTE:
+ action_description = "execution";
+ break;
+
+ case SIMIX_ACTION_PARALLEL_EXECUTE:
+ action_description = "parallel execution";
+ break;
+
+ case SIMIX_ACTION_COMMUNICATE:
+ action_description = "communication";
+ break;
+
+ case SIMIX_ACTION_SLEEP:
+ action_description = "sleeping";
+ break;
+
+ case SIMIX_ACTION_SYNCHRO:
+ action_description = "synchronization";
+ break;
- } else {
- who2 =
- bprintf
- ("%s Blocked in an unknown status (please report this bug)", who);
- free(who);
- who = who2;
+ case SIMIX_ACTION_IO:
+ action_description = "I/O";
+ break;
+ }
+ XBT_INFO("Waiting for %s action %p to finish", action_description, process->waiting_action);
}
- INFO1("%s.", who);
- free(who);
}
- */
+}
+
+static void* SIMIX_action_mallocator_new_f(void) {
+ smx_action_t action = xbt_new(s_smx_action_t, 1);
+ action->request_list = xbt_fifo_new();
+ return action;
+}
+
+static void SIMIX_action_mallocator_free_f(void* action) {
+ xbt_fifo_free(((smx_action_t) action)->request_list);
+ xbt_free(action);
+}
+
+static void SIMIX_action_mallocator_reset_f(void* action) {
+
+ // we also recycle the request list
+ xbt_fifo_t fifo = ((smx_action_t) action)->request_list;
+ xbt_fifo_reset(fifo);
+ memset(action, 0, sizeof(s_smx_action_t));
+ ((smx_action_t) action)->request_list = fifo;
}
