Changeset 29e6637e in rtems for doc/user/smp.t


Ignore:
Timestamp:
May 5, 2014, 7:55:13 PM (7 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
4.11, 5, 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.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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.