static void
restart_simulation (MainData *data)
{
guint i;
/* Have we finished? */
if (data->num_test_runs_remaining == 0) {
g_message (_("Stopping simulation due to performing the desired number of test runs."));
stop_simulation (data);
return;
}
g_message (_("Restarting simulation."));
/* Stop the test program and reset all our simulation objects. */
dsim_program_wrapper_kill (DSIM_PROGRAM_WRAPPER (data->test_program), FALSE);
for (i = 0; i < data->simulated_objects->len; i++) {
DfsmObject *simulated_object = g_ptr_array_index (data->simulated_objects, i);
dfsm_object_reset (simulated_object);
}
dfsm_object_factory_set_unfuzzed_transition_limit (unfuzzed_transition_limit);
/* Re-spawn the program under test. */
spawn_test_program (data);
}
void start_simulation(void)
{ int kernel_st ;
int tmp ;
{
{
kernel_st = 0;
init_threads();
}
{
while (1) {
while_3_continue: /* CIL Label */ ;
{
kernel_st = 1;
eval();
tmp = stop_simulation();
}
if (tmp) {
goto while_3_break;
} else {
}
}
while_3_break: /* CIL Label */ ;
}
return;
}
}
void start_simulation(void)
{ int kernel_st ;
int tmp ;
int tmp___0 ;
{
{
kernel_st = 0;
update_channels();
init_threads();
fire_delta_events();
activate_threads();
reset_delta_events();
}
{
while (1) {
while_6_continue: /* CIL Label */ ;
{
kernel_st = 1;
eval();
}
{
kernel_st = 2;
update_channels();
}
{
kernel_st = 3;
fire_delta_events();
activate_threads();
reset_delta_events();
}
{
tmp = exists_runnable_thread();
}
if (tmp == 0) {
{
kernel_st = 4;
fire_time_events();
activate_threads();
reset_time_events();
}
} else {
}
{
tmp___0 = stop_simulation();
}
if (tmp___0) {
goto while_6_break;
} else {
}
}
while_6_break: /* CIL Label */ ;
}
return;
}
}
static gboolean
simulation_timeout_cb (MainData *data)
{
g_message (_("Stopping simulation due to simulation timeout being reached."));
stop_simulation (data);
return FALSE;
}
void main1() {
int i;
start_metric();
pr("Starting Hello World", 0, PR_CPU_ID | PR_STRING | PR_NEWL);
for(i=0;i<5;i++) {
pr("", i, PR_CPU_ID | PR_DEC | PR_NEWL);
}
stop_metric();
stop_simulation();
}
static void
connection_closed_cb (GDBusConnection *connection, gboolean remote_peer_vanished, GError *error, MainData *data)
{
g_debug ("D-Bus connection closed (remote peer vanished: %s, error: %s).", (remote_peer_vanished == TRUE) ? "yes" : "no",
(error != NULL) ? error->message : "no");
/* Shut down if this wasn't the result of us calling close() on the connection. */
if (remote_peer_vanished == TRUE || error != NULL) {
g_clear_object (&data->connection);
stop_simulation (data);
}
}
static void
test_program_died_cb (DsimProgramWrapper *wrapper, gint status, MainData *data)
{
if (WIFEXITED (status) || (WIFSIGNALED (status) && (WTERMSIG (status) == SIGTERM || WTERMSIG (status) == SIGINT))) {
/* Exited normally: proceed to the next test run. However, if bendy-bus was signalled beforehand, ignore the test program exiting
* and continue to close ourselves. */
if (data->exit_signal == EXIT_SIGNAL_INVALID) {
/* We have to do this in an idle callback so that we don't try to re-spawn the test program while it's still closing. */
g_idle_add ((GSourceFunc) restart_simulation_idle_cb, data);
}
} else {
/* Crashed: stop the entire simulation. */
g_message (_("Stopping simulation due to test program crashing (status: %i)."), status);
stop_simulation (data);
}
}
void start_simulation(void)
{ int kernel_st ;
int tmp ;
{
{
kernel_st = 0;
update_channels();
init_threads();
fire_delta_events();
activate_threads();
reset_delta_events();
}
{
while (1) {
while_1_continue: /* CIL Label */ ;
{
kernel_st = 1;
eval();
}
{
kernel_st = 2;
update_channels();
}
{
kernel_st = 3;
fire_delta_events();
activate_threads();
reset_delta_events();
tmp = stop_simulation();
}
if (tmp) {
goto while_1_break;
} else {
}
}
while_1_break: /* CIL Label */ ;
}
return;
}
}
static void
signal_handler (int signum, MainData *data)
{
g_debug ("signal_handler(%i) called.", signum);
/* We need to propagate the signal when we exit, in order that the calling process knows we exited due to a signal.
* However, if we kill() now, we won't finish cleaning up properly (because we need to re-enter the main loop for a little
* while to be able to do that). */
data->exit_status = STATUS_SUCCESS;
data->exit_signal = signum;
/* Have we created/spawned the test program yet? If not, we don't have much cleaning up to do. */
if (data->test_program != NULL) {
g_message (_("Stopping simulation due to receiving termination signal."));
stop_simulation (data);
} else {
g_main_loop_quit (data->main_loop);
}
}
static void
spawn_test_program (MainData *data)
{
GError *error = NULL;
dsim_program_wrapper_spawn (DSIM_PROGRAM_WRAPPER (data->test_program), &error);
if (data->num_test_runs_remaining > 0) {
data->num_test_runs_remaining--;
}
if (error != NULL) {
g_printerr (_("Error spawning test program instance: %s"), error->message);
g_printerr ("\n");
g_error_free (error);
data->exit_status = STATUS_TEST_PROGRAM_SPAWN_ERROR;
stop_simulation (data);
return;
}
}
static void
dbus_daemon_died_cb (DsimProgramWrapper *wrapper, gint status, MainData *data)
{
/* This should never happen. We assume the dbus-daemon is rock solid. */
if (WIFEXITED (status) || (WIFSIGNALED (status) && (WTERMSIG (status) == SIGTERM || WTERMSIG (status) == SIGINT))) {
/* Ignore the daemon disappearing if bendy-bus was signalled beforehand. */
if (data->exit_signal == EXIT_SIGNAL_INVALID) {
g_message (_("Stopping simulation due to dbus-daemon exiting (status: %i)."), status);
}
} else {
g_message (_("Stopping simulation due to dbus-daemon crashing (status: %i)."), status);
}
if (data->exit_signal != EXIT_SIGNAL_INVALID) {
return;
}
/* Have we created/spawned the test program yet? If not, we don't have much cleaning up to do. */
if (data->test_program != NULL) {
stop_simulation (data);
} else {
g_main_loop_quit (data->main_loop);
}
}
