static PLI_INT32 from_myhdl_calltf(PLI_BYTE8 *user_data)
{
vpiHandle reg_iter, reg_handle;
s_vpi_time verilog_time_s;
char buf[MAXLINE];
char s[MAXWIDTH];
int n;
static int from_myhdl_flag = 0;
if (from_myhdl_flag) {
vpi_printf("ERROR: $from_myhdl called more than once\n");
vpi_control(vpiFinish, 1); /* abort simulation */
return(0);
}
from_myhdl_flag = 1;
init_pipes();
verilog_time_s.type = vpiSimTime;
vpi_get_time(NULL, &verilog_time_s);
verilog_time = timestruct_to_time(&verilog_time_s);
if (verilog_time != 0) {
vpi_printf("ERROR: $from_myhdl should be called at time 0\n");
vpi_control(vpiFinish, 1); /* abort simulation */
return(0);
}
sprintf(buf, "FROM 0 ");
pli_time = 0;
delta = 0;
from_myhdl_systf_handle = vpi_handle(vpiSysTfCall, NULL);
reg_iter = vpi_iterate(vpiArgument, from_myhdl_systf_handle);
while ((reg_handle = vpi_scan(reg_iter)) != NULL) {
if (vpi_get(vpiType, reg_handle) != vpiReg) {
vpi_printf("ERROR: $from_myhdl argument %s should be a reg\n",
vpi_get_str(vpiName, reg_handle));
vpi_control(vpiFinish, 1); /* abort simulation */
return(0);
}
strcat(buf, vpi_get_str(vpiName, reg_handle));
strcat(buf, " ");
sprintf(s, "%d ", vpi_get(vpiSize, reg_handle));
strcat(buf, s);
vpi_free_object(reg_handle);
}
//vpi_free_object(reg_iter);
n = write(wpipe, buf, strlen(buf));
if ((n = read(rpipe, buf, MAXLINE)) == 0) {
vpi_printf("Info: MyHDL simulator down\n");
vpi_control(vpiFinish, 1); /* abort simulation */
return(0);
}
assert(n > 0);
buf[n] = '\0';
return(0);
}
void Model::init_items(){
QJsonObject json_obj= read_json_file(":/map/items_1.json");
QJsonArray blocks_array = json_obj.value(QString("items")).toObject()["block"].toArray();
init_blocks(blocks_array);
QJsonArray coins_array = json_obj.value(QString("items")).toObject()["coins"].toArray();
init_coins(coins_array);
QJsonArray pipes_array = json_obj.value(QString("items")).toObject()["pipes"].toArray();
init_pipes(pipes_array);
QJsonArray decor_array = json_obj.value(QString("items")).toObject()["decor"].toArray();
init_decor(decor_array);
}
int main(int argc, char *argv[])
{
char buf[MAX] = {0};
int count = 0;
while ((count = get_cmds(buf, MAX)) > 0) {
#if DEBUG == 1
print_cmds(count);
#endif
run_cmds(buf);
init_pipes();
}
}
/* Initialize all kernel subsystems and run system */
int main(void) {
printa("In main %x\n", (unsigned)main);
init_int();
init_page_alloc();
init_pipes();
init_scheduler();
add_task(&init_systems);
while (1) {
schedule();
}
return 0;
}
//-----------------------------------------------------------------------------
void init( int argc, char* argv[] ) {
// * set variables from constants *
cpu = DEFAULT_CPU;
// * open error logs *
std::string log_name = "info.log";
info = log_c( log_name );
log_c::error_e log_err;
log_err = info.allocate( LOG_CAPACITY );
if( log_err != log_c::ERROR_NONE ) {
sprintf( errstr, "(coordinator.cpp) init() failed calling log_c::allocate(...).\nExiting\n" );
printf( "%s", errstr );
exit( 1 );
}
// * get the process identifier *
coordinator_pid = getpid( );
printf( "coordinator pid: %d\n", coordinator_pid );
// * bind the process to a single cpu *
if( cpu_c::bind( coordinator_pid, cpu ) != cpu_c::ERROR_NONE ) {
sprintf( errstr, "(coordinator.cpp) init() failed calling cpu_c::bind(coordinator_pid,DEFAULT_CPU).\nExiting\n" );
//error_log.write( errstr );
printf( "%s", errstr );
//error_log.close( );
exit( 1 );
}
// * set the process to be scheduled with realtime policy and max priority *
if( scheduler_c::set_realtime_policy( coordinator_pid, coordinator_priority ) != scheduler_c::ERROR_NONE ) {
sprintf( errstr, "(coordinator.cpp) init() failed calling schedule_set_realtime_max(coordinator_pid,coordinator_priority).\nExiting\n" );
//error_log.write( errstr );
printf( "%s", errstr );
//error_log.close( );
exit( 1 );
}
printf( "coordinator process priority: %d\n", coordinator_priority );
// * determine if the OS supports high resolution timers *
struct timespec res;
clock_getres( CLOCK_MONOTONIC, &res );
double clock_res = timespec_to_real( res );
printf( "Clock resolution (secs): %10.9f\n", clock_res );
if( res.tv_sec != 0 && res.tv_nsec != 1 ) {
sprintf( errstr, "(coordinator.cpp) init() failed. The host operating system does not support high resolution timers. Consult your system documentation on enabling this feature.\nExiting\n" );
//error_log.write( errstr );
printf( "%s", errstr );
//error_log.close( );
exit( 1 );
}
// * get the cpu speed *
if( cpu_c::get_speed( cpu_speed, cpu ) != cpu_c::ERROR_NONE ) {
sprintf( errstr, "(coordinator.cpp) init() failed calling cpu_c::get_frequency(cpu_speed,cpu)\nExiting\n" );
//error_log.write( errstr );
printf( "%s", errstr );
//error_log.close( );
exit( 1 );
}
// * initialize pipes *
if( !init_pipes() ) {
sprintf( errstr, "(coordinator.cpp) init() failed calling init_pipes()\nExiting\n" );
//error_log.write( errstr );
printf( "%s", errstr );
//error_log.close( );
exit( 1 );
}
// * initialize shared memory *
msgbuffer = client_message_buffer_c( CLIENT_MESSAGE_BUFFER_NAME, CLIENT_MESSAGE_BUFFER_MUTEX_NAME, true );
if( msgbuffer.open( ) != client_message_buffer_c::ERROR_NONE ) {
sprintf( errstr, "(coordinator.cpp) init() failed calling actuator_msg_buffer_c.open(...,true)\n" );
//error_log.write( errstr );
printf( "%s", errstr );
close_pipes( );
//error_log.close( );
exit( 1 );
}
// * initialize clients *
/*
CLIENT_MAX_PRIORITY = coordinator_priority - 1;
CLIENT_MIN_PRIORITY = coordinator_priority - 3;
int client_priority_step = CLIENT_MAX_PRIORITY - CLIENT_MIN_PRIORITY;
processor = boost::shared_ptr<processor_c>( new processor_c() );
processor->name = "processor";
dynamics = boost::shared_ptr<dynamics_c>( new dynamics_c() );
dynamics->name = "dynamics";
prey = boost::shared_ptr<timesink_c>( new timesink_c( scheduler_c::PROGRESS) );
prey->name = "prey_timesink";
prey_controller = boost::shared_ptr<osthread_c>( new osthread_c(&select, &read_notifications) );
prey_controller->name = "prey_controller";
prey_controller->_max_priority = CLIENT_MAX_PRIORITY;
prey_controller->_min_priority = CLIENT_MIN_PRIORITY;
prey_controller->_priority_step = client_priority_step;
pred = boost::shared_ptr<timesink_c>( new timesink_c(scheduler_c::PRIORITY) );
pred->name = "pred_timesink";
pred_controller = boost::shared_ptr<osthread_c>( new osthread_c(&select, &read_notifications) );
pred_controller->name = "pred_controller";
pred_controller->_max_priority = CLIENT_MAX_PRIORITY;
pred_controller->_min_priority = CLIENT_MIN_PRIORITY;
pred_controller->_priority_step = client_priority_step;
pred_planner = boost::shared_ptr<osthread_c>( new osthread_c(&select, &read_notifications) );
pred_planner->name = "pred_planner";
pred_planner->_max_priority = CLIENT_MAX_PRIORITY;
pred_planner->_min_priority = CLIENT_MIN_PRIORITY;
pred_planner->_priority_step = client_priority_step;
processor->run_queue.push_back( dynamics );
processor->run_queue.push_back( prey );
processor->run_queue.push_back( pred );
std::make_heap(processor->run_queue.begin(),processor->run_queue.end(),compare_thread_p_t());
prey->run_queue.push_back( prey_controller );
std::make_heap(prey->run_queue.begin(),prey->run_queue.end(),compare_thread_p_t());
pred->run_queue.push_back( pred_planner );
pred->run_queue.push_back( pred_controller );
std::make_heap(pred->run_queue.begin(),pred->run_queue.end(),compare_thread_p_t());
*/
// * initialize block detection, i.e. wakeup *
wakeup_priority = coordinator_priority - 2;
if( scheduler_c::create( wakeup_thread, wakeup_priority, wakeup ) != scheduler_c::ERROR_NONE ) {
msgbuffer.close( );
close_pipes( );
//error_log.close( );
printf( "(coordinator.cpp) init() failed calling wakeup_thread.create(...,wakeup)\nExiting\n" );
exit( 1 );
}
// * initialize timer *
if( timer.create( timer_sighandler, RTTIMER_SIGNAL ) != timer_c::ERROR_NONE ) {
sprintf( errstr, "(coordinator.cpp) init() failed calling timer.create(timer_sighandler,RTTIMER_SIGNAL)\nExiting\n" );
//error_log.write( errstr );
printf( "%s", errstr );
msgbuffer.close( );
close_pipes( );
//error_log.close( );
exit( 1 );
}
// * initialize other resources *
// lock into memory to prevent pagefaults. do last before main loop
mlockall( MCL_CURRENT );
}
/* Note: adjust rlimit if needed for more allowed open fd */
int main(int argc, char **argv)
{
int i;
int rc;
void *thread_retval;
int retry;
if (argc > 1) {
target_addr = strtoul(argv[1], NULL, 0);
}
fprintf(stderr, "target_addr = %p\n", (void *)target_addr);
setfdlimit();
init_sock();
init_mmap();
redo:
retry = 0;
init_pipes();
for (i = 0; i < NR_SOCKS; i++) {
rc = pthread_create(&sendmmsg_threads[i], NULL,
sendmmsg_thread_func, NULL);
if (rc) {
perror("sendmmsg_threads failed");
exit(2);
}
}
sleep(3);
kill_switch = 1;
for (i = 0; i < NR_SOCKS; i++) {
pthread_join(sendmmsg_threads[i], &thread_retval);
}
kill_switch = 0;
sleep(1);
rc = pthread_create(&mmap_thread, NULL, mmap_thread_func, NULL);
if (rc) {
perror("mmap_thread failed");
}
for (i = 0; i < NR_PIPES; i++) {
rc = pthread_create(&pipe_write_threads[i], NULL,
pipe_write_func, (void *)pipes[i].fd[1]);
if (rc) {
perror("pipe_write_thread failed");
exit(2);
}
rc = pthread_create(&pipe_read_threads[i], NULL,
pipe_read_func, (void *)pipes[i].fd[0]);
if (rc) {
perror("pipe_read_thread failed");
exit(2);
}
}
for (i = 0; i < NR_PIPES; i++) {
fprintf(stderr, "join read thread %d...\n", i);
pthread_join(pipe_read_threads[i], &thread_retval);
if (thread_retval == (void *)-1) {
retry = 1;
}
fprintf(stderr, "done\n");
}
kill_switch = 1;
fprintf(stderr, "kill others\n");
fprintf(stderr, "join mmap thread...\n");
pthread_join(mmap_thread, &thread_retval);
fprintf(stderr, "done\n");
for (i = 0; i < NR_PIPES; i++) {
for(;;) {
if (close(pipes[i].fd[0])) {
perror("close write pipe failed");
continue;
}
if (close(pipes[i].fd[1])) {
perror("close read pipe failed");
continue;
}
break;
}
}
fprintf(stderr, "pipe closed\n");
if (retry) {
goto redo;
}
exit(0);
return 0;
}
int main( int argc, char *argv[] )
{
GtkWidget *mainbox, *hbox, *hbox2, *label,*pixmap_w;
/* GdkPixmap *pixmap;
GdkBitmap *mask;
GtkStyle *style;*/
init_pipes(); /* set all pipe data to 0 */
command_line_options(argc, argv);
/* g_thread_init(NULL); no ide why I had to remove it */
gtk_init(&argc, &argv);
gdk_rgb_init ();
/* capturing_init = FALSE;
playing = FALSE;*/
signal(SIGSEGV, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGPIPE, signal_handler);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_signal_connect (GTK_OBJECT (window), "delete_event", GTK_SIGNAL_FUNC (delete_event), NULL);
gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (destroy), NULL);
gtk_window_set_title (GTK_WINDOW (window), "Linux Video Studio");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
mainbox = gtk_vbox_new(FALSE,0);
gtk_container_add (GTK_CONTAINER (window), mainbox);
gtk_widget_show (mainbox);
make_menus(mainbox);
notebook = gtk_notebook_new ();
/* style = gtk_widget_get_style(window);*/
gtk_widget_realize(window);
hbox = create_lavrec_layout(window);
if (hbox != NULL)
{
hbox2 = gtk_hbox_new(FALSE, 10);
/* pixmap = gdk_pixmap_create_from_xpm_d(window->window, &mask,
&style->bg[GTK_STATE_NORMAL], cam_xpm);
pixmap_w = gtk_pixmap_new(pixmap, mask);*/
pixmap_w = gtk_widget_from_xpm_data(cam_xpm);
gtk_widget_show(pixmap_w);
gtk_box_pack_start(GTK_BOX(hbox2), pixmap_w, FALSE, FALSE, 0);
label = gtk_label_new("Capture Video");
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
gtk_widget_show(label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), hbox, hbox2);
gtk_widget_show(hbox);
gtk_widget_show(hbox2);
}
hbox = create_lavedit_layout(window);
hbox2 = gtk_hbox_new(FALSE, 10);
/* pixmap = gdk_pixmap_create_from_xpm_d(window->window, &mask, &style->bg[GTK_STATE_NORMAL], editing_xpm);
pixmap_w = gtk_pixmap_new(pixmap, mask);*/
pixmap_w = gtk_widget_from_xpm_data(editing_xpm);
gtk_widget_show(pixmap_w);
gtk_box_pack_start(GTK_BOX(hbox2), pixmap_w, FALSE, FALSE, 0);
label = gtk_label_new("Edit Video");
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
gtk_widget_show(label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), hbox, hbox2);
gtk_widget_show(hbox);
gtk_widget_show(hbox2);
hbox = create_lavplay_layout();
if (hbox != NULL)
{
hbox2 = gtk_hbox_new(FALSE, 10);
/* pixmap = gdk_pixmap_create_from_xpm_d(window->window, &mask,
&style->bg[GTK_STATE_NORMAL], tv_xpm);
pixmap_w = gtk_pixmap_new(pixmap, mask);*/
pixmap_w = gtk_widget_from_xpm_data(tv_xpm);
gtk_widget_show(pixmap_w);
gtk_box_pack_start(GTK_BOX(hbox2), pixmap_w, FALSE, FALSE, 0);
label = gtk_label_new("Playback Video");
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
gtk_widget_show(label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), hbox, hbox2);
gtk_widget_show(hbox);
gtk_widget_show(hbox2);
}
/* New notebook entry for encoding */
hbox = create_lavencode_layout();
hbox2 = gtk_hbox_new(FALSE, 10);
/* pixmap = gdk_pixmap_create_from_xpm_d(window->window, &mask,
&style->bg[GTK_STATE_NORMAL], arrows_xpm);
pixmap_w = gtk_pixmap_new(pixmap, mask);*/
pixmap_w = gtk_widget_from_xpm_data(arrows_xpm);
gtk_widget_show(pixmap_w);
gtk_box_pack_start(GTK_BOX(hbox2), pixmap_w, FALSE, FALSE, 0);
label = gtk_label_new("Encode Video");
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
gtk_widget_show(label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), hbox, hbox2);
gtk_widget_show(hbox);
gtk_widget_show(hbox2);
hbox = gtk_hbox_new(FALSE,5);
gtk_box_pack_start(GTK_BOX(hbox), notebook, FALSE, FALSE, 5);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
gtk_widget_show(notebook);
gtk_box_pack_start(GTK_BOX(mainbox), hbox, FALSE, FALSE, 5);
gtk_widget_show(hbox);
gtk_signal_connect(GTK_OBJECT(notebook), "switch_page", GTK_SIGNAL_FUNC(notebook_page_switched),NULL);
gtk_widget_show(window);
if (verbose) g_print("Linux Video Studio initialized correctly\n");
gdk_threads_enter();
gtk_main();
gdk_threads_leave();
return 0;
}
//-----------------------------------------------------------------------------
void init( int argc, char* argv[] ) {
//quit = false;
quit = 0;
//quit.store( 0, std::memory_order_seq_cst );
//quit.store( 0, std::memory_order_relaxed );
actual_timer_events = 0;
caught_timer_events = 0;
// * set variables from constants *
cpu = DEFAULT_CPU;
// * install SIGTERM signal handler *
struct sigaction action;
memset( &action, 0, sizeof(struct sigaction) );
action.sa_handler = term_sighandler;
sigaction( SIGTERM, &action, NULL );
// * open log *
#ifdef DO_LOGGING
info = log_p( new log_c( "info.log", true ) );
log_c::error_e log_err = info->allocate( LOG_CAPACITY );
if( log_err != log_c::ERROR_NONE ) {
sprintf( spstr, "(coordinator.cpp) init() failed calling log_c::allocate(...).\nExiting\n" );
printf( spstr );
exit( 1 );
}
#endif
// * get the process identifier *
coordinator_pid = getpid( );
sprintf( spstr, "coordinator pid: %d\n", coordinator_pid );
if( info ) info->write( spstr );
printf( "%s", spstr );
// * bind the process to a single cpu *
if( cpu_c::bind( coordinator_pid, cpu ) != cpu_c::ERROR_NONE ) {
sprintf( spstr, "(coordinator.cpp) init() failed calling cpu_c::_bind(coordinator_pid,DEFAULT_CPU).\nExiting\n" );
if( info ) info->write( spstr );
printf( "%s", spstr );
exit( 1 );
}
// * set the process to be scheduled with realtime policy and max priority *
if( scheduler_c::set_realtime_policy( coordinator_pid, coordinator_os_priority ) != scheduler_c::ERROR_NONE ) {
sprintf( spstr, "(coordinator.cpp) init() failed calling schedule_set_realtime_max(coordinator_pid,coordinator_priority).\nExiting\n" );
if( info ) info->write( spstr );
printf( "%s", spstr );
exit( 1 );
}
sprintf( spstr, "coordinator os priority: %d\n", coordinator_os_priority );
if( info ) info->write( spstr );
printf( "%s", spstr );
// * determine if the OS supports high resolution timers *
struct timespec res;
clock_getres( CLOCK_MONOTONIC, &res );
double clock_res = timespec_to_real( res );
sprintf( spstr, "clock resolution (secs): %10.9f\n", clock_res );
if( info ) info->write( spstr );
printf( "%s", spstr );
if( res.tv_sec != 0 && res.tv_nsec != 1 ) {
sprintf( spstr, "(coordinator.cpp) init() failed. The host operating system does not support high resolution timers. Consult your system documentation on enabling this feature.\nExiting\n" );
if( info ) info->write( spstr );
printf( "%s", spstr );
exit( 1 );
}
// * get the cpu speed *
if( cpu_c::get_speed( cpu_speed, cpu ) != cpu_c::ERROR_NONE ) {
sprintf( spstr, "(coordinator.cpp) init() failed calling cpu_c::get_frequency(cpu_speed,cpu)\nExiting\n" );
if( info ) info->write( spstr );
printf( "%s", spstr );
exit( 1 );
}
sprintf( spstr, "cpu speed(hz): %llu\n", cpu_speed );
if( info ) info->write( spstr );
printf( "%s", spstr );
// * initialize pipes *
if( !init_pipes() ) {
sprintf( spstr, "(coordinator.cpp) init() failed calling init_pipes()\nExiting\n" );
if( info ) info->write( spstr );
printf( "%s", spstr );
exit( 1 );
}
// * initialize shared memory *
msgbuffer = client_message_buffer_c( CLIENT_MESSAGE_BUFFER_NAME, CLIENT_MESSAGE_BUFFER_MUTEX_NAME, true );
if( msgbuffer.open( ) != client_message_buffer_c::ERROR_NONE ) {
sprintf( spstr, "(coordinator.cpp) init() failed calling actuator_msg_buffer_c.open(...,true)\nExiting\n" );
if( info ) info->write( spstr );
printf( "%s", spstr );
close_pipes( );
exit( 1 );
}
// * initialize block detection, i.e. wakeup *
wakeup_os_priority = coordinator_os_priority - 2;
wakeup_enabled.store( 1 );
// set up the wakeup overhead to minimize what changes inside
wakeup_note.source = notification_t::WAKEUP;
wakeup_write_fd = FD_WAKEUP_TO_COORDINATOR_WRITE_CHANNEL;
if( info ) info->flush();
// lock into memory to prevent pagefaults. do last before main loop
mlockall( MCL_CURRENT );
/*
if( scheduler_c::create( wakeup_thread, wakeup_os_priority, wakeup ) != scheduler_c::ERROR_NONE ) {
sprintf( spstr, "(coordinator.cpp) init() failed calling wakeup_thread.create(...,wakeup)\nExiting\n" );
if( info ) info->write( spstr );
printf( "%s", spstr );
msgbuffer.close( );
close_pipes( );
exit( 1 );
}
*/
/*
if( scheduler_c::get_priority( wakeup_thread, wakeup_os_priority ) != scheduler_c::ERROR_NONE ) {
sprintf( spstr, "(coordinator.cpp) init() failed calling get_priority(wakeup_thread,...)\nExiting\n" );
info.write( spstr );
msgbuffer.close( );
close_pipes( );
// kill the wakeup thread?
exit(1);
}
*/
sprintf( spstr, "wakeup thread created... priority:%d\n", wakeup_os_priority );
if( info ) info->write( spstr );
printf( "%s", spstr );
// * initialize clients *
sprintf( spstr, "initializing clients\n" );
if( info ) info->write( spstr );
printf( "%s", spstr );
scheduler_c::error_e schedulererr;
double controller_floor_seconds = 0.001;
double controller_ceiling_seconds = 0.01;
double planner_floor_seconds = 0.01;
double planner_ceiling_seconds = 0.5;
std::string controller_seed = "1";
char numbuf[16];
sprintf(numbuf,"%llu",seconds_to_cycles(controller_floor_seconds, cpu_speed));
std::string controller_floor = numbuf;
sprintf(numbuf,"%llu",seconds_to_cycles(controller_ceiling_seconds, cpu_speed));
std::string controller_ceiling = numbuf;
sprintf(numbuf,"%llu",seconds_to_cycles(planner_floor_seconds, cpu_speed));
std::string planner_floor = numbuf;
sprintf(numbuf,"%llu",seconds_to_cycles(planner_ceiling_seconds, cpu_speed));
std::string planner_ceiling = numbuf;
CLIENT_OS_MAX_PRIORITY = coordinator_os_priority - 1;
CLIENT_OS_MIN_PRIORITY = coordinator_os_priority - 3;
int client_os_priority_step = CLIENT_OS_MAX_PRIORITY - CLIENT_OS_MIN_PRIORITY;
log_c* pinfo = NULL;
if( info ) pinfo = info.get();
/*
// - create a processor -
processor = boost::shared_ptr<processor_c>( new processor_c( "processor_0" ) );
timesink_p processor_timesink = boost::dynamic_pointer_cast<timesink_c>( processor );
processor_thread = boost::dynamic_pointer_cast<thread_c>( processor );
processor->info = pinfo;
// - create dynamics process -
dynamics = boost::shared_ptr<dynamics_c>( new dynamics_c( "dynamics", processor_timesink, cpu_speed ) );
dynamics->info = pinfo;
processor->run_queue.push( dynamics );
// - create prey processes -
prey = boost::shared_ptr<timesink_c>( new timesink_c( "prey", processor_timesink, scheduler_c::PROGRESS) );
prey->info = pinfo;
//prey->priority = 0;
processor->run_queue.push( prey );
prey_thread = boost::dynamic_pointer_cast<thread_c>(prey);
*/
prey_controller = boost::shared_ptr<osthread_c>( new osthread_c( "prey_controller", prey, &select, &read_notifications, &process_notifications, pinfo ) );
prey_controller->_max_os_priority = CLIENT_OS_MAX_PRIORITY;
prey_controller->_min_os_priority = CLIENT_OS_MIN_PRIORITY;
prey_controller->_os_priority_step = client_os_priority_step;
prey_controller->_cpu_speed = cpu_speed;
prey_controller->priority = 0;
prey_controller->desired_period = seconds_to_cycles( controller_ceiling_seconds, cpu_speed );
//prey->run_queue.push( prey_controller );
schedulererr = scheduler_c::create( prey_controller, 3, DEFAULT_CPU, "client-process", "prey-controller", controller_seed.c_str(), controller_floor.c_str(), controller_ceiling.c_str() );
//prey_controller->block();
sprintf( spstr, "created prey-controller: pid[%d], _os_priority[%d], _os_priority_step[%d], _max_os_priority[%d], _min_os_priority[%d]\n", prey_controller->pid, prey_controller->_os_priority, prey_controller->_os_priority_step, prey_controller->_max_os_priority, prey_controller->_min_os_priority );
if( info ) info->write( spstr );
/*
// - create predator processes -
pred = boost::shared_ptr<timesink_c>( new timesink_c( "pred", processor_timesink, scheduler_c::PROGRESS) );
pred->info = pinfo;
//prey->priority = 0;
processor->run_queue.push( pred );
pred_thread = boost::dynamic_pointer_cast<thread_c>(pred);
pred_controller = boost::shared_ptr<osthread_c>( new osthread_c( "pred_controller", pred, &select, &read_notifications, &process_notifications, pinfo ) );
pred_controller->_max_os_priority = CLIENT_OS_MAX_PRIORITY;
pred_controller->_min_os_priority = CLIENT_OS_MIN_PRIORITY;
pred_controller->_os_priority_step = client_os_priority_step;
pred_controller->_cpu_speed = cpu_speed;
pred_controller->priority = 0;
pred_controller->desired_period = seconds_to_cycles( controller_ceiling_seconds, cpu_speed );
pred->run_queue.push( pred_controller );
schedulererr = scheduler_c::create( pred_controller, 3, DEFAULT_CPU, "client-process", "pred-controller", controller_seed.c_str(), controller_floor.c_str(), controller_ceiling.c_str() );
//prey_controller->block();
sprintf( spstr, "created pred-controller: pid[%d], _os_priority[%d], _os_priority_step[%d], _max_os_priority[%d], _min_os_priority[%d]\n", pred_controller->pid, pred_controller->_os_priority, pred_controller->_os_priority_step, pred_controller->_max_os_priority, pred_controller->_min_os_priority );
if( info ) info->write( spstr );
*/
// * initialize timer *
// set up the timer handler overhead to minimize what changes inside
timer_note.source = notification_t::TIMER;
timer_write_fd = FD_TIMER_TO_COORDINATOR_WRITE_CHANNEL;
// create the timer
if( timer.create( timer_sighandler, RTTIMER_SIGNAL ) != timer_c::ERROR_NONE ) {
sprintf( spstr, "(coordinator.cpp) init() failed calling timer.create(timer_sighandler,RTTIMER_SIGNAL)\nExiting\n" );
pthread_cancel( wakeup_thread );
int status;
if( pred_controller ) {
kill( pred_controller->pid, SIGTERM );
waitpid( pred_controller->pid, &status, 0 );
}
if( prey_controller ) {
kill( prey_controller->pid, SIGTERM );
waitpid( prey_controller->pid, &status, 0 );
}
if( info ) info->write( spstr );
printf( "%s", spstr );
msgbuffer.close( );
close_pipes( );
exit( 1 );
}
// * initialize other resources *
//clients.push_back( prey_controller );
//clients.push_back( pred_controller );
//clients.push_back( pred_planner );
}
void cmus_track_request_init(void)
{
init_pipes(&cmus_next_track_request_fd, &cmus_next_track_request_fd_priv);
}
bool wine_start(char *wine_app, char *avsloader, AVS_PIPES *avs_pipes, int pipe_timeout)
{
char sname[MAX_PATH];
struct stat st;
sprintf(sname, "%s %s %d", wine_app, avsloader, pipe_timeout);
FILE *pfile = popen(sname, "r");
if (!pfile)
{
DEBUG_PRINTF_RED("avsfilter : popen failed, errno %d, failed start app is : [%s]\n", errno, sname);
return false;
}
if (fscanf(pfile, "%s\n", sname) != 1 ||
stat(sname, &st) ||
!S_ISDIR(st.st_mode))
{
DEBUG_PRINTF_RED("avsfilter : tmpdirname [%s] failed, errno %d[stat %d isdir %d]\n", sname, errno, stat(sname, &st), S_ISDIR(st.st_mode));
pclose(pfile);
return false;
}
DEBUG_PRINTF("avsfilter : good tmpdirname %s\n", sname);
if (!init_pipes(avs_pipes, CMD_PIPE_NUM, pfile))
{
DEBUG_PRINTF_RED("init_pipes failed\n");
pclose(pfile);
return false;
}
time_t t = time(NULL);
DEBUG_PRINTF("avsfilter : precreate thread time %s\n",
ctime(&t));
pthread_t thread;
TPARSER tp = { avs_pipes, pfile };
open_pipes_ok = false;
if (pthread_create(&thread, NULL, parse_wine_stdout, &tp))
{
DEBUG_PRINTF_RED("Cannot pthread started...Errno %d\n",errno);
deinit_pipes(avs_pipes, CMD_PIPE_NUM);
return false;
}
t = time(NULL);
DEBUG_PRINTF("avsfilter : preopen time %s\n",
ctime(&t));
if (!open_pipes(avs_pipes, CMD_PIPE_NUM) || wine_loader_down)
{
open_pipes_ok = true;
DEBUG_PRINTF_RED("open_pipes failed\n");
deinit_pipes(avs_pipes, CMD_PIPE_NUM);
return false;
}
open_pipes_ok = true;
if (pipe_test_filter (avs_pipes[PIPE_LOADER_READ].hpipe,
avs_pipes[PIPE_FILTER_WRITE].hpipe))
{
DEBUG_PRINTF("avsfilter : test pipe to filter ok\n");
if (pipe_test_filter (avs_pipes[PIPE_LOADER_READ].hpipe,
avs_pipes[PIPE_LOADER_WRITE].hpipe))
{
DEBUG_PRINTF("avsfilter : test pipe to loader ok\n");
}
else
goto error_pipe_test;
}
else
{
error_pipe_test:
DEBUG_PRINTF_RED("Error test read/write pipes\n");
deinit_pipes(avs_pipes, CMD_PIPE_NUM);
return false;
}
DEBUG_PRINTF("wine start is ok\n");
return true;
}
static PLI_INT32 to_myhdl_calltf(PLI_BYTE8 *user_data)
{
vpiHandle net_iter, net_handle, cb_h;
char buf[MAXLINE];
char s[MAXWIDTH];
int n;
int i;
int *id;
s_cb_data cb_data_s;
s_vpi_time verilog_time_s;
s_vpi_time time_s;
s_vpi_value value_s;
static int to_myhdl_flag = 0;
if (to_myhdl_flag) {
vpi_printf("ERROR: $to_myhdl called more than once\n");
vpi_control(vpiFinish, 1); /* abort simulation */
return(0);
}
to_myhdl_flag = 1;
init_pipes();
verilog_time_s.type = vpiSimTime;
vpi_get_time(NULL, &verilog_time_s);
verilog_time = timestruct_to_time(&verilog_time_s);
if (verilog_time != 0) {
vpi_printf("ERROR: $to_myhdl should be called at time 0\n");
vpi_control(vpiFinish, 1); /* abort simulation */
return(0);
}
sprintf(buf, "TO 0 ");
pli_time = 0;
delta = 0;
time_s.type = vpiSuppressTime;
value_s.format = vpiSuppressVal;
cb_data_s.reason = cbValueChange;
cb_data_s.cb_rtn = change_callback;
cb_data_s.time = &time_s;
cb_data_s.value = &value_s;
// value_s.format = vpiHexStrVal;
i = 0;
to_myhdl_systf_handle = vpi_handle(vpiSysTfCall, NULL);
net_iter = vpi_iterate(vpiArgument, to_myhdl_systf_handle);
while ((net_handle = vpi_scan(net_iter)) != NULL) {
if (i == MAXARGS) {
vpi_printf("ERROR: $to_myhdl max #args (%d) exceeded\n", MAXARGS);
vpi_control(vpiFinish, 1); /* abort simulation */
}
strcat(buf, vpi_get_str(vpiName, net_handle));
strcat(buf, " ");
sprintf(s, "%d ", vpi_get(vpiSize, net_handle));
strcat(buf, s);
changeFlag[i] = 0;
id = malloc(sizeof(int));
*id = i;
cb_data_s.user_data = (PLI_BYTE8 *)id;
cb_data_s.obj = net_handle;
cb_h = vpi_register_cb(&cb_data_s);
vpi_free_object(cb_h);
i++;
vpi_free_object(net_handle);
}
//vpi_free_object(net_iter);
n = write(wpipe, buf, strlen(buf));
if ((n = read(rpipe, buf, MAXLINE)) == 0) {
vpi_printf("ABORT from $to_myhdl\n");
vpi_control(vpiFinish, 1); /* abort simulation */
return(0);
}
buf[n] = '\0';
assert(n > 0);
// register read-only callback //
time_s.type = vpiSimTime;
time_s.high = 0;
time_s.low = 0;
cb_data_s.reason = cbReadOnlySynch;
cb_data_s.user_data = NULL;
cb_data_s.cb_rtn = readonly_callback;
cb_data_s.obj = NULL;
cb_data_s.time = &time_s;
cb_data_s.value = NULL;
cb_h = vpi_register_cb(&cb_data_s);
vpi_free_object(cb_h);
// pre-register delta cycle callback //
delta = 0;
time_s.type = vpiSimTime;
time_s.high = 0;
time_s.low = 1;
cb_data_s.reason = cbAfterDelay;
cb_data_s.user_data = NULL;
cb_data_s.cb_rtn = delta_callback;
cb_data_s.obj = NULL;
cb_data_s.time = &time_s;
cb_data_s.value = NULL;
cb_h = vpi_register_cb(&cb_data_s);
vpi_free_object(cb_h);
return(0);
}
