summaryrefslogtreecommitdiffstats
path: root/cpukit/score/include/rtems/score/schedulersimple.h
blob: fb883bb9c3204058d3bd3b458c2bea14078153c0 (plain) (blame)
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
/**
 *  @file  rtems/score/schedulersimple.h
 *
 *  This include file contains all the constants and structures associated
 *  with the manipulation of threads on a simple-priority-based ready queue.
 *
 *
 *  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.
 */

#ifndef _RTEMS_SCORE_SCHEDULERSIMPLE_H
#define _RTEMS_SCORE_SCHEDULERSIMPLE_H

/**
 *  @addtogroup ScoreScheduler
 *
 */
/**@{*/

#ifdef __cplusplus
extern "C" {
#endif

#include <rtems/score/scheduler.h>
#include <rtems/score/schedulerpriority.h>

/**
 *  Entry points for Scheduler Simple
 */
#define SCHEDULER_SIMPLE_ENTRY_POINTS \
  { \
    _Scheduler_simple_Initialize,         /* initialize entry point */ \
    _Scheduler_simple_Schedule,           /* schedule entry point */ \
    _Scheduler_simple_Yield,              /* yield entry point */ \
    _Scheduler_simple_Block,              /* block entry point */ \
    _Scheduler_simple_Unblock,            /* unblock entry point */ \
    _Scheduler_simple_Allocate,           /* allocate entry point */ \
    _Scheduler_simple_Free,               /* free entry point */ \
    _Scheduler_simple_Update,             /* update entry point */ \
    _Scheduler_simple_Enqueue,            /* enqueue entry point */ \
    _Scheduler_simple_Enqueue_first,      /* enqueue_first entry point */ \
    _Scheduler_simple_Extract,            /* extract entry point */ \
    _Scheduler_priority_Priority_compare, /* compares two priorities */ \
    _Scheduler_priority_Release_job,      /* new period of task */ \
    _Scheduler_priority_Tick              /* tick entry point */ \
  }

/**
 * This routine initializes the simple scheduler.
 */
void _Scheduler_simple_Initialize( void );

/**
 *  This routine sets the heir thread to be the next ready thread
 *  on the ready queue by getting the first node in the scheduler
 *  information.
 */
void _Scheduler_simple_Schedule( void );

/**
 *  This routine is invoked when a thread wishes to voluntarily
 *  transfer control of the processor to another thread in the queue.
 *  It will remove the running THREAD from the scheduler.informaiton
 *  (where the ready queue is stored) and place it immediately at the
 *  between the last entry of its priority and the next priority thread.
 *  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_simple_Yield( 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 that is to be blocked
 */
void _Scheduler_simple_Block(
  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 is the thread that is to be unblocked
 */
void _Scheduler_simple_Unblock(
  Thread_Control *the_thread
);

/**
 *  This routine removes a specific thread from the specified
 *  simple-based ready queue.
 *
 *  @param[in] the_thread is the thread to be blocked
 */
void _Scheduler_simple_Extract(
  Thread_Control *the_thread
);

/**
 *  This routine puts @a the_thread on to the ready queue.
 *
 *  @param[in] the_thread is the thread to be blocked
 */
void _Scheduler_simple_Enqueue(
  Thread_Control *the_thread
);

/**
 *  This routine puts @a the_thread to the head of the ready queue.
 *  The thread will be the first thread at its priority level.
 *
 *  @param[in] the_thread is the thread to be blocked
 */
void _Scheduler_simple_Enqueue_first(
  Thread_Control *the_thread
);

/**
 *  This routine is a place holder for any memeory allocation needed
 *  by the scheduler.  For the simple scheduler the routine is an empty
 *  place holder.
 *
 *  @param[in] the_thread is the thread the scheduler is allocating
 *             management memory for
 *
 *  @return this routine returns -1 since this is just an empty placeholder
 *  and the return value may be defined differently by each scheduler.
 */
void *_Scheduler_simple_Allocate(
  Thread_Control *the_thread
);

/**
 * This routine does nothing, and is used as a stub for Schedule update
 *
 * The overhead of a function call will still be imposed.
 *
 *  @param[in] the_thread is the thread to be blocked
 */
void _Scheduler_simple_Update(
  Thread_Control *the_thread
);

/**
 * This routine does nothing, and is used as a stub for Schedule free
 *
 * The overhead of a function call will still be imposed.
 *
 *  @param[in] the_thread is the thread to be blocked
 */
void _Scheduler_simple_Free(
  Thread_Control *the_thread
);

/**
 *  _Scheduler_simple_Ready_queue_enqueue
 *
 *  This routine puts @a the_thread on the ready queue
 *  at the end of its priority group.
 *
 *  @param[in] the_thread - pointer to a thread control block
 */
void _Scheduler_simple_Ready_queue_enqueue(
  Thread_Control    *the_thread
);

/**
 *  _Scheduler_simple_Ready_queue_enqueue_first
 *
 *  This routine puts @a the_thread on to the ready queue
 *  at the beginning of its priority group.
 *
 *  @param[in] the_thread - pointer to a thread control block
 */
void _Scheduler_simple_Ready_queue_enqueue_first(
  Thread_Control    *the_thread
);

#ifndef __RTEMS_APPLICATION__
#include <rtems/score/schedulersimple.inl>
#endif

#ifdef __cplusplus
}
#endif

/**@}*/

#endif
/* end of include file */