OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [rtos/] [ecos-2.0/] [doc/] [html/] [ref/] [kernel-schedcontrol.html] - Blame information for rev 482

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 28 unneback 
<!-- Copyright (C) 2003 Red Hat, Inc.                                -->
2 
<!-- This material may be distributed only subject to the terms      -->
3 
<!-- and conditions set forth in the Open Publication License, v1.0  -->
4 
<!-- or later (the latest version is presently available at          -->
5 
<!-- http://www.opencontent.org/openpub/).                           -->
6 
<!-- Distribution of the work or derivative of the work in any       -->
7 
<!-- standard (paper) book form is prohibited unless prior           -->
8 
<!-- permission is obtained from the copyright holder.               -->
9 
<HTML
10 
><HEAD
11 
><TITLE
12 
>Scheduler Control</TITLE
13 
><meta name="MSSmartTagsPreventParsing" content="TRUE">
14 
<META
15 
NAME="GENERATOR"
16 
CONTENT="Modular DocBook HTML Stylesheet Version 1.76b+
17 
"><LINK
18 
REL="HOME"
19 
TITLE="eCos Reference Manual"
20 
HREF="ecos-ref.html"><LINK
21 
REL="UP"
22 
TITLE="The eCos Kernel"
23 
HREF="kernel.html"><LINK
24 
REL="PREVIOUS"
25 
TITLE="Spinlocks"
26 
HREF="kernel-spinlocks.html"><LINK
27 
REL="NEXT"
28 
TITLE="Interrupt Handling"
29 
HREF="kernel-interrupts.html"></HEAD
30 
><BODY
31 
CLASS="REFENTRY"
32 
BGCOLOR="#FFFFFF"
33 
TEXT="#000000"
34 
LINK="#0000FF"
35 
VLINK="#840084"
36 
ALINK="#0000FF"
37 
><DIV
38 
CLASS="NAVHEADER"
39 
><TABLE
40 
SUMMARY="Header navigation table"
41 
WIDTH="100%"
42 
BORDER="0"
43 
CELLPADDING="0"
44 
CELLSPACING="0"
45 
><TR
46 
><TH
47 
COLSPAN="3"
48 
ALIGN="center"
49 
>eCos Reference Manual</TH
50 
></TR
51 
><TR
52 
><TD
53 
WIDTH="10%"
54 
ALIGN="left"
55 
VALIGN="bottom"
56 
><A
57 
HREF="kernel-spinlocks.html"
58 
ACCESSKEY="P"
59 
>Prev</A
60 
></TD
61 
><TD
62 
WIDTH="80%"
63 
ALIGN="center"
64 
VALIGN="bottom"
65 
></TD
66 
><TD
67 
WIDTH="10%"
68 
ALIGN="right"
69 
VALIGN="bottom"
70 
><A
71 
HREF="kernel-interrupts.html"
72 
ACCESSKEY="N"
73 
>Next</A
74 
></TD
75 
></TR
76 
></TABLE
77 
><HR
78 
ALIGN="LEFT"
79 
WIDTH="100%"></DIV
80 
><H1
81 
><A
82 
NAME="KERNEL-SCHEDCONTROL">Scheduler Control</H1
83 
><DIV
84 
CLASS="REFNAMEDIV"
85 
><A
86 
NAME="AEN1784"
87 
></A
88 
><H2
89 
>Name</H2
90 
>cyg_scheduler_start, cyg_scheduler_lock, cyg_scheduler_unlock, cyg_scheduler_safe_lock, cyg_scheduler_read_lock&nbsp;--&nbsp;Control the state of the scheduler</DIV
91 
><DIV
92 
CLASS="REFSYNOPSISDIV"
93 
><A
94 
NAME="AEN1791"><H2
95 
>Synopsis</H2
96 
><DIV
97 
CLASS="FUNCSYNOPSIS"
98 
><A
99 
NAME="AEN1792"><P
100 
></P
101 
><TABLE
102 
BORDER="5"
103 
BGCOLOR="#E0E0F0"
104 
WIDTH="70%"
105 
><TR
106 
><TD
107 
><PRE
108 
CLASS="FUNCSYNOPSISINFO"
109 
>#include &lt;cyg/kernel/kapi.h&gt;
110 
        </PRE
111 
></TD
112 
></TR
113 
></TABLE
114 
><P
115 
><CODE
116 
><CODE
117 
CLASS="FUNCDEF"
118 
>void cyg_scheduler_start</CODE
119 
>(void);</CODE
120 
></P
121 
><P
122 
><CODE
123 
><CODE
124 
CLASS="FUNCDEF"
125 
>void cyg_scheduler_lock</CODE
126 
>(void);</CODE
127 
></P
128 
><P
129 
><CODE
130 
><CODE
131 
CLASS="FUNCDEF"
132 
>void cyg_scheduler_unlock</CODE
133 
>(void);</CODE
134 
></P
135 
><P
136 
><CODE
137 
><CODE
138 
CLASS="FUNCDEF"
139 
>cyg_ucount32 cyg_scheduler_read_lock</CODE
140 
>(void);</CODE
141 
></P
142 
><P
143 
></P
144 
></DIV
145 
></DIV
146 
><DIV
147 
CLASS="REFSECT1"
148 
><A
149 
NAME="KERNEL-SCHEDCONTROL-DESCRIPTION"
150 
></A
151 
><H2
152 
>Description</H2
153 
><P
154 
><TT
155 
CLASS="FUNCTION"
156 
>cyg_scheduler_start</TT
157 
> should only be called once,
158 
to mark the end of system initialization. In typical configurations it
159 
is called automatically by the system startup, but some applications
160 
may bypass the standard startup in which case
161 
<TT
162 
CLASS="FUNCTION"
163 
>cyg_scheduler_start</TT
164 
> will have to be called
165 
explicitly. The call will enable system interrupts, allowing I/O
166 
operations to commence. Then the scheduler will be invoked and control
167 
will be transferred to the highest priority runnable thread. The call
168 
will never return.
169 
      </P
170 
><P
171 
>The various data structures inside the eCos kernel must be protected
172 
against concurrent updates. Consider a call to
173 
<TT
174 
CLASS="FUNCTION"
175 
>cyg_semaphore_post</TT
176 
> which causes a thread to be
177 
woken up: the semaphore data structure must be updated to remove the
178 
thread from its queue; the scheduler data structure must also be
179 
updated to mark the thread as runnable; it is possible that the newly
180 
runnable thread has a higher priority than the current one, in which
181 
case preemption is required. If in the middle of the semaphore post
182 
call an interrupt occurred and the interrupt handler tried to
183 
manipulate the same data structures, for example by making another
184 
thread runnable, then it is likely that the structures will be left in
185 
an inconsistent state and the system will fail.
186 
      </P
187 
><P
188 
>To prevent such problems the kernel contains a special lock known as
189 
the scheduler lock. A typical kernel function such as
190 
<TT
191 
CLASS="FUNCTION"
192 
>cyg_semaphore_post</TT
193 
> will claim the scheduler lock,
194 
do all its manipulation of kernel data structures, and then release
195 
the scheduler lock. The current thread cannot be preempted while it
196 
holds the scheduler lock. If an interrupt occurs and a DSR is supposed
197 
to run to signal that some event has occurred, that DSR is postponed
198 
until the scheduler unlock operation. This prevents concurrent updates
199 
of kernel data structures.
200 
      </P
201 
><P
202 
>The kernel exports three routines for manipulating the scheduler lock.
203 
<TT
204 
CLASS="FUNCTION"
205 
>cyg_scheduler_lock</TT
206 
> can be called to claim the
207 
lock. On return it is guaranteed that the current thread will not be
208 
preempted, and that no other code is manipulating any kernel data
209 
structures. <TT
210 
CLASS="FUNCTION"
211 
>cyg_scheduler_unlock</TT
212 
> can be used to
213 
release the lock, which may cause the current thread to be preempted.
214 
<TT
215 
CLASS="FUNCTION"
216 
>cyg_scheduler_read_lock</TT
217 
> can be used to query the
218 
current state of the scheduler lock. This function should never be
219 
needed because well-written code should always know whether or not the
220 
scheduler is currently locked, but may prove useful during debugging.
221 
      </P
222 
><P
223 
>The implementation of the scheduler lock involves a simple counter.
224 
Code can call <TT
225 
CLASS="FUNCTION"
226 
>cyg_scheduler_lock</TT
227 
> multiple times,
228 
causing the counter to be incremented each time, as long as
229 
<TT
230 
CLASS="FUNCTION"
231 
>cyg_scheduler_unlock</TT
232 
> is called the same number of
233 
times. This behaviour is different from mutexes where an attempt by a
234 
thread to lock a mutex multiple times will result in deadlock or an
235 
assertion failure.
236 
      </P
237 
><P
238 
>Typical application code should not use the scheduler lock. Instead
239 
other synchronization primitives such as mutexes and semaphores should
240 
be used. While the scheduler is locked the current thread cannot be
241 
preempted, so any higher priority threads will not be able to run.
242 
Also no DSRs can run, so device drivers may not be able to service
243 
I/O requests. However there is one situation where locking the
244 
scheduler is appropriate: if some data structure needs to be shared
245 
between an application thread and a DSR associated with some interrupt
246 
source, the thread can use the scheduler lock to prevent concurrent
247 
invocations of the DSR and then safely manipulate the structure. It is
248 
desirable that the scheduler lock is held for only a short period of
249 
time, typically some tens of instructions. In exceptional cases there
250 
may also be some performance-critical code where it is more
251 
appropriate to use the scheduler lock rather than a mutex, because the
252 
former is more efficient.
253 
      </P
254 
></DIV
255 
><DIV
256 
CLASS="REFSECT1"
257 
><A
258 
NAME="KERNEL-SCHEDCONTROL-CONTEXT"
259 
></A
260 
><H2
261 
>Valid contexts</H2
262 
><P
263 
><TT
264 
CLASS="FUNCTION"
265 
>cyg_scheduler_start</TT
266 
> can only be called during
267 
system initialization, since it marks the end of that phase. The
268 
remaining functions may be called from thread or DSR context. Locking
269 
the scheduler from inside the DSR has no practical effect because the
270 
lock is claimed automatically by the interrupt subsystem before
271 
running DSRs, but allows functions to be shared between normal thread
272 
code and DSRs.
273 
      </P
274 
></DIV
275 
><DIV
276 
CLASS="NAVFOOTER"
277 
><HR
278 
ALIGN="LEFT"
279 
WIDTH="100%"><TABLE
280 
SUMMARY="Footer navigation table"
281 
WIDTH="100%"
282 
BORDER="0"
283 
CELLPADDING="0"
284 
CELLSPACING="0"
285 
><TR
286 
><TD
287 
WIDTH="33%"
288 
ALIGN="left"
289 
VALIGN="top"
290 
><A
291 
HREF="kernel-spinlocks.html"
292 
ACCESSKEY="P"
293 
>Prev</A
294 
></TD
295 
><TD
296 
WIDTH="34%"
297 
ALIGN="center"
298 
VALIGN="top"
299 
><A
300 
HREF="ecos-ref.html"
301 
ACCESSKEY="H"
302 
>Home</A
303 
></TD
304 
><TD
305 
WIDTH="33%"
306 
ALIGN="right"
307 
VALIGN="top"
308 
><A
309 
HREF="kernel-interrupts.html"
310 
ACCESSKEY="N"
311 
>Next</A
312 
></TD
313 
></TR
314 
><TR
315 
><TD
316 
WIDTH="33%"
317 
ALIGN="left"
318 
VALIGN="top"
319 
>Spinlocks</TD
320 
><TD
321 
WIDTH="34%"
322 
ALIGN="center"
323 
VALIGN="top"
324 
><A
325 
HREF="kernel.html"
326 
ACCESSKEY="U"
327 
>Up</A
328 
></TD
329 
><TD
330 
WIDTH="33%"
331 
ALIGN="right"
332 
VALIGN="top"
333 
>Interrupt Handling</TD
334 
></TR
335 
></TABLE
336 
></DIV
337 
></BODY
338 
></HTML
339 
>

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.