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
|
/* -*- C++ -*- */
// $Id$
// ============================================================================
//
// = LIBRARY
// ACE
//
// = FILENAME
// Sched_Params.h
//
// = CREATION DATE
// 28 January 1997
//
// = AUTHOR
// David Levine and Carlos O'Ryan
//
// ============================================================================
#if !defined (ACE_SCHED_PARAMS_H)
#define ACE_SCHED_PARAMS_H
#include "ace/OS.h"
class ACE_Export ACE_Sched_Params
// = TITLE
// Container for scheduling-related parameters.
//
// = DESCRIPTION
// ACE_Sched_Params are passed via
// ACE_OS::sched_params () to the OS to specify scheduling
// parameters. These parameters include scheduling policy,
// such as FIFO, round-robin, or an implementation-defined
// "OTHER" (to which many systems default); priority; and
// a time-slice quantum for round-robin scheduling.
// A "scope" parameter specifies whether the ACE_Sched_Params
// applies to the current process, current lightweight process
// (LWP) (on Solaris), or current thread. Please see the "NOTE"
// below about not all combinations of parameters being legal
// on a particular platform.
//
// For the case of thread priorities, it is intended that
// ACE_OS::sched_params () usually be called from main () before
// any threads have been spawned.
// If spawned threads inherit their parent's priority (I think
// that's the default behavior for all of our platforms), then
// this sets the default base priority. Individual thread priorities
// can be adjusted as usual using ACE_OS::thr_prio () or via the
// ACE_Thread interface. See the parameter descriptions in the
// private: section below.
//
// NOTE: this class does not do any checking of parameters.
// It is just a container class. If it is constructed with values
// that are not supported on a platform, the call to
// ACE_OS::sched_params () will fail by returning -1 with EINVAL
// (available through ACE_OS::last_error ()).
// OS Scheduling parameters are complicated and often confusing. Many
// thanks to Thilo Kielmann <kielmann@informatik.uni-siegen.de> for his
// careful review of this class design, thoughtful comments, and
// assistance with implementation, especially for PTHREADS platforms.
// Please send any comments or corrections to the ACE developers.
{
public:
typedef int Policy;
// = Initialization and termination methods.
ACE_Sched_Params (const Policy policy,
const ACE_Sched_Priority priority,
const int scope = ACE_SCOPE_THREAD,
const ACE_Time_Value &quantum = ACE_Time_Value::zero);
// Constructor.
~ACE_Sched_Params (void);
// Termination.
// = Get/Set methods:
// = Get/Set policy
Policy policy (void) const;
void policy (const Policy);
// = Get/Set priority.
ACE_Sched_Priority priority (void) const;
void priority (const ACE_Sched_Priority);
// = Get/Set scope.
int scope (void) const;
void scope(const int);
// = Get/Set quantum.
const ACE_Time_Value &quantum (void) const;
void quantum (const ACE_Time_Value &);
// = Accessors for OS-specific priorities.
// These return priority values for ACE_SCHED_OTHER if the Policy value
// is invalid.
static int priority_min (const Policy,
const int scope = ACE_SCOPE_THREAD);
static int priority_max (const Policy,
const int scope = ACE_SCOPE_THREAD);
static int next_priority (const Policy,
const int priority,
const int scope = ACE_SCOPE_THREAD);
// The next higher priority. "Higher" refers to scheduling priority,
// not to the priority value itself. (On some platforms, higher scheduling
// priority is indicated by a lower priority value.) If "priority" is
// already the highest priority (for the specified policy), then it is
// returned.
static int previous_priority (const Policy,
const int priority,
const int scope = ACE_SCOPE_THREAD);
// The previous, lower priority. "Lower" refers to scheduling priority,
// not to the priority value itself. (On some platforms, lower scheduling
// priority is indicated by a higher priority value.) If "priority" is
// already the lowest priority (for the specified policy), then it is
// returned.
private:
Policy policy_;
// Scheduling policy.
ACE_Sched_Priority priority_;
// Default <priority_>: for setting the priority for the process, LWP,
// or thread, as indicated by the scope_ parameter.
int scope_;
// <scope_> must be one of the following:
// ACE_SCOPE_PROCESS: sets the scheduling policy for the
// process, and the process priority. On some platforms,
// such as Win32, the scheduling policy can _only_ be
// set at process scope.
// ACE_SCOPE_LWP: lightweight process scope, only used with
// Solaris threads.
// ACE_SCOPE_THREAD: sets the scheduling policy for the thread,
// if the OS supports it, such as with Posix threads, and the
// thread priority.
// NOTE: I don't think that these are the same as POSIX
// contention scope. POSIX users who are interested in,
// and understand, contention scope will have to set it
// by using system calls outside of ACE.
ACE_Time_Value quantum_;
// The <quantum_> is for time slicing. An ACE_Time_Value of 0 has
// special significance: it means time-slicing is disabled; with
// that, a thread that is running on a CPU will continue to run
// until it blocks or is preempted. Currently ignored if the OS
// doesn't directly support time slicing, such as on VxWorks, or
// setting the quantum (can that be done on Win32?).
};
class ACE_Export ACE_Sched_Priority_Iterator
// = TITLE
// An iterator over the OS-defined scheduling priorities.
//
// = DESCRIPTION
// The order of priorities (numeric value vs. importance) is OS
// dependant, it can be the case that the priorities are not even
// contigous. This class permits iteration over priorities using
// the iterator pattern.
{
public:
ACE_Sched_Priority_Iterator (const ACE_Sched_Params::Policy &policy,
int scope = ACE_SCOPE_THREAD);
// Initialize the iterator, the arguments define the scheduling
// policy and scope for the priorities (see ACE_Sched_Param).
int more (void) const;
// Check if there are more priorities.
int priority (void) const;
// Return the current priority
void next (void);
// Move to the next priority.
// The iteration is from lowest to highest importance.
const ACE_Sched_Params::Policy &policy (void) const;
// Accessor for the scheduling policy over which we are iterating.
int scope (void) const;
// Accessor for the scheduling
private:
ACE_Sched_Params::Policy policy_;
int scope_;
// The Scheduling policy (FIFO, RR, etc.) and scheduling scope
// (PROCESS, SYSTEM) we are iterating on.
int priority_;
// The current priority.
int done_;
// This is set to 1 when there are no more priorities. Cannot easily
// compare against the highest priority on platforms were priorities
// are non-contigous or descending.
};
#if defined (__ACE_INLINE__)
#include "ace/Sched_Params.i"
#endif /* __ACE_INLINE__ */
#endif /* ACE_SCHED_PARAMS_H */
|
