mirror of
https://github.com/nasa/trick.git
synced 2024-12-19 21:27:54 +00:00
26dfb3a000
Moved the lock memory function to the real time sync directory. It doesn't need to be part of the RealTimeSync class either so I left the lock/unlock code in the C language calls for real time functions. refs #195
1013 lines
26 KiB
C++
1013 lines
26 KiB
C++
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <string>
|
|
|
|
#include "trick/Executive.hh"
|
|
#include "trick/ExecutiveException.hh"
|
|
#include "trick/exec_proto.h"
|
|
#include "trick/exec_proto.hh"
|
|
|
|
/* Global singleton pointer to the executive */
|
|
extern Trick::Executive * the_exec ;
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* returns a pointer to the simulation executive
|
|
* @return Executive
|
|
*/
|
|
Trick::Executive * exec_get_exec_cpp() {
|
|
return ( the_exec ) ;
|
|
}
|
|
|
|
/*********************************************************/
|
|
/* These routines are the "C" interface to the executive */
|
|
/*********************************************************/
|
|
|
|
// -------------------------- GET ------------------------
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_attach_debugger
|
|
* C wrapper for Trick::Executive::get_attach_debugger
|
|
*/
|
|
extern "C" int exec_get_attach_debugger() {
|
|
if ( the_exec != NULL ) {
|
|
return (int)the_exec->get_attach_debugger() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_debugger_command
|
|
* C wrapper for Trick::Executive::get_debugger_command
|
|
*/
|
|
extern "C" const char * exec_get_debugger_command() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_debugger_command().c_str() ;
|
|
}
|
|
return NULL ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_enable_freeze
|
|
* C wrapper for Trick::Executive::get_enable_freeze
|
|
*/
|
|
extern "C" int exec_get_enable_freeze() {
|
|
if ( the_exec != NULL ) {
|
|
return (int)the_exec->get_enable_freeze() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_exec_command
|
|
* C wrapper for Trick::Executive::get_exec_command
|
|
*/
|
|
extern "C" SIM_COMMAND exec_get_exec_command() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_exec_command() ;
|
|
}
|
|
return NoCmd ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_freeze_frame
|
|
* C wrapper for Trick::Executive::get_freeze_frame
|
|
*/
|
|
extern "C" double exec_get_freeze_frame() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_freeze_frame() ;
|
|
}
|
|
return 0.0 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_freeze_command
|
|
* C wrapper for Trick::Executive::get_freeze_command
|
|
*/
|
|
extern "C" int exec_get_freeze_command() {
|
|
if ( the_exec != NULL ) {
|
|
return (int)the_exec->get_freeze_command() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_freeze_on_frame_boundary
|
|
* C wrapper for Trick::Executive::get_freeze_on_frame_boundary
|
|
*/
|
|
extern "C" int exec_get_freeze_on_frame_boundary() {
|
|
if ( the_exec != NULL ) {
|
|
return (int)the_exec->get_freeze_on_frame_boundary() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_freeze_frame_tics
|
|
* C wrapper for Trick::Executive::get_freeze_frame_tics
|
|
*/
|
|
extern "C" long long exec_get_freeze_frame_tics() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_freeze_frame_tics() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_freeze_frame_count
|
|
* C wrapper for Trick::Executive::get_freeze_frame_count
|
|
*/
|
|
extern "C" long long exec_get_freeze_frame_count() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_freeze_frame_count() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_job_cycle
|
|
* C wrapper for Trick::Executive::get_job_cycle
|
|
*/
|
|
extern "C" double exec_get_job_cycle(const char * job_name) {
|
|
|
|
if ( the_exec != NULL ) {
|
|
|
|
std::string job_string ;
|
|
|
|
// Add handling for NULL string.
|
|
if ( job_name == NULL ) {
|
|
job_string.clear() ;
|
|
} else {
|
|
job_string = std::string(job_name) ;
|
|
}
|
|
return the_exec->get_job_cycle(job_string) ;
|
|
}
|
|
return -1.0 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_mode
|
|
* C wrapper for Trick::Executive::get_mode
|
|
*/
|
|
extern "C" SIM_MODE exec_get_mode() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_mode() ;
|
|
}
|
|
return Initialization ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_num_threads
|
|
* C wrapper for Trick::Executive::get_num_threads
|
|
*/
|
|
extern "C" unsigned int exec_get_num_threads() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_num_threads() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_time_tic_value
|
|
* C wrapper for Trick::Executive::get_time_tic_value
|
|
*/
|
|
extern "C" int exec_get_old_time_tic_value() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_old_time_tic_value() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_process_id
|
|
* C wrapper for Trick::Executive::get_process_id
|
|
*/
|
|
extern "C" unsigned int exec_get_process_id() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_process_id() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_rt_nap
|
|
* C wrapper for Trick::Executive::get_rt_nap
|
|
*/
|
|
extern "C" int exec_get_rt_nap() {
|
|
if ( the_exec != NULL ) {
|
|
return (int)the_exec->get_rt_nap() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_scheduled_start_index
|
|
* C wrapper for Trick::Executive::get_scheduled_start_index
|
|
*/
|
|
extern "C" int exec_get_scheduled_start_index() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_scheduled_start_index() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_sim_time
|
|
* C wrapper for Trick::Executive::get_sim_time
|
|
*/
|
|
extern "C" double exec_get_sim_time() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_sim_time() ;
|
|
}
|
|
return -1.0 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_software_frame
|
|
* C wrapper for Trick::Executive::get_software_frame
|
|
*/
|
|
extern "C" double exec_get_software_frame() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_software_frame() ;
|
|
}
|
|
return -1.0 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_software_frame_tics
|
|
* C wrapper for Trick::Executive::get_software_frame_tics
|
|
*/
|
|
extern "C" long long exec_get_software_frame_tics() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_software_frame_tics() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_frame_count
|
|
* C wrapper for Trick::Executive::get_frame_count
|
|
*/
|
|
extern "C" long long exec_get_frame_count() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_frame_count() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_stack_trace
|
|
* C wrapper for Trick::Executive::get_stack_trace
|
|
*/
|
|
extern "C" int exec_get_stack_trace() {
|
|
if ( the_exec != NULL ) {
|
|
return (int)the_exec->get_stack_trace() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_terminate_time
|
|
* C wrapper for Trick::Executive::get_terminate_time
|
|
*/
|
|
extern "C" double exec_get_terminate_time() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_terminate_time() ;
|
|
}
|
|
return -1.0 ;
|
|
}
|
|
|
|
extern "C" double exec_get_thread_amf_cycle_time(unsigned int thread_id) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_thread_amf_cycle_time(thread_id) ;
|
|
}
|
|
return -1.0 ;
|
|
}
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_time_tic_value
|
|
* C wrapper for Trick::Executive::get_time_tic_value
|
|
*/
|
|
extern "C" int exec_get_time_tic_value() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_time_tic_value() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_time_tics
|
|
* C wrapper for Trick::Executive::get_time_tics
|
|
*/
|
|
extern "C" long long exec_get_time_tics() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_time_tics() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_freeze_time_tics
|
|
* C wrapper for Trick::Executive::get_freeze_time_tics
|
|
*/
|
|
extern "C" long long exec_get_freeze_time_tics() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_freeze_time_tics() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_trap_sigbus
|
|
* C wrapper for Trick::Executive::get_trap_sigbus
|
|
*/
|
|
extern "C" int exec_get_trap_sigbus() {
|
|
if ( the_exec != NULL ) {
|
|
return (int)the_exec->get_trap_sigbus() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_trap_sigfpe
|
|
* C wrapper for Trick::Executive::get_trap_sigfpe
|
|
*/
|
|
extern "C" int exec_get_trap_sigfpe() {
|
|
if ( the_exec != NULL ) {
|
|
return (int)the_exec->get_trap_sigfpe() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_trap_sigsegv
|
|
* C wrapper for Trick::Executive::get_trap_sigsegv
|
|
*/
|
|
extern "C" int exec_get_trap_sigsegv() {
|
|
if ( the_exec != NULL ) {
|
|
return (int)the_exec->get_trap_sigsegv() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
// -------------------------- SET ------------------------
|
|
|
|
/**
|
|
@relates Trick::Executive
|
|
@copybrief Trick::Executive::set_attach_debugger
|
|
|
|
@par Python Usage:
|
|
@code trick.exec_set_attach_debugger(<on_off>) @endcode
|
|
|
|
C wrapper for Trick::Executive::set_attach_debugger
|
|
*/
|
|
extern "C" int exec_set_attach_debugger( int on_off ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_attach_debugger((bool)on_off) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
@relates Trick::Executive
|
|
@copydoc Trick::Executive::set_debugger_command
|
|
|
|
@par Python Usage:
|
|
@code trick.exec_set_debugger_command("<command>") @endcode
|
|
|
|
C wrapper for Trick::Executive::set_debugger_command
|
|
*/
|
|
extern "C" int exec_set_debugger_command( const char * command ) {
|
|
if ( the_exec != NULL ) {
|
|
return ( the_exec->set_debugger_command(std::string(command)) ) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_enable_freeze
|
|
* C wrapper for Trick::Executive::set_enable_freeze
|
|
*/
|
|
extern "C" int exec_set_enable_freeze( int on_off ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_enable_freeze((bool)on_off) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_exec_command
|
|
* C wrapper for Trick::Executive::set_exec_command
|
|
*/
|
|
// TODO: I don't think we need this function, too dangerous. (Alex 3/2/12)
|
|
extern "C" int exec_set_exec_command(SIM_COMMAND in_command) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_exec_command(in_command) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_freeze_command
|
|
* C wrapper for Trick::Executive::set_freeze_command
|
|
*/
|
|
extern "C" int exec_set_freeze_command( int on_off ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_freeze_command((bool)on_off) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_freeze_on_frame_boundary
|
|
* C wrapper for Trick::Executive::set_freeze_on_frame_boundary
|
|
*/
|
|
extern "C" int exec_set_freeze_on_frame_boundary( int on_off ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_freeze_on_frame_boundary((bool)on_off) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_freeze_frame
|
|
* C wrapper for Trick::Executive::set_freeze_frame
|
|
*/
|
|
extern "C" int exec_set_freeze_frame(double in_frame) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_freeze_frame(in_frame) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_rt_nap
|
|
* C wrapper for Trick::Executive::set_rt_nap
|
|
*/
|
|
extern "C" int exec_set_rt_nap( int on_off ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_rt_nap((bool)on_off) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_software_frame
|
|
* C wrapper for Trick::Executive::set_software_frame
|
|
*/
|
|
extern "C" int exec_set_software_frame(double in_frame) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_software_frame(in_frame) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_stack_trace
|
|
* C wrapper for Trick::Executive::set_stack_trace
|
|
*/
|
|
extern "C" int exec_set_stack_trace( int on_off ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_stack_trace((bool)on_off) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_terminate_time
|
|
* C wrapper for Trick::Executive::set_terminate_time
|
|
*/
|
|
extern "C" int exec_set_terminate_time(double time_value) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_terminate_time(time_value) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_time
|
|
* C wrapper for Trick::Executive::set_time
|
|
*/
|
|
extern "C" int exec_set_time( double in_time ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_time(in_time) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_time_tics
|
|
* C wrapper for Trick::Executive::set_time_tics
|
|
*/
|
|
extern "C" int exec_set_time_tics( long long in_time_tics ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_time_tics(in_time_tics) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_time_tic_value
|
|
* C wrapper for Trick::Executive::set_time_tic_value
|
|
*/
|
|
extern "C" int exec_set_time_tic_value( int in_time_tics ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_time_tic_value(in_time_tics) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_trap_sigbus
|
|
* C wrapper for Trick::Executive::set_trap_sigbus
|
|
*/
|
|
extern "C" int exec_set_trap_sigbus( int on_off ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_trap_sigbus((bool)on_off) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_trap_sigfpe
|
|
* C wrapper for Trick::Executive::set_trap_sigfpe
|
|
*/
|
|
extern "C" int exec_set_trap_sigfpe( int on_off ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_trap_sigfpe((bool)on_off) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_trap_sigsegv
|
|
* C wrapper for Trick::Executive::set_trap_sigsegv
|
|
*/
|
|
extern "C" int exec_set_trap_sigsegv( int on_off ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_trap_sigsegv((bool)on_off) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_job_onoff
|
|
* C wrapper for Trick::Executive::set_job_onoff
|
|
*/
|
|
extern "C" int exec_set_job_onoff(const char * job_name , int instance , int on) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_job_onoff( job_name , instance , on) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_sim_object_onoff
|
|
* C wrapper for Trick::Executive::set_sim_object_onoff
|
|
*/
|
|
extern "C" int exec_set_sim_object_onoff(const char * sim_object_name , int on) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_sim_object_onoff( sim_object_name , on) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_version_date_tag
|
|
* C wrapper for Trick::Executive::set_version_date_tag
|
|
*/
|
|
extern "C" int exec_set_version_date_tag(const char * tag) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_version_date_tag(std::string(tag)) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_build_date
|
|
* C wrapper for Trick::Executive::set_build_date
|
|
*/
|
|
extern "C" int exec_set_build_date(const char * date) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_build_date(std::string(date)) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_current_version
|
|
* C wrapper for Trick::Executive::set_current_version
|
|
*/
|
|
extern "C" int exec_set_current_version(const char * version) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_current_version(std::string(version)) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_current_version
|
|
* C wrapper for Trick::Executive::set_current_version
|
|
*/
|
|
extern "C" const char * exec_get_current_version() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_current_version().c_str() ;
|
|
}
|
|
return NULL ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @userdesc Raise a signal on the main thread to terminate the simuation immediately.
|
|
* This is not typically used by users. Use exec_terminate instead.
|
|
*/
|
|
extern "C" void exec_signal_terminate() {
|
|
// ret_code = 0 for this call.
|
|
if ( the_exec != NULL ) {
|
|
pthread_kill( the_exec->get_pthread_id(0) , SIGUSR1 ) ;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @userdesc C wrapper to transition to Shutdown mode. Throws Trick::ExecutiveException exception. This version
|
|
* @ is backwards compatible
|
|
* @param file_name - file name of the caller to exec_terminate
|
|
* @param error - error message to print
|
|
*/
|
|
extern "C" int exec_terminate(const char *file_name , const char *error ) {
|
|
throw Trick::ExecutiveException(0 , file_name , 0 , error) ;
|
|
// never reached
|
|
return 0 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @userdesc C wrapper to transition to Shutdown mode. Throws Trick::ExecutiveException exception
|
|
* @param ret_code - return code to pass back to caller of init() or loop() ;
|
|
* @param file_name - file name of the caller to exec_terminate
|
|
* @param line - line number where exception occurred
|
|
* @param error - error message to print
|
|
* @return ret_code (but never reached)
|
|
*/
|
|
extern "C" int exec_terminate_with_return(int ret_code , const char *file_name , int line , const char *error ) {
|
|
throw Trick::ExecutiveException(ret_code , file_name , line , error) ;
|
|
// never reached
|
|
return ret_code ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::freeze
|
|
* C wrapper for Trick::Executive::freeze
|
|
*/
|
|
extern "C" int exec_freeze() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->freeze() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::run
|
|
* C wrapper for Trick::Executive::run
|
|
*/
|
|
extern "C" int exec_run() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->run() ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
@userdesc C wrapper to add an instrumentation job before all initialization, integration,
|
|
scheduled, shutdown, top_of_frame & end_of_frame jobs.
|
|
* Calls Trick::Executive::instrument_job_before(job_name, "", NULL)
|
|
* @param job_name - name of the job to instrument. Name follows convention in RUN_<dir>/S_job_execution
|
|
* @return number of times the job was inserted
|
|
*/
|
|
extern "C" int exec_instrument_before(const char * job_name) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->instrument_job_before(job_name) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
@userdesc C wrapper to add an instrumentation job after all initialization, integration,
|
|
scheduled, shutdown, top_of_frame & end_of_frame jobs.
|
|
* Calls Trick::Executive::instrument_job_after(job_name, "", NULL)
|
|
* @param job_name - name of the job to instrument. Name follows convention in RUN_<dir>/S_job_execution
|
|
* @return number of times the job was inserted
|
|
*/
|
|
extern "C" int exec_instrument_after(const char * job_name) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->instrument_job_after(job_name) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
@userdesc C wrapper to remove all jobs with name job_name from all job queues.
|
|
* Calls Trick::Executive::instrument_job_remove(job_name, NULL)
|
|
* @param job_name - name of the job to remove. Name follows convention in RUN_<dir>/S_job_execution
|
|
* @return always 0
|
|
*/
|
|
extern "C" int exec_instrument_remove(const char * job_name) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->instrument_job_remove(job_name) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_thread_enabled
|
|
* C wrapper for Trick::Executive::set_thread_enabled
|
|
*/
|
|
extern "C" int exec_set_thread_enabled( unsigned int thread_id , int yes_no ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_thread_enabled(thread_id , yes_no) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_thread_amf_cycle_time
|
|
* C wrapper for Trick::Executive::set_thread_amf_cycle_time
|
|
*/
|
|
extern "C" int exec_set_thread_amf_cycle_time( unsigned int thread_id , double cycle_time ) {
|
|
return exec_set_thread_async_cycle_time(thread_id , cycle_time) ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_thread_async_cycle_time
|
|
* C wrapper for Trick::Executive::set_thread_async_cycle_time
|
|
*/
|
|
extern "C" int exec_set_thread_async_cycle_time( unsigned int thread_id , double cycle_time ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_thread_amf_cycle_time(thread_id , cycle_time) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_thread_async_wait
|
|
* C wrapper for Trick::Executive::set_thread_async_wait
|
|
*/
|
|
extern "C" int exec_set_thread_async_wait( unsigned int thread_id , int yes_no ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_thread_async_wait(thread_id , (bool)yes_no) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_thread_rt_semaphores
|
|
* C wrapper for Trick::Executive::set_thread_rt_semaphores
|
|
*/
|
|
extern "C" int exec_set_thread_rt_semaphores( unsigned int thread_id , int yes_no ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_thread_rt_semaphores(thread_id , (bool)yes_no) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_thread_cpu_affinity
|
|
* C wrapper for Trick::Executive::set_thread_cpu_affinity
|
|
*/
|
|
extern "C" int exec_set_thread_cpu_affinity(unsigned int thread_id , int cpu_num) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_thread_cpu_affinity(thread_id, cpu_num) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_thread_priority
|
|
* C wrapper for Trick::Executive::set_thread_priority
|
|
*/
|
|
extern "C" int exec_set_thread_priority(unsigned int thread_id , unsigned int req_priority) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_thread_priority(thread_id, req_priority) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_thread_process_type
|
|
* C wrapper for Trick::Executive::set_thread_process_type
|
|
*/
|
|
extern "C" int exec_set_thread_process_type( unsigned int thread_id , int process_type ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->set_thread_process_type(thread_id , process_type) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::set_job_cycle
|
|
* C wrapper for Trick::Executive::set_job_cycle
|
|
*/
|
|
extern "C" int exec_set_job_cycle(const char * job_name, int instance, double in_cycle) {
|
|
|
|
if ( the_exec != NULL ) {
|
|
std::string job_string ;
|
|
|
|
// Add handling for NULL string.
|
|
if ( job_name == NULL ) {
|
|
job_string.clear() ;
|
|
} else {
|
|
job_string = std::string(job_name) ;
|
|
}
|
|
return the_exec->set_job_cycle(job_string, instance, in_cycle) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::add_depends_on_job
|
|
* C wrapper for Trick::Executive::add_depends_on_job
|
|
*/
|
|
extern "C" int exec_add_scheduled_job_class(const char * in_name) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->add_scheduled_job_class(std::string(in_name)) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::add_depends_on_job
|
|
* C wrapper for Trick::Executive::add_depends_on_job
|
|
*/
|
|
extern "C" int exec_add_depends_on_job(const char * target_job_string , unsigned int t_instance , const char * depend_job_string , unsigned int d_instance ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->add_depends_on_job(std::string(target_job_string) , t_instance , std::string(depend_job_string) , d_instance ) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/*********************************************************/
|
|
/* These are executive access functions that stay C++ */
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::add_sim_object
|
|
* C wrapper for Trick::Executive::add_sim_object
|
|
*/
|
|
int exec_add_sim_object( Trick::SimObject * in_object , const char * in_name ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->add_sim_object(in_object , in_name) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::add_sim_object
|
|
* C wrapper for Trick::Executive::add_sim_object
|
|
*/
|
|
int exec_remove_sim_object( Trick::SimObject * in_object ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->delete_sim_object(in_object) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_sim_objects
|
|
* Wrapper for Trick::Executive::get_sim_objects
|
|
*/
|
|
int exec_get_sim_objects(std::vector<Trick::SimObject *>& in_sim_objects ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_sim_objects(in_sim_objects) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_job
|
|
* Wrapper for Trick::Executive::get_job
|
|
*/
|
|
Trick::JobData * exec_get_job(const char * job_name , unsigned int j_instance) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_job(std::string(job_name), j_instance) ;
|
|
}
|
|
return NULL ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_curr_job
|
|
* Wrapper for Trick::Executive::get_curr_job
|
|
*/
|
|
Trick::JobData * exec_get_curr_job() {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_curr_job() ;
|
|
}
|
|
return NULL ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_thread
|
|
* C wrapper for Trick::Executive::get_thread
|
|
*/
|
|
Trick::Threads * exec_get_thread( unsigned int thread_id ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_thread(thread_id) ;
|
|
}
|
|
return NULL ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::get_all_jobs_vector
|
|
* Wrapper for Trick::Executive::get_all_jobs_vector
|
|
*/
|
|
int exec_get_all_jobs_vector(std::vector<Trick::JobData *> & in_jobs_vector) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->get_all_jobs_vector(in_jobs_vector) ;
|
|
}
|
|
return 0 ;
|
|
}
|
|
|
|
/**
|
|
* @relates Trick::Executive
|
|
* @copydoc Trick::Executive::register_scheduler
|
|
* Wrapper for Trick::Executive::register_scheduler
|
|
*/
|
|
int exec_register_scheduler( Trick::Scheduler * scheduler ) {
|
|
if ( the_exec != NULL ) {
|
|
return the_exec->register_scheduler(scheduler) ;
|
|
}
|
|
return -1 ;
|
|
}
|
|
|