int main(void) { int __retres1 ; { { e_wl = 2; e_c = e_wl; e_g = e_c; e_f = e_g; e_e = e_f; wl_pc = 0; c1_pc = 0; c2_pc = 0; wb_pc = 0; wb_i = 1; c2_i = wb_i; c1_i = c2_i; wl_i = c1_i; r_i = 0; c_req_up = 0; d = 0; c = 0; start_simulation(); } __retres1 = 0; return (__retres1); } }
static void object_registered_cb (DfsmObject *obj, GAsyncResult *async_result, MainData *data) { GError *error = NULL; g_debug ("Finished registering object %p.", obj); /* Finish the async call. */ dfsm_object_register_on_bus_finish (obj, async_result, &error); data->outstanding_registration_callbacks--; if (error != NULL) { /* Error! Unregister all the objects we've just registered, disconnect from the bus and run away. */ g_printerr (_("Error connecting simulated object to D-Bus: %s"), error->message); g_printerr ("\n"); data->exit_status = STATUS_DBUS_ERROR; g_error_free (error); /* Unregister objects and run away from the bus. */ unregister_objects_and_close_connection (data); } /* Bail if this isn't the last callback. */ if (data->outstanding_registration_callbacks > 0) { return; } /* Spawn! */ start_simulation (data); }
int main(void) { int __retres1 ; { { c_m_lock = 0; c_m_ev = 2; m_run_i = 1; m_run_pc = 0; s_run_i = 1; s_run_pc = 0; c_empty_req = 1; c_empty_rsp = 1; c_read_req_ev = 2; c_write_req_ev = 2; c_read_rsp_ev = 2; c_write_rsp_ev = 2; c_m_lock = 0; c_m_ev = 2; start_simulation(); } __retres1 = 0; return (__retres1); } }
int main(void) { int __retres1 ; { { init_model(); start_simulation(); } __retres1 = 0; return (__retres1); } }
int main(void) { struct ramdisk_struct *simulated_disk; simulated_disk = create_ramdisk(RAMDISK_SIZE, DEFAULT_LBA_SHIFT); if (!simulated_disk) { fprintf(stderr, "error initializing ramdisk"); return -1; } start_simulation(simulated_disk); destroy_ramdisk(simulated_disk); return 0; }
static void connection_created_cb (GObject *source_object, GAsyncResult *result, MainData *data) { guint i; GError *error = NULL; /* Finish connecting to D-Bus. */ data->connection = g_dbus_connection_new_finish (result, &error); if (error != NULL) { g_printerr (_("Error connecting to D-Bus using address ā%sā: %s"), data->dbus_address, error->message); g_printerr ("\n"); g_error_free (error); data->exit_status = STATUS_DBUS_ERROR; g_main_loop_quit (data->main_loop); return; } /* Connect to closed notifications, so we know if the bus disappears. */ g_signal_connect (data->connection, "closed", (GCallback) connection_closed_cb, data); /* Hold an outstanding callback while we loop over the objects, so that we don't spawn the program under test before we've finished * registering all the objects (e.g. if their callbacks are called very quickly). */ data->outstanding_registration_callbacks++; /* Register our DfsmObjects on the bus. */ for (i = 0; i < data->simulated_objects->len; i++) { DfsmObject *simulated_object; simulated_object = g_ptr_array_index (data->simulated_objects, i); /* Register the object. We keep a count of all the outstanding callbacks and only spawn the program under test once all are complete. */ data->outstanding_registration_callbacks++; g_signal_connect (simulated_object, "notify::dbus-activity-count", (GCallback) simulated_object_dbus_activity_count_notify_cb, data); dfsm_object_register_on_bus (simulated_object, data->connection, (GAsyncReadyCallback) object_registered_cb, data); } /* Release our outstanding callback and spawn the test program if it hasn't been spawned already. */ data->outstanding_registration_callbacks--; if (data->outstanding_registration_callbacks == 0) { start_simulation (data); } }
int main(void) { int __retres1 ; { { init_model(); start_simulation(); } if (! ((int )z_val == 0)) { { error(); } } else { } __retres1 = 0; return (__retres1); } }
/*! this is a straight forward main function, that does the following - load lua config file - get configuration table from config - contruct a preferences class from them - start simulation according to the preferences - dump the result as precified in preferences */ int main(int argc, char * argv[argc]) { fftw_init_threads(); fftw_plan_with_nthreads(4); if (argc != 3) { fprintf(stderr, "usage: %s config.lua result.dat\n", argv[0]); return -1; } lua_State * L = luaL_newstate(); luaL_openlibs(L); preferences_t * prefs = preferences_new(); if (luaL_dofile(L, argv[1])) { fprintf(stderr, "could not load '%s' : %s\n", argv[1], lua_tostring(L, 1)); } else { // get config table lua_getfield(L, LUA_GLOBALSINDEX, "config"); if (lua_isnil(L, -1)) { fprintf(stderr, "table config undefined\n"); } else { // ref config table, so we can access it in preferences_read() prefs->config = luaL_ref(L, LUA_REGISTRYINDEX); if (!preferences_read(L, prefs)) { if (!start_simulation(prefs)) { FILE * fp = fopen(argv[2], "wb"); assert(fp); dump_results(prefs, fp); fclose(fp); } } } } preferences_free(prefs); lua_close(L); fftw_cleanup(); fftw_cleanup_threads(); pthread_exit(NULL); }
int main(int argc , char * argv[]) { // if(argc !=4 ){ printf("\nUSAGE : simuation graph_data car_data time_step");exit(0);} GRAPH G; CARS C; EDGES E; time_step =1;// atof(argv[3]); read_graph(&G, "input");//argv[1]); read_cars(&C, "car_input");//argv[2]); print_graph(&G); print_cars(&C); init(&G,&C,&E); // print_edges(&E); printf(" \n time_step : %f\n",time_step); start_simulation(&G,&C,&E); print_collisons(); print_path_history(&C); print_edge_history(&E); return 1; }
int main(void) { int count ; int __retres2 ; { { num = 0; i = 0; max_loop = 2; e ; timer = 0; P_1_pc = 0; C_1_pc = 0; count = 0; init_model(); start_simulation(); } __retres2 = 0; return (__retres2); } }
mainwin::mainwin(QWidget *parent) : QMainWindow(parent), ui(new Ui::mainwin) { /* Initialize program parameters */ initialize_scalar_propery_names(); // Set up user interface ui->setupUi(this); // Set up main window this->show(); // Set central widget /* Connect menu items with functions */ QObject::connect(ui->actionPause, SIGNAL(triggered(bool)), this, SLOT(toggle_pause_simulation())); QObject::connect(ui->actionSave_screen_as_TikZ_picture, SIGNAL(triggered(bool)), this, SLOT(save_screen_as_tikz_picture())); // Start simulation directly when application has finished loading QTimer::singleShot(100, this, SLOT(start_simulation())); }
int main(void) { int count ; int __retres2 ; { { main_in1_ev = 2; main_in1_req_up = 0; main_in2_ev = 2; main_in2_req_up = 0; main_diff_ev = 2; main_diff_req_up = 0; main_sum_ev = 2; main_sum_req_up = 0; main_pres_ev = 2; main_pres_req_up = 0; main_dbl_ev = 2; main_dbl_req_up = 0; main_zero_ev = 2; main_zero_req_up = 0; main_clk_val = 0; main_clk_ev = 2; main_clk_req_up = 0; main_clk_pos_edge = 2; main_clk_neg_edge = 2; count = 0; N_generate_i = 0; S1_addsub_i = 0; S2_presdbl_i = 0; S3_zero_i = 0; D_print_i = 0; start_simulation(); } { while (1) { while_2_continue: /* CIL Label */ ; { main_clk_val_t = 1; main_clk_req_up = 1; start_simulation(); count += 1; } if (count == 5) { if ((D_z == 0)) { { error(); } } else { } count = 0; } else { } { main_clk_val_t = 0; main_clk_req_up = 1; start_simulation(); } } while_2_break: /* CIL Label */ ; } __retres2 = 0; return (__retres2); } }
int main() { try { const clock_t begin_time = clock(); start_simulation(); const clock_t after_init_time = clock(); /************************************************* * STimulus here: **************************************************/ #if TEST_TEST_CASE == LUT6_TEST run_LUT6_test_stumulus(); #endif #if TEST_TEST_CASE == TEST_DUT_TEST run_TEST_DUT_test_stimulus(); #endif #if (TEST_TEST_CASE == CARRY4_TEST) run_CARRY4_test_stumulus(); #endif const clock_t after_run_time = clock(); VCDWiter vcdWriter("parsimony.vcd"); vcdWriter.write_vcd(); delete engine; printf("Exiting... \n By"); fflush(stdout); const clock_t finish_time = clock(); printf("Summary of time of running:\n"); printf(" Init : %.0f ms\n", float(after_init_time - begin_time) / CLOCKS_PER_MSEC); printf(" Run : %.0f ms\n", float(after_run_time - after_init_time) / CLOCKS_PER_MSEC); printf(" VCD write: %.0f ms\n", float(finish_time - after_run_time) / CLOCKS_PER_MSEC); printf("Sum : %.0f ms\n", float(finish_time - begin_time) / CLOCKS_PER_MSEC); } catch (const std::exception &exc) { // catch anything thrown within try block that derives from std::exception std::cerr << "SimulatorEngine::run: start sim: " << exc.what() << std::endl; exit(-1); } catch (const char * ex) { // catch anything thrown within try block that derives from std::exception std::cerr << ex << std::endl; exit(-1); } catch (...) { // catch anything thrown within try block that derives from std::exception std::cerr << "Semi Unhandled EX in main" << std::endl; exit(-1); } return 0; }