source: rtems-docs/c-user/glossary.rst @ b033e39

5
Last change on this file since b033e39 was b033e39, checked in by Sebastian Huber <sebastian.huber@…>, on 02/02/17 at 09:46:05

c-user: Add SMP application issues section

  • Property mode set to 100644
File size: 26.0 KB
Line 
1.. comment SPDX-License-Identifier: CC-BY-SA-4.0
2
3Glossary
4********
5
6:dfn:`active`
7    A term used to describe an object which has been created by an application.
8
9:dfn:`aperiodic task`
10    A task which must execute only at irregular intervals and has only a soft
11    deadline.
12
13:dfn:`application`
14    In this document, software which makes use of RTEMS.
15
16:dfn:`ASR`
17    see Asynchronous Signal Routine.
18
19:dfn:`asynchronous`
20    Not related in order or timing to other occurrences in the system.
21
22:dfn:`Asynchronous Signal Routine`
23    Similar to a hardware interrupt except that it is associated with a task
24    and is run in the context of a task.  The directives provided by the signal
25    manager are used to service signals.
26
27:dfn:`atomic operations`
28    Atomic operations are defined in terms of :ref:`C11 <C11>`.
29
30:dfn:`awakened`
31    A term used to describe a task that has been unblocked and may be scheduled
32    to the CPU.
33
34:dfn:`big endian`
35    A data representation scheme in which the bytes composing a numeric value
36    are arranged such that the most significant byte is at the lowest address.
37
38:dfn:`bit-mapped`
39    A data encoding scheme in which each bit in a variable is used to represent
40    something different.  This makes for compact data representation.
41
42:dfn:`block`
43    A physically contiguous area of memory.
44
45:dfn:`blocked task`
46    The task state entered by a task which has been previously started and
47    cannot continue execution until the reason for waiting has been satisfied.
48    Blocked tasks are not an element of the set of ready tasks of a scheduler
49    instance.
50
51:dfn:`broadcast`
52    To simultaneously send a message to a logical set of destinations.
53
54:dfn:`BSP`
55    see Board Support Package.
56
57:dfn:`Board Support Package`
58    A collection of device initialization and control routines specific to a
59    particular type of board or collection of boards.
60
61:dfn:`buffer`
62    A fixed length block of memory allocated from a partition.
63
64.. _C11:
65
66:dfn:`C11`
67    The standard ISO/IEC 9899:2011.
68
69.. _C++11:
70
71:dfn:`C++11`
72    The standard ISO/IEC 14882:2011.
73
74:dfn:`calling convention`
75    The processor and compiler dependent rules which define the mechanism used
76    to invoke subroutines in a high-level language.  These rules define the
77    passing of arguments, the call and return mechanism, and the register set
78    which must be preserved.
79
80:dfn:`Central Processing Unit`
81    This term is equivalent to the terms processor and microprocessor.
82
83:dfn:`chain`
84    A data structure which allows for efficient dynamic addition and removal of
85    elements.  It differs from an array in that it is not limited to a
86    predefined size.
87
88:dfn:`cluster`
89    We have clustered scheduling in case the set of processors of a system is
90    partitioned into non-empty pairwise disjoint subsets.  These subsets are
91    called:dfn:`clusters`.  Clusters with a cardinality of one are partitions.
92    Each cluster is owned by exactly one scheduler instance.
93
94:dfn:`coalesce`
95    The process of merging adjacent holes into a single larger hole.  Sometimes
96    this process is referred to as garbage collection.
97
98:dfn:`Configuration Table`
99    A table which contains information used to tailor RTEMS for a particular
100    application.
101
102:dfn:`context`
103    All of the processor registers and operating system data structures
104    associated with a task.
105
106:dfn:`context switch`
107    Alternate term for task switch.  Taking control of the processor from one
108    task and transferring it to another task.
109
110:dfn:`control block`
111    A data structure used by the executive to define and control an object.
112
113:dfn:`core`
114    When used in this manual, this term refers to the internal executive
115    utility functions.  In the interest of application portability, the core of
116    the executive should not be used directly by applications.
117
118:dfn:`CPU`
119    An acronym for Central Processing Unit.
120
121:dfn:`critical section`
122    A section of code which must be executed indivisibly.
123
124:dfn:`CRT`
125    An acronym for Cathode Ray Tube.  Normally used in reference to the
126    man-machine interface.
127
128:dfn:`deadline`
129    A fixed time limit by which a task must have completed a set of actions.
130    Beyond this point, the results are of reduced value and may even be
131    considered useless or harmful.
132
133:dfn:`device`
134    A peripheral used by the application that requires special operation
135    software.  See also device driver.
136
137:dfn:`device driver`
138    Control software for special peripheral devices used by the application.
139
140:dfn:`directives`
141    RTEMS' provided routines that provide support mechanisms for real-time
142    applications.
143
144:dfn:`dispatch`
145    The act of loading a task's context onto the CPU and transferring control
146    of the CPU to that task.
147
148:dfn:`dormant`
149    The state entered by a task after it is created and before it has been
150    started.
151
152:dfn:`Device Driver Table`
153    A table which contains the entry points for each of the configured device
154    drivers.
155
156:dfn:`dual-ported`
157    A term used to describe memory which can be accessed at two different
158    addresses.
159
160:dfn:`embedded`
161    An application that is delivered as a hidden part of a larger system.  For
162    example, the software in a fuel-injection control system is an embedded
163    application found in many late-model automobiles.
164
165:dfn:`envelope`
166    A buffer provided by the MPCI layer to RTEMS which is used to pass messages
167    between nodes in a multiprocessor system.  It typically contains routing
168    information needed by the MPCI.  The contents of an envelope are referred
169    to as a packet.
170
171:dfn:`entry point`
172    The address at which a function or task begins to execute.  In C, the entry
173    point of a function is the function's name.
174
175:dfn:`events`
176    A method for task communication and synchronization. The directives
177    provided by the event manager are used to service events.
178
179:dfn:`exception`
180    A synonym for interrupt.
181
182:dfn:`executing task`
183    The task state entered by a task after it has been given control of the
184    processor.  In SMP configurations, a task may be registered as executing on
185    more than one processor for short time frames during task migration.
186    Blocked tasks can be executing until they issue a thread dispatch.
187
188:dfn:`executive`
189    In this document, this term is used to referred to RTEMS.  Commonly, an
190    executive is a small real-time operating system used in embedded systems.
191
192:dfn:`exported`
193    An object known by all nodes in a multiprocessor system.  An object created
194    with the GLOBAL attribute will be exported.
195
196:dfn:`external address`
197    The address used to access dual-ported memory by all the nodes in a system
198    which do not own the memory.
199
200:dfn:`FIFO`
201    An acronym for First In First Out.
202
203:dfn:`First In First Out`
204    A discipline for manipulating entries in a data structure.
205
206:dfn:`floating point coprocessor`
207    A component used in computer systems to enhance performance in
208    mathematically intensive situations.  It is typically viewed as a logical
209    extension of the primary processor.
210
211:dfn:`freed`
212    A resource that has been released by the application to RTEMS.
213
214:dfn:`global`
215    An object that has been created with the GLOBAL attribute and exported to
216    all nodes in a multiprocessor system.
217
218:dfn:`handler`
219    The equivalent of a manager, except that it is internal to RTEMS and forms
220    part of the core.  A handler is a collection of routines which provide a
221    related set of functions.  For example, there is a handler used by RTEMS to
222    manage all objects.
223
224:dfn:`hard real-time system`
225    A real-time system in which a missed deadline causes the worked performed
226    to have no value or to result in a catastrophic effect on the integrity of
227    the system.
228
229:dfn:`heap`
230    A data structure used to dynamically allocate and deallocate variable sized
231    blocks of memory.
232
233:dfn:`heir task`
234    A task is an :dfn:`heir` if it is registered as an heir in a processor of
235    the system.  A task can be the heir on at most one processor in the system.
236    In case the executing and heir tasks differ on a processor and a thread
237    dispatch is marked as necessary, then the next thread dispatch will make
238    the heir task the executing task.
239
240:dfn:`heterogeneous`
241    A multiprocessor computer system composed of dissimilar processors.
242
243:dfn:`homogeneous`
244    A multiprocessor computer system composed of a single type of processor.
245
246:dfn:`ID`
247    An RTEMS assigned identification tag used to access an active object.
248
249:dfn:`IDLE task`
250    A special low priority task which assumes control of the CPU when no other
251    task is able to execute.
252
253:dfn:`interface`
254    A specification of the methodology used to connect multiple independent
255    subsystems.
256
257:dfn:`internal address`
258    The address used to access dual-ported memory by the node which owns the
259    memory.
260
261:dfn:`interrupt`
262    A hardware facility that causes the CPU to suspend execution, save its
263    status, and transfer control to a specific location.
264
265:dfn:`interrupt level`
266    A mask used to by the CPU to determine which pending interrupts should be
267    serviced.  If a pending interrupt is below the current interrupt level,
268    then the CPU does not recognize that interrupt.
269
270:dfn:`Interrupt Service Routine`
271    An ISR is invoked by the CPU to process a pending interrupt.
272
273:dfn:`I/O`
274    An acronym for Input/Output.
275
276:dfn:`ISR`
277    An acronym for Interrupt Service Routine.
278
279:dfn:`kernel`
280    In this document, this term is used as a synonym for executive.
281
282:dfn:`list`
283    A data structure which allows for dynamic addition and removal of entries.
284    It is not statically limited to a particular size.
285
286:dfn:`little endian`
287    A data representation scheme in which the bytes composing a numeric value
288    are arranged such that the least significant byte is at the lowest address.
289
290:dfn:`local`
291    An object which was created with the LOCAL attribute and is accessible only
292    on the node it was created and resides upon.  In a single processor
293    configuration, all objects are local.
294
295:dfn:`local operation`
296    The manipulation of an object which resides on the same node as the calling
297    task.
298
299:dfn:`logical address`
300    An address used by an application.  In a system without memory management,
301    logical addresses will equal physical addresses.
302
303:dfn:`loosely-coupled`
304    A multiprocessor configuration where shared memory is not used for
305    communication.
306
307:dfn:`major number`
308    The index of a device driver in the Device Driver Table.
309
310:dfn:`manager`
311    A group of related RTEMS' directives which provide access and control over
312    resources.
313
314:dfn:`memory pool`
315    Used interchangeably with heap.
316
317:dfn:`message`
318    A sixteen byte entity used to communicate between tasks.  Messages are sent
319    to message queues and stored in message buffers.
320
321:dfn:`message buffer`
322    A block of memory used to store messages.
323
324:dfn:`message queue`
325    An RTEMS object used to synchronize and communicate between tasks by
326    transporting messages between sending and receiving tasks.
327
328:dfn:`Message Queue Control Block`
329    A data structure associated with each message queue used by RTEMS to manage
330    that message queue.
331
332:dfn:`minor number`
333    A numeric value passed to a device driver, the exact usage of which is
334    driver dependent.
335
336:dfn:`mode`
337    An entry in a task's control block that is used to determine if the task
338    allows preemption, timeslicing, processing of signals, and the interrupt
339    disable level used by the task.
340
341:dfn:`MPCI`
342    An acronym for Multiprocessor Communications Interface Layer.
343
344:dfn:`multiprocessing`
345    The simultaneous execution of two or more processes by a multiple processor
346    computer system.
347
348:dfn:`multiprocessor`
349    A computer with multiple CPUs available for executing applications.
350
351:dfn:`Multiprocessor Communications Interface Layer`
352    A set of user-provided routines which enable the nodes in a multiprocessor
353    system to communicate with one another.
354
355:dfn:`Multiprocessor Configuration Table`
356    The data structure defining the characteristics of the multiprocessor
357    target system with which RTEMS will communicate.
358
359:dfn:`multitasking`
360    The alternation of execution amongst a group of processes on a single CPU.
361    A scheduling algorithm is used to determine which process executes at which
362    time.
363
364:dfn:`mutual exclusion`
365    A term used to describe the act of preventing other tasks from accessing a
366    resource simultaneously.
367
368:dfn:`nested`
369    A term used to describe an ASR that occurs during another ASR or an ISR
370    that occurs during another ISR.
371
372:dfn:`node`
373    A term used to reference a processor running RTEMS in a multiprocessor
374    system.
375
376:dfn:`non-existent`
377    The state occupied by an uncreated or deleted task.
378
379:dfn:`numeric coprocessor`
380    A component used in computer systems to enhance performance in
381    mathematically intensive situations.  It is typically viewed as a logical
382    extension of the primary processor.
383
384:dfn:`object`
385    In this document, this term is used to refer collectively to tasks, timers,
386    message queues, partitions, regions, semaphores, ports, and rate monotonic
387    periods.  All RTEMS objects have IDs and user-assigned names.
388
389:dfn:`object-oriented`
390    A term used to describe systems with common mechanisms for utilizing a
391    variety of entities.  Object-oriented systems shield the application from
392    implementation details.
393
394:dfn:`operating system`
395    The software which controls all the computer's resources and provides the
396    base upon which application programs can be written.
397
398:dfn:`overhead`
399    The portion of the CPUs processing power consumed by the operating system.
400
401:dfn:`packet`
402    A buffer which contains the messages passed between nodes in a
403    multiprocessor system.  A packet is the contents of an envelope.
404
405:dfn:`partition`
406    An RTEMS object which is used to allocate and deallocate fixed size blocks
407    of memory from an dynamically specified area of memory.
408
409:dfn:`partition`
410    Clusters with a cardinality of one are :dfn:`partitions`.
411
412:dfn:`Partition Control Block`
413    A data structure associated with each partition used by RTEMS to manage
414    that partition.
415
416:dfn:`pending`
417    A term used to describe a task blocked waiting for an event, message,
418    semaphore, or signal.
419
420:dfn:`periodic task`
421    A task which must execute at regular intervals and comply with a hard
422    deadline.
423
424:dfn:`physical address`
425    The actual hardware address of a resource.
426
427:dfn:`poll`
428    A mechanism used to determine if an event has occurred by periodically
429    checking for a particular status.  Typical events include arrival of data,
430    completion of an action, and errors.
431
432:dfn:`pool`
433    A collection from which resources are allocated.
434
435:dfn:`portability`
436    A term used to describe the ease with which software can be rehosted on
437    another computer.
438
439:dfn:`posting`
440    The act of sending an event, message, semaphore, or signal to a task.
441
442:dfn:`preempt`
443    The act of forcing a task to relinquish the processor and dispatching to
444    another task.
445
446:dfn:`priority`
447    A mechanism used to represent the relative importance of an element in a
448    set of items.  RTEMS uses priority to determine which task should execute.
449
450:dfn:`priority boosting`
451    A simple approach to extend the priority inheritance protocol for clustered
452    scheduling is :dfn:`priority boosting`.  In case a mutex is owned by a task
453    of another cluster, then the priority of the owner task is raised to an
454    artificially high priority, the pseudo-interrupt priority.
455
456:dfn:`priority inheritance`
457    An algorithm that calls for the lower priority task holding a resource to
458    have its priority increased to that of the highest priority task blocked
459    waiting for that resource.  This avoids the problem of priority inversion.
460
461:dfn:`priority inversion`
462    A form of indefinite postponement which occurs when a high priority tasks
463    requests access to shared resource currently allocated to low priority
464    task.  The high priority task must block until the low priority task
465    releases the resource.
466
467:dfn:`processor utilization`
468    The percentage of processor time used by a task or a set of tasks.
469
470:dfn:`proxy`
471    An RTEMS control structure used to represent, on a remote node, a task
472    which must block as part of a remote operation.
473
474:dfn:`Proxy Control Block`
475    A data structure associated with each proxy used by RTEMS to manage that
476    proxy.
477
478:dfn:`PTCB`
479    An acronym for Partition Control Block.
480
481:dfn:`PXCB`
482    An acronym for Proxy Control Block.
483
484:dfn:`quantum`
485    The application defined unit of time in which the processor is allocated.
486
487:dfn:`queue`
488    Alternate term for message queue.
489
490:dfn:`QCB`
491    An acronym for Message Queue Control Block.
492
493:dfn:`ready task`
494    A task occupies this state when it is available to be given control of a
495    processor.  A ready task has no processor assigned.  The scheduler decided
496    that other tasks are currently more important.  A task that is ready to
497    execute and has a processor assigned is called scheduled.
498
499:dfn:`real-time`
500    A term used to describe systems which are characterized by requiring
501    deterministic response times to external stimuli.  The external stimuli
502    require that the response occur at a precise time or the response is
503    incorrect.
504
505:dfn:`reentrant`
506    A term used to describe routines which do not modify themselves or global
507    variables.
508
509:dfn:`region`
510    An RTEMS object which is used to allocate and deallocate variable size
511    blocks of memory from a dynamically specified area of memory.
512
513:dfn:`Region Control Block`
514    A data structure associated with each region used by RTEMS to manage that
515    region.
516
517:dfn:`registers`
518    Registers are locations physically located within a component, typically
519    used for device control or general purpose storage.
520
521:dfn:`remote`
522    Any object that does not reside on the local node.
523
524:dfn:`remote operation`
525    The manipulation of an object which does not reside on the same node as the
526    calling task.
527
528:dfn:`return code`
529    Also known as error code or return value.
530
531:dfn:`resource`
532    A hardware or software entity to which access must be controlled.
533
534:dfn:`resume`
535    Removing a task from the suspend state.  If the task's state is ready
536    following a call to the ``rtems_task_resume`` directive, then the task is
537    available for scheduling.
538
539:dfn:`return code`
540    A value returned by RTEMS directives to indicate the completion status of
541    the directive.
542
543:dfn:`RNCB`
544    An acronym for Region Control Block.
545
546:dfn:`round-robin`
547    A task scheduling discipline in which tasks of equal priority are executed
548    in the order in which they are made ready.
549
550:dfn:`RS-232`
551    A standard for serial communications.
552
553:dfn:`running`
554    The state of a rate monotonic timer while it is being used to delineate a
555    period.  The timer exits this state by either expiring or being canceled.
556
557:dfn:`schedulable`
558    A set of tasks which can be guaranteed to meet their deadlines based upon a
559    specific scheduling algorithm.
560
561:dfn:`schedule`
562    The process of choosing which task should next enter the executing state.
563
564:dfn:`scheduled task`
565    A task is :dfn:`scheduled` if it is allowed to execute and has a processor
566    assigned.  Such a task executes currently on a processor or is about to
567    start execution.  A task about to start execution it is an heir task on
568    exactly one processor in the system.
569
570:dfn:`scheduler`
571    A :dfn:`scheduler` or :dfn:`scheduling algorithm` allocates processors to a
572    subset of its set of ready tasks.  So it manages access to the processor
573    resource.  Various algorithms exist to choose the tasks allowed to use a
574    processor out of the set of ready tasks.  One method is to assign each task
575    a priority number and assign the tasks with the lowest priority number to
576    one processor of the set of processors owned by a scheduler instance.
577
578:dfn:`scheduler instance`
579    A :dfn:`scheduler instance` is a scheduling algorithm with a corresponding
580    context to store its internal state.  Each processor in the system is owned
581    by at most one scheduler instance.  The processor to scheduler instance
582    assignment is determined at application configuration time.  See
583    :ref:`Configuring a System`.
584
585:dfn:`segments`
586    Variable sized memory blocks allocated from a region.
587
588:dfn:`semaphore`
589    An RTEMS object which is used to synchronize tasks and provide mutually
590    exclusive access to resources.
591
592:dfn:`Semaphore Control Block`
593    A data structure associated with each semaphore used by RTEMS to manage
594    that semaphore.
595
596:dfn:`shared memory`
597    Memory which is accessible by multiple nodes in a multiprocessor system.
598
599:dfn:`signal`
600    An RTEMS provided mechanism to communicate asynchronously with a task.
601    Upon reception of a signal, the ASR of the receiving task will be invoked.
602
603:dfn:`signal set`
604    A thirty-two bit entity which is used to represent a task's collection of
605    pending signals and the signals sent to a task.
606
607:dfn:`SMCB`
608    An acronym for Semaphore Control Block.
609
610:dfn:`SMP locks`
611    The :dfn:`SMP locks` ensure mutual exclusion on the lowest level and are a
612    replacement for the sections of disabled interrupts.  Interrupts are
613    usually disabled while holding an SMP lock.  They are implemented using
614    atomic operations.  Currently a ticket lock is used in RTEMS.
615
616:dfn:`SMP barriers`
617    The :dfn:`SMP barriers` ensure that a defined set of independent threads of
618    execution on a set of processors reaches a common synchronization point in
619    time.  They are implemented using atomic operations.  Currently a sense
620    barrier is used in RTEMS.
621
622:dfn:`soft real-time system`
623    A real-time system in which a missed deadline does not compromise the
624    integrity of the system.
625
626:dfn:`sporadic task`
627    A task which executes at irregular intervals and must comply with a hard
628    deadline.  A minimum period of time between successive iterations of the
629    task can be guaranteed.
630
631:dfn:`stack`
632    A data structure that is managed using a Last In First Out (LIFO)
633    discipline.  Each task has a stack associated with it which is used to
634    store return information and local variables.
635
636:dfn:`status code`
637    Also known as error code or return value.
638
639:dfn:`suspend`
640    A term used to describe a task that is not competing for the CPU because it
641    has had a ``rtems_task_suspend`` directive.
642
643:dfn:`synchronous`
644    Related in order or timing to other occurrences in the system.
645
646:dfn:`system call`
647    In this document, this is used as an alternate term for directive.
648
649:dfn:`target`
650    The system on which the application will ultimately execute.
651
652.. _task:
653
654:dfn:`task`
655    A logically complete thread of execution.  It consists normally of a set of
656    registers and a stack.  The scheduler assigns processors to a subset of the
657    ready tasks.  The terms :dfn:`task` and :dfn:`thread` are synonym in RTEMS.
658    The term :dfn:`task` is used throughout the Classic API, however,
659    internally in the operating system implementation and the POSIX API the
660    term :dfn:`thread` is used.
661
662:dfn:`Task Control Block`
663    A data structure associated with each task used by RTEMS to manage that
664    task.
665
666:dfn:`task migration`
667    :dfn:`Task migration` happens in case a task stops execution on one
668    processor and resumes execution on another processor.
669
670:dfn:`task processor affinity`
671    The set of processors on which a task is allowed to execute.
672
673:dfn:`task switch`
674    Alternate terminology for context switch.  Taking control of the processor
675    from one task and given to another.
676
677:dfn:`TCB`
678    An acronym for Task Control Block.
679
680:dfn:`thread`
681    See :ref:`task <task>`.
682
683:dfn:`thread dispatch`
684    The :dfn:`thread dispatch` transfers control of the processor from the
685    currently executing thread to the heir thread of the processor.
686
687:dfn:`tick`
688    The basic unit of time used by RTEMS.  It is a user-configurable number of
689    microseconds.  The current tick expires when a clock tick directive is
690    invoked.
691
692:dfn:`tightly-coupled`
693    A multiprocessor configuration system which communicates via shared memory.
694
695:dfn:`timeout`
696    An argument provided to a number of directives which determines the maximum
697    length of time an application task is willing to wait to acquire the
698    resource if it is not immediately available.
699
700:dfn:`timer`
701    An RTEMS object used to invoke subprograms at a later time.
702
703:dfn:`Timer Control Block`
704    A data structure associated with each timer used by RTEMS to manage that
705    timer.
706
707:dfn:`timeslicing`
708    A task scheduling discipline in which tasks of equal priority are executed
709    for a specific period of time before being preempted by another task.
710
711:dfn:`timeslice`
712    The application defined unit of time in which the processor is allocated.
713
714.. _TLS:
715
716:dfn:`TLS`
717    An acronym for Thread-Local Storage :cite:`Drepper:2013:TLS`.  TLS is
718    available in :ref:`C11 <C11>` and :ref:`C++11 <C++11>`.  The support for
719    TLS depends on the CPU port :cite:`RTEMS:CPU`.
720
721:dfn:`TMCB`
722    An acronym for Timer Control Block.
723
724:dfn:`transient overload`
725    A temporary rise in system activity which may cause deadlines to be missed.
726    Rate Monotonic Scheduling can be used to determine if all deadlines will be
727    met under transient overload.
728
729:dfn:`user extensions`
730    Software routines provided by the application to enhance the functionality
731    of RTEMS.
732
733:dfn:`User Extension Table`
734    A table which contains the entry points for each user extensions.
735
736:dfn:`User Initialization Tasks Table`
737    A table which contains the information needed to create and start each of
738    the user initialization tasks.
739
740:dfn:`user-provided`
741    Alternate term for user-supplied.  This term is used to designate any
742    software routines which must be written by the application designer.
743
744:dfn:`user-supplied`
745    Alternate term for user-provided.  This term is used to designate any
746    software routines which must be written by the application designer.
747
748:dfn:`vector`
749    Memory pointers used by the processor to fetch the address of routines
750    which will handle various exceptions and interrupts.
751
752:dfn:`wait queue`
753    The list of tasks blocked pending the release of a particular resource.
754    Message queues, regions, and semaphores have a wait queue associated with
755    them.
756
757:dfn:`yield`
758    When a task voluntarily releases control of the processor.
Note: See TracBrowser for help on using the repository browser.