1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
|
// -*- C++ -*-
//=============================================================================
/**
* @file Scheduler_Factory.h
*
* @author Chris Gill <cdgill@cs.wustl.edu>
*/
//=============================================================================
#ifndef ACE_SCHEDULER_FACTORY_H
#define ACE_SCHEDULER_FACTORY_H
#include /**/ "ace/pre.h"
#include "ace/Containers_T.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "orbsvcs/CosNamingC.h"
#include "orbsvcs/RtecSchedulerC.h"
#include "orbsvcs/Sched/sched_export.h"
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
class TAO_Reconfig_Scheduler_Entry;
struct TAO_RT_Info_Tuple;
typedef ACE_Ordered_MultiSet<TAO_RT_Info_Tuple *> TUPLE_SET;
typedef ACE_Ordered_MultiSet_Iterator<TAO_RT_Info_Tuple *> TUPLE_SET_ITERATOR;
/**
* @class ACE_Scheduler_Factory
*
* @brief Factory of scheduler services.
*
* This class acts as a factory for scheduler servers. At config
* time it will return a remote server, which will actually
* compute the scheduling parameters. At run-time it returns a
* local server, which will use the results of the config runs to
* actually do the scheduling, without incurring in RPC overheads.
*/
class TAO_RTSched_Export ACE_Scheduler_Factory
{
public:
/*
* This type enumerates the possible states of the factory:
* uninitialized, or in a configuration, runtime, or
* reconfigurable mode of operation.
*/
enum Factory_Status
{
UNINITIALIZED,
CONFIG,
RECONFIG,
RUNTIME
};
/*
* @brief Plain Old Data for RT_Infos.
*
* This class provide us with a plain old data version of
* RT_Info, this is useful for implementing arrays of
* those.
*/
struct POD_RT_Info
{
const char *entry_point;
RtecScheduler::handle_t handle;
RtecScheduler::Time worst_case_execution_time;
RtecScheduler::Time typical_execution_time;
RtecScheduler::Time cached_execution_time;
RtecScheduler::Period_t period;
CORBA::Long criticality;
CORBA::Long importance;
RtecScheduler::Quantum_t quantum;
RtecScheduler::Threads_t threads;
RtecScheduler::OS_Priority priority;
RtecScheduler::Preemption_Subpriority_t static_subpriority;
RtecScheduler::Preemption_Priority_t preemption_priority;
CORBA::Long info_type;
RtecScheduler::RT_Info_Enabled_Type_t enabled;
};
struct POD_Dependency_Info
{
// = TITLE
// Plain Old Data for RT_Info Dependencies.
//
// = DESCRIPTION
// This class provide us with a plain old data version of
// dependencies between RT_Infos. This is useful for implementing
// arrays of those.
RtecScheduler::Dependency_Type_t dependency_type;
CORBA::Long number_of_calls;
RtecScheduler::handle_t info_that_depends;
RtecScheduler::handle_t info_depended_on;
RtecScheduler::Dependency_Enabled_Type_t enabled;
};
struct POD_Config_Info
{
// = TITLE
// Plain Old Data for dispatch queue configuration information.
//
// = DESCRIPTION
// This class provide us with a plain old data version of
// configuration info, which is useful for implementing static arrays
// NOTE: if used in an array, the run-time scheduler requires that the
// array index match the preemption priority stored in the config info
// at that index: this is used to detect uninitialized/corrupted schedules
RtecScheduler::Preemption_Priority_t preemption_priority;
RtecScheduler::OS_Priority thread_priority;
RtecScheduler::Dispatching_Type_t dispatching_type;
};
struct POD_Scheduling_Anomaly
{
// = TITLE
// Plain Old Data for scheduling anomaly information.
//
// = DESCRIPTION
// This class provide us with a plain old data version of
// scheduling anomalies, which is used to generate error
// and warning lines in the runtime scheduling header output.
const char* description;
RtecScheduler::Anomaly_Severity severity;
};
/// Setup the variables needed for a config run, using the
/// NamingContext to locate a Scheduler.
static int use_config (CosNaming::NamingContext_ptr naming);
/// Setup the variables needed for a config run, using the
/// NamingContext to locate a Scheduler.
static int use_config (CosNaming::NamingContext_ptr naming,
const char* name);
/// Disable config runs in the Factory and sets up the precomputed
/// scheduling information.
static int use_runtime (int cc,
POD_Config_Info cfgi[],
int ec,
POD_RT_Info rti[]);
/**
* Return the Real-time Scheduling Service used for this run.
* Must have been configured either using use_context() or use_data().
*
* Normally use_data() is called at static elaboration time, so
* everything is automatic. On config runs use_context() is called
* from main, after resolve_initial_references.
*/
static int server (RtecScheduler::Scheduler_ptr);
static RtecScheduler::Scheduler_ptr server (void);
/**
* This helper function will dump the schedule returned by a
* RtecScheduler::Scheduler into a file, the file can be compiled to
* create an efficient local implementation of the Scheduler.
*/
static int dump_schedule (const RtecScheduler::RT_Info_Set& infos,
const RtecScheduler::Dependency_Set& dependencies,
const RtecScheduler::Config_Info_Set& configs,
const RtecScheduler::Scheduling_Anomaly_Set& anomalies,
const ACE_TCHAR* file_name = 0,
const char* rt_info_format = 0,
const char* dependency_format = 0,
const char* config_info_format = 0,
int dump_disabled_infos = 0,
int dump_disabled_dependencies = 0);
// TODO: How to do cleanup()? Use the ACE_Object_Manager stuff?
/// This helper function prints out a single scheduling entry contents
static void log_scheduling_entry(TAO_Reconfig_Scheduler_Entry * entry,
FILE* file);
/// This helper function prints out the intermediate scheduling entries
static int log_scheduling_entries(TAO_Reconfig_Scheduler_Entry ** entry_ptr_array,
long entry_ptr_array_size,
const char* file_name);
/// This helper function prints out the arry used to create scheduling entries
/// sorted in topological order then priority order
static void log_scheduling_tuples(TAO_RT_Info_Tuple ** tuple_ptr_array,
long tuple_ptr_array_size,
const char* file_name);
static void log_tuple_subset(TUPLE_SET & tuple_subset,
FILE* file);
/**
* This helper function allows the application to determine whether
* the factory is uninitialized, or in a config or runtime mode of
* operation.
*/
static Factory_Status status (void);
// = Access the (OS independent) preemption priority of the calling thread.
/// Returns (u_int) -1 if the preemption priority hadn't been set.
static RtecScheduler::Preemption_Priority_t preemption_priority ();
// = Set the (OS independent) preemption priority of the calling thread.
/**
* The application or Event Channel is responsible for making sure
* that the preemption priority is set before any access of the
* preemption priority.
*/
static void set_preemption_priority
(const RtecScheduler::Preemption_Priority_t);
// Accessor for obtaining the default period (Boeing Extension)
/// Method for setting the default period (Boeing Extension)
static RtecScheduler::Period_t period_default();
static void period_default(RtecScheduler::Period_t period_default);
// Accessor for obtaining the default threads (Boeing Extension)
/// Method for setting the default threads (Boeing Extension)
static RtecScheduler::Threads_t threads_default();
static void threads_default(RtecScheduler::Threads_t threads_default);
// Accessor for obtaining the default importance (VERY_LOW_IMPORTANCE to VERY_HIGH_IMPORTANCE). (Boeing Extension)
/// Method for setting the default importance (VERY_LOW_IMPORTANCE to VERY_HIGH_IMPORTANCE). (Boeing Extension)
static RtecScheduler::Importance_t importance_default();
static void importance_default(RtecScheduler::Importance_t importance_default);
// Accessor for obtaining the default criticality (VERY_LOW_CRITICALITY to VERY_HIGH_CRITICALITY). (Boeing Extension)
/// Method for setting the default criticality (VERY_LOW_CRITICALITY to VERY_HIGH_CRITICALITY). (Boeing Extension)
static RtecScheduler::Criticality_t criticality_default();
static void criticality_default(RtecScheduler::Criticality_t criticality_default);
// Accessor for obtaining the default rt_info enabled state. (RT_INFO_DISABLED, RT_INFO_ENABLED, or RT_INFO_NON_VOLATILE)
static RtecScheduler::RT_Info_Enabled_Type_t rt_info_enable_state_default();
// Method for setting the default rt_info enabled state. (RT_INFO_DISABLED, RT_INFO_ENABLED, or RT_INFO_NON_VOLATILE)
static void rt_info_enable_state_default(RtecScheduler::RT_Info_Enabled_Type_t rt_info_enable_state_default);
protected:
/**
* By default this factory assumes we are runnning a config
* run. Calling this method disables that. Since the methods
* returns an int it can be used to initialize a static variable,
* hence calling it before main(); this technique can be used in the
* code emitted for the run-time scheduler, automagically disabling
* the config_run() when that code is linked in.
*/
static int no_config_run (void);
private:
static RtecScheduler::Scheduler_ptr server_;
static Factory_Status status_;
/// Default period configuration. (Boeing Extension)
static RtecScheduler::Period_t period_default_;
/// Default threads configuration. (Boeing Extension)
static RtecScheduler::Threads_t threads_default_;
/// Default importance configuration. (Boeing Extension)
static RtecScheduler::Importance_t importance_default_;
/// Default criticality. (Boeing Extension)
static RtecScheduler::Criticality_t criticality_default_;
/// Default rt_info enabled state. (Boeing Extension)
static RtecScheduler::RT_Info_Enabled_Type_t rt_info_enable_state_default_;
};
TAO_END_VERSIONED_NAMESPACE_DECL
#if defined (__ACE_INLINE__)
#include "orbsvcs/Scheduler_Factory.inl"
#endif /* __ACE_INLINE__ */
#include /**/ "ace/post.h"
#endif /* ACE_SCHEDULER_FACTORY_H */
|