mirror of
https://github.com/nasa/trick.git
synced 2024-12-21 06:03:10 +00:00
7779dc568b
I made a number of changes to Trick to make it compile clean with clang++ -Wdocumentation, which checks doxygen comments. The changes were either to comments or to parameter names in function declarations. None of the changes have any impact on the compiled code.
276 lines
9.8 KiB
C++
276 lines
9.8 KiB
C++
/*
|
|
PURPOSE:
|
|
( The job class that the executive schedules and runs )
|
|
|
|
PROGRAMMERS:
|
|
((Alex Lin) (NASA) (May 2009) (OO))
|
|
*/
|
|
|
|
#ifndef JOBDATA_HH
|
|
#define JOBDATA_HH
|
|
|
|
#include <string>
|
|
#include <vector>
|
|
#include <set>
|
|
|
|
#include "trick/InstrumentBase.hh"
|
|
|
|
namespace Trick {
|
|
|
|
class SimObject ;
|
|
class InstrumentBase ;
|
|
|
|
/**
|
|
* This class is the base JobData class. Instances of this class are typically created
|
|
* within the Trick::SimObject::add_job routine. This class contains all of the class, cycle,
|
|
* start, and stop times of the job.
|
|
*
|
|
* @author Alexander S. Lin
|
|
*
|
|
* @date Jan. 2010
|
|
*
|
|
*/
|
|
|
|
class JobData {
|
|
|
|
public:
|
|
|
|
/** Job source code name */
|
|
std::string name; /**< trick_units(--) */
|
|
|
|
/** Indicates if the job is enabled */
|
|
bool disabled; /**< trick_units(--) */
|
|
|
|
/** Indicates if the job is complete */
|
|
bool complete; /**< trick_units(--) */
|
|
|
|
/** Indicates if a scheduler is handling this job */
|
|
bool handled; /**< trick_units(--) */
|
|
|
|
/** The cycle time */
|
|
double cycle; /**< trick_units(s) */
|
|
|
|
/** The start time */
|
|
double start; /**< trick_units(s) */
|
|
|
|
/** The stop time */
|
|
double stop; /**< trick_units(s) */
|
|
|
|
/** Supplemental data attached to this job. Typically used internally by instrumentation jobs */
|
|
void * sup_class_data; /**< trick_io(**) */
|
|
|
|
/** Job class id assigned by scheduler */
|
|
int job_class; /**< trick_units(--) */
|
|
|
|
/** Job class name as specified in S_define file */
|
|
std::string job_class_name; /**< trick_units(--) */
|
|
|
|
/** Indicates a system job class only valid for "system_*" and "automatic*" jobs. These classes of
|
|
jobs typically reschedule themselves and do not rely on the scheduler to determine the next call time */
|
|
int system_job_class ; /**< trick_units(--) */
|
|
|
|
/** Phase number */
|
|
unsigned short phase; /**< trick_units(--) */
|
|
|
|
/** Group tag names specified in S_define file */
|
|
std::set< std::string > tags; /**< trick_units(--) */
|
|
|
|
typedef std::set< std::string >::iterator TagsIterator ;
|
|
TagsIterator tags_begin() { return tags.begin() ; } ;
|
|
TagsIterator tags_end() { return tags.end() ; } ;
|
|
|
|
//TODO: Move frame information to it's own structure
|
|
/* Frame log information */
|
|
|
|
/** Clock time when job started in frame */
|
|
long long rt_start_time ; /**< trick_io(**) */
|
|
|
|
/** Clock time when job stopped in frame */
|
|
long long rt_stop_time ; /**< trick_io(**) */
|
|
|
|
/** Cumulative time used for job in frame (stop - start) */
|
|
long long frame_time ; /**< trick_io(**) */
|
|
|
|
/** Sim_object_id.id (for job identification in timeline logging) */
|
|
double frame_id; /**< trick_io(**) */
|
|
|
|
/** Thread specified in the S_define file */
|
|
unsigned int thread ; /**< trick_units(--) */
|
|
|
|
/** Job id assigned by CP */
|
|
int id; /**< trick_units(--) */
|
|
|
|
/** SimObject id assigned by CP */
|
|
int sim_object_id; /**< trick_units(--) */
|
|
|
|
/** Pointer back to parent SimObject. Used by scheduler to call actual job */
|
|
SimObject * parent_object ; /**< trick_io(**) */
|
|
|
|
/** Depends jobs specified in S_define file, added at initialization */
|
|
std::vector< JobData * > depends ; /**< trick_io(**) */
|
|
|
|
/** Instrumentation jobs to be run before this job */
|
|
std::vector< Trick::InstrumentBase * > inst_before ; /**< trick_io(**) */
|
|
|
|
/** Instrumentation jobs to be run after this job */
|
|
std::vector< Trick::InstrumentBase * > inst_after ; /**< trick_io(**) */
|
|
|
|
// Used internally by the scheduler integer timing.
|
|
/** Internal cycle rate in tics */
|
|
long long cycle_tics; /**< trick_units(--) */
|
|
|
|
/** Internal start rate in tics */
|
|
long long start_tics; /**< trick_units(--) */
|
|
|
|
/** Internal stop rate in tics */
|
|
long long stop_tics; /**< trick_units(--) */
|
|
|
|
/** Internal next rate in tics */
|
|
long long next_tics; /**< trick_units(--) */
|
|
|
|
/** time tic value from the executive */
|
|
static long long time_tic_value ; /**< trick_io(**) */
|
|
|
|
/** Constructor for new blank JobData instance */
|
|
JobData() ;
|
|
|
|
/**
|
|
* Constructor that is typically used in S_source.cpp
|
|
* @param in_thread - thread number specified in S_define
|
|
* @param in_id - job id given to job by CP
|
|
* @param in_job_class_name - job name specified in S_define
|
|
* @param in_sup_class_data - supplemental data to attach to job
|
|
* @param in_cycle - job cycle specified in S_define
|
|
* @param in_name - name of job specified in S_define
|
|
* @param in_tag - group tag name specified in S_define
|
|
* @param in_phase - job phase specified in S_define
|
|
* @param in_start - job start time specified in S_define
|
|
* @param in_stop - job stop time specified in S_define
|
|
*/
|
|
JobData(int in_thread, int in_id, std::string in_job_class_name , void* in_sup_class_data,
|
|
double in_cycle, std::string in_name, std::string in_tag = "", int in_phase = 60000 ,
|
|
double in_start = 0.0 , double in_stop = 1.0e37) ;
|
|
|
|
/** Default destructor that doesn't do anything */
|
|
virtual ~JobData() {} ;
|
|
|
|
/**
|
|
* Returns the job is handled flag
|
|
* @return the job is handled flag
|
|
*/
|
|
virtual bool get_handled() ;
|
|
|
|
/**
|
|
* Enable the job.
|
|
*/
|
|
void enable() ;
|
|
|
|
/**
|
|
* Disable the job.
|
|
*/
|
|
void disable() ;
|
|
|
|
/**
|
|
* Sets the job is handled flag
|
|
* @param yes_no - requested state of the handled flag
|
|
* @return always 0
|
|
*/
|
|
virtual int set_handled(bool yes_no) ;
|
|
|
|
/**
|
|
* Sets/Resets the static time_tic value
|
|
* @param in_time_tic_value - number of tics per second
|
|
* @return always 0
|
|
*/
|
|
static int set_time_tic_value(long long in_time_tic_value) ;
|
|
|
|
/**
|
|
* Sets/Resets the job cycle rate
|
|
* @param rate - desired cycle rate in seconds
|
|
* @return always 0
|
|
*/
|
|
virtual int set_cycle(double rate) ;
|
|
|
|
/**
|
|
* Calculates the cycle tics based on the cycle rate an the time_tic_value
|
|
* @return always 0
|
|
*/
|
|
virtual int calc_cycle_tics() ;
|
|
|
|
/**
|
|
* Sets the next job call time greater or equal to the incoming time_tics.
|
|
* @param time_tics - the current time in tics.
|
|
* @return always 0
|
|
*/
|
|
virtual int set_next_call_time(long long time_tics) ;
|
|
|
|
/**
|
|
* Sets the system job flag
|
|
* @param yes_no - requested state of the system job flag
|
|
* @return always 0
|
|
*/
|
|
virtual int set_system_job_class(bool yes_no) ;
|
|
|
|
/**
|
|
* Adds another job as a dependency to this job
|
|
* @param in_tag - JobData instance of depends_on job
|
|
* @return always 0
|
|
*/
|
|
virtual int add_tag( std::string in_tag) ;
|
|
|
|
/**
|
|
* Adds another job as a dependency to this job
|
|
* @param depend - JobData instance of depends_on job
|
|
* @return always 0
|
|
*/
|
|
virtual int add_depend( JobData * depend ) ;
|
|
|
|
/**
|
|
* Adds an instrumentation job to the before list
|
|
* @param in_job - JobData instance of instrumentation job
|
|
* @return always 0
|
|
*/
|
|
virtual int add_inst_before( InstrumentBase * in_job ) ;
|
|
|
|
/**
|
|
* Adds an instrumentation job to the before list
|
|
* @param in_job - JobData instance of instrumentation job
|
|
* @return always 0
|
|
*/
|
|
virtual int add_inst_after( InstrumentBase * in_job ) ;
|
|
|
|
/**
|
|
* Removes an instrumentation job that matches the incoming job name
|
|
* @param job_name - job name
|
|
* @return always 0
|
|
*/
|
|
virtual int remove_inst( std::string job_name ) ;
|
|
|
|
/**
|
|
* Calls the instumentation jobs and the job itself.
|
|
* @return always 0
|
|
*/
|
|
virtual int call() ;
|
|
|
|
/**
|
|
* Calls the instumentation jobs and the job itself.
|
|
* @return always 0
|
|
*/
|
|
virtual double call_double() ;
|
|
|
|
/**
|
|
* Copy command that takes checkpoint data and merges with existing
|
|
* job with the same name. This allows checkpoints that may have different
|
|
* id numbers (job_id or sim_object_ids) to be restored without breaking
|
|
* the bond between the current job_ids and the call_function routines in S_source.cpp
|
|
* @return always 0
|
|
*/
|
|
virtual int copy_from_checkpoint( JobData * in_job ) ;
|
|
|
|
} ;
|
|
|
|
} ;
|
|
|
|
#endif
|
|
|