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
|
/**
* @file rtems/score/schedulerpriority.h
*
* This include file contains all the constants and structures associated
* with the manipulation of threads for the priority-based scheduler.
*/
/*
* Copryight (c) 2010 Gedare Bloom.
* Copyright (C) 2011 On-Line Applications Research Corporation (OAR).
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rtems.com/license/LICENSE.
*
* $Id$
*/
#ifndef _RTEMS_SCORE_SCHEDULERPRIORITY_H
#define _RTEMS_SCORE_SCHEDULERPRIORITY_H
#include <rtems/score/chain.h>
#include <rtems/score/priority.h>
#include <rtems/score/scheduler.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @addtogroup ScoreScheduler
*
*/
/**@{*/
/**
* Entry points for the Deterministic Priority Based Scheduler.
*/
#define SCHEDULER_PRIORITY_ENTRY_POINTS \
{ \
_Scheduler_priority_Initialize, /* initialize entry point */ \
_Scheduler_priority_Schedule, /* schedule entry point */ \
_Scheduler_priority_Yield, /* yield entry point */ \
_Scheduler_priority_Block, /* block entry point */ \
_Scheduler_priority_Unblock, /* unblock entry point */ \
_Scheduler_priority_Allocate, /* allocate entry point */ \
_Scheduler_priority_Free, /* free entry point */ \
_Scheduler_priority_Update, /* update entry point */ \
_Scheduler_priority_Enqueue, /* enqueue entry point */ \
_Scheduler_priority_Enqueue_first, /* enqueue_first entry point */ \
_Scheduler_priority_Extract /* extract entry point */ \
}
/**
* Per-thread data related to the _Scheduler_PRIORITY scheduling policy.
*/
typedef struct {
/** This field points to the Ready FIFO for this thread's priority. */
Chain_Control *ready_chain;
/** This field contains precalculated priority map indices. */
Priority_bit_map_Information Priority_map;
} Scheduler_priority_Per_thread;
/**
* This routine initializes the priority scheduler.
*/
void _Scheduler_priority_Initialize(void);
/**
* This routine removes @a the_thread from the scheduling decision,
* that is, removes it from the ready queue. It performs
* any necessary scheduling operations including the selection of
* a new heir thread.
*
* @param[in] the_thread is the thread to be blocked
*/
void _Scheduler_priority_Block(
Thread_Control *the_thread
);
/**
* This kernel routine sets the heir thread to be the next ready thread
* by invoking the_scheduler->ready_queue->operations->first().
*/
void _Scheduler_priority_Schedule(void);
/**
* This routine allocates @a the_thread->scheduler.
*
* @param[in] the_thread is the thread the scheduler is allocating
* management memory for
*/
void * _Scheduler_priority_Allocate(
Thread_Control *the_thread
);
/**
* This routine frees @a the_thread->scheduler.
*
* @param[in] the_thread is the thread whose scheduler specific information
* will be deallocated.
*/
void _Scheduler_priority_Free(
Thread_Control *the_thread
);
/**
* This routine updates @a the_thread->scheduler based on @a the_scheduler
* structures and thread state.
*
* @param[in] the_thread will have its scheduler specific information
* structure updated.
*/
void _Scheduler_priority_Update(
Thread_Control *the_thread
);
/**
* This routine adds @a the_thread to the scheduling decision,
* that is, adds it to the ready queue and
* updates any appropriate scheduling variables, for example the heir thread.
*
* @param[in] the_thread will be unblocked
*/
void _Scheduler_priority_Unblock(
Thread_Control *the_thread
);
/**
* This routine is invoked when a thread wishes to voluntarily
* transfer control of the processor to another thread in the queue.
*
* This routine will remove the running THREAD from the ready queue
* and place it immediately at the rear of this chain. Reset timeslice
* and yield the processor functions both use this routine, therefore if
* reset is true and this is the only thread on the queue then the
* timeslice counter is reset. The heir THREAD will be updated if the
* running is also the currently the heir.
*/
void _Scheduler_priority_Yield( void );
/**
* This routine puts @a the_thread on to the priority-based ready queue.
*
* @param[in] the_thread will be enqueued at the TAIL of its priority.
*/
void _Scheduler_priority_Enqueue(
Thread_Control *the_thread
);
/**
* This routine puts @a the_thread to the head of the ready queue.
* For priority-based ready queues, the thread will be the first thread
* at its priority level.
*
* @param[in] the_thread will be enqueued at the HEAD of its priority.
*/
void _Scheduler_priority_Enqueue_first(
Thread_Control *the_thread
);
/**
* This routine removes a specific thread from the scheduler's set
* of ready threads.
*
* @param[in] the_thread will be extracted from the ready set.
*/
void _Scheduler_priority_Extract(
Thread_Control *the_thread
);
/**
* This is the major bit map.
*/
extern volatile Priority_bit_map_Control _Priority_Major_bit_map;
/**
* This is the minor bit map.
*/
extern Priority_bit_map_Control _Priority_Bit_map[16] CPU_STRUCTURE_ALIGNMENT;
#ifndef __RTEMS_APPLICATION__
#include <rtems/score/schedulerpriority.inl>
#endif
#ifdef __cplusplus
}
#endif
/**@}*/
#endif
/* end of include file */
|
