Changeset 29e6637e in rtems


Ignore:
Timestamp:
May 5, 2014, 7:55:13 PM (5 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
4.11, master
Children:
35a3af7a
Parents:
d9196d1d
git-author:
Sebastian Huber <sebastian.huber@…> (05/05/14 19:55:13)
git-committer:
Sebastian Huber <sebastian.huber@…> (05/08/14 06:43:45)
Message:

doc: Move SMP glossary to global glossary

Add some terms.

Location:
doc/user
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • doc/user/glossary.texi

    rd9196d1d r29e6637e  
    3333manager are used to service signals.
    3434
     35@item atomic operations
     36Atomic operations are defined in terms of @cite{ISO/IEC 9899:2011}.
     37
    3538@item awakened
    3639A term used to describe a task that has
     
    5053A physically contiguous area of memory.
    5154
    52 @item blocked
    53 The task state entered by a task which has
    54 been previously started and cannot continue execution until the
    55 reason for waiting has been satisfied.
     55@item blocked task
     56The task state entered by a task which has been previously started and cannot
     57continue execution until the reason for waiting has been satisfied.  Blocked
     58tasks are not an element of the set of ready tasks of a scheduler instance.
    5659
    5760@item broadcast
     
    8790array in that it is not limited to a predefined size.
    8891
     92@item cluster
     93We have clustered scheduling in case the set of processors of a system is
     94partitioned into non-empty pairwise disjoint subsets.  These subsets are called
     95@dfn{clusters}.  Each cluster is owned by exactly one scheduler instance.
     96
    8997@item coalesce
    9098The process of merging adjacent holes into
     
    186194A synonym for interrupt.
    187195
    188 @item executing
    189 The task state entered by a task after it
    190 has been given control of the CPU.
     196@item executing task
     197The task state entered by a task after it has been given control of the
     198processor.  On SMP configurations a task may be registered as executing on more
     199than one processor for short time frames during task migration.  Blocked tasks
     200can be executing until they issue a thread dispatch.
    191201
    192202@item executive
     
    220230A resource that has been released by the
    221231application to RTEMS.
     232
     233@item Giant lock
     234The @dfn{Giant lock} is a recursive SMP lock protecting most parts of the
     235operating system state.  Virtually every operating system service must acquire
     236and release the Giant lock during its operation.
    222237
    223238@item global
     
    243258and deallocate variable sized blocks of memory.
    244259
     260@item heir task
     261A task is an @dfn{heir} if it is registered as an heir in a processor of the
     262system.  A task can be the heir on at most one processor in the system.  In
     263case the executing and heir tasks differ on a processor and a thread dispatch
     264is marked as necessary, then the next thread dispatch will make the heir task
     265the executing task.
     266
    245267@item heterogeneous
    246268A multiprocessor computer system composed of dissimilar processors.
     
    256278A special low priority task which assumes
    257279control of the CPU when no other task is able to execute.
     280
     281@item in the air task
     282A task is @dfn{in the air} if it is in a transient state and has a processor
     283assigned.  The next scheduler operation will turn it into a blocked, ready or
     284scheduled task.  This state is specific to SMP configurations.
    258285
    259286@item interface
     
    436463and deallocate fixed size blocks of memory from an dynamically
    437464specified area of memory.
     465
     466@item partition
     467Clusters with a cardinality of one are @dfn{partitions}.
    438468
    439469@item Partition Control Block
     
    523553An acronym for Message Queue Control Block.
    524554
    525 @item ready
    526 A task occupies this state when it is
    527 available to be given control of the CPU.
     555@item ready task
     556A task occupies this state when it is available to be given control of a
     557processor.  A ready task has no processor assigned.  The scheduler decided that
     558other tasks are currently more important.  A task that is ready to execute and
     559has a processor assigned is called scheduled.
    528560
    529561@item real-time
     
    593625state by either expiring or being canceled.
    594626
    595 @item schedule
    596 The process of choosing which task should
    597 next enter the executing state.
    598 
    599627@item schedulable
    600628A set of tasks which can be guaranteed
     
    602630algorithm.
    603631
     632@item schedule
     633The process of choosing which task should
     634next enter the executing state.
     635
     636@item scheduled task
     637A task is @dfn{scheduled} if it is allowed to execute and has a processor
     638assigned.  Such a task executes currently on a processor or is about to start
     639execution.  A task about to start execution it is an heir task on exactly one
     640processor in the system.
     641
     642@item scheduler
     643A @dfn{scheduler} or @dfn{scheduling algorithm} allocates processors to a
     644subset of its set of ready tasks.  So it manages access to the processor
     645resource.  Various algorithms exist to choose the tasks allowed to use a
     646processor out of the set of ready tasks.  One method is to assign each task a
     647priority number and assign the tasks with the lowest priority number to one
     648processor of the set of processors owned by a scheduler instance.
     649
     650@item scheduler instance
     651A @dfn{scheduler instance} is a scheduling algorithm with a corresponding
     652context to store its internal state.  Each processor in the system is owned by
     653at most one scheduler instance.  The processor to scheduler instance assignment
     654is determined at application configuration time.  @xref{Configuring a System
     655Configuring Clustered/Partitioned Schedulers}.
     656
    604657@item segments
    605658Variable sized memory blocks allocated
     
    631684@item SMCB
    632685An acronym for Semaphore Control Block.
     686
     687@item SMP locks
     688The @dfn{SMP locks} ensure mutual exclusion on the lowest level and are a
     689replacement for the sections of disabled interrupts.  Interrupts are usually
     690disabled while holding an SMP lock.  They are implemented using atomic
     691operations.  Currently a ticket lock is used in RTEMS.
     692
     693@item SMP barriers
     694The @dfn{SMP barriers} ensure that a defined set of independent threads of
     695execution on a set of processors reaches a common synchronization point in
     696time.  They are implemented using atomic operations.  Currently a sense barrier
     697is used in RTEMS.
    633698
    634699@item soft real-time system
     
    670735
    671736@item task
    672 A logically complete thread of execution.  The
    673 CPU is allocated among the ready tasks.
     737A logically complete thread of execution.  It consists normally of a set of
     738registers and a stack.  The terms @dfn{task} and @dfn{thread} are synonym in
     739RTEMS.  The scheduler assigns processors to a subset of the ready tasks.
    674740
    675741@item Task Control Block
    676742A data structure associated with
    677743each task used by RTEMS to manage that task.
     744
     745@item task migration
     746@dfn{Task migration} happens in case a task stops execution on one processor
     747and resumes execution on another processor.
     748
     749@item task processor affinity
     750The set of processors on which a task is allowed to execute.
    678751
    679752@item task switch
     
    684757@item TCB
    685758An acronym for Task Control Block.
     759
     760@item thread dispatch
     761The @dfn{thread dispatch} transfers control of the processor from the currently
     762executing thread to the heir thread of the processor.
    686763
    687764@item tick
  • doc/user/smp.t

    rd9196d1d r29e6637e  
    2929@c
    3030@section Background
    31 
    32 @subsection Glossary
    33 
    34 @table @dfn
    35 
    36 @item scheduler
    37 
    38 A @dfn{scheduler} or @dfn{scheduling algorithm} allocates processors to a
    39 subset of its set of ready tasks.  So it manages access to the processor
    40 resource.  Various algorithms exist to choose the tasks allowed to use a
    41 processor out of the set of ready tasks.  One method is to assign each task a
    42 priority number and assign the tasks with the lowest priority number to one
    43 processor of the set of processors owned by a scheduler instance.
    44 
    45 @item scheduler instance
    46 
    47 A @dfn{scheduler instance} is a scheduling algorithm with a corresponding
    48 context to store its internal state.  Each processor in the system is owned by
    49 at most one scheduler instance.  The processor to scheduler instance assignment
    50 is determined at application configuration time.  @xref{Configuring a System
    51 Configuring Clustered/Partitioned Schedulers}.
    52 
    53 @item cluster
    54 
    55 We have clustered scheduling in case the set of processors of a system is
    56 partitioned into non-empty pairwise disjoint subsets.  These subsets are called
    57 @dfn{clusters}.  Each cluster is owned by exactly one scheduler instance.
    58 
    59 @item partition
    60 
    61 Clusters with a cardinality of one are @dfn{partitions}.
    62 
    63 @item task
    64 
    65 A @dfn{task} or @dfn{thread} is a context which can execute on a processor.  It
    66 consists normally of a set of registers and a stack.  The terms @dfn{task} and
    67 @dfn{thread} are synonym in RTEMS
    68 
    69 @item task processor affinity
    70 
    71 The set of processors on which a task is allowed to execute.
    72 
    73 @item task migration
    74 
    75 @dfn{Task migration} happens in case a task stops execution on one processor
    76 and resumes execution on another processor.
    77 
    78 @item blocked task
    79 
    80 A task is @dfn{blocked} if it is not allowed to execute.  There are several
    81 reasons why a task is blocked, for example
    82 
    83 @itemize @bullet
    84 
    85 @item it has to wait for a resource, currently owned by another task,
    86 
    87 @item some time must elapse, for example the next period start or some time
    88 out,
    89 
    90 @item it is explicitly suspended, or
    91 
    92 @item it is not yet started.
    93 
    94 @end itemize
    95 
    96 Blocked tasks are not an element of the set of ready tasks of a scheduler
    97 instance.
    98 
    99 @item ready task
    100 
    101 A task is @dfn{ready} if it is allowed to execute, but has no processor
    102 assigned.  The scheduler decided that other tasks are currently more important.
    103 
    104 @item scheduled task
    105 
    106 A task is @dfn{scheduled} if it is allowed to execute and has a processor
    107 assigned.  Such a task executes currently on a processor or is about to start
    108 execution.  A task about to start execution it is an heir task on exactly one
    109 processor in the system.
    110 
    111 @item in the air task
    112 
    113 A task is @dfn{in the air} if it is in a transient state and has a processor
    114 assigned.  The next scheduler operation will turn it into a blocked, ready or
    115 scheduled task.
    116 
    117 @item atomic operations
    118 
    119 Atomic operations are defined in terms of @cite{ISO/IEC 9899:2011}.
    120 
    121 @item SMP locks
    122 
    123 The @dfn{SMP locks} ensure mutual exclusion on the lowest level and are a
    124 replacement for the sections of disabled interrupts.  Interrupts are usually
    125 disabled while holding an SMP lock.  They are implemented using atomic
    126 operations.  Currently a ticket lock is used in RTEMS.
    127 
    128 @item SMP barriers
    129 
    130 The @dfn{SMP locks} ensure that a set of processors reaches a common
    131 synchronization point in time.  They are implemented using atomic operations.
    132 Currently a sense barrier is used in RTEMS.
    133 
    134 @item Giant lock
    135 
    136 The @dfn{Giant lock} is a recursive SMP lock protecting most parts of the
    137 operating system state.  Virtually every operating system service must acquire
    138 and release the Giant lock during its operation.
    139 
    140 @end table
    14131
    14232@subsection Uniprocessor versus SMP Parallelism
Note: See TracChangeset for help on using the changeset viewer.