Ignore:
Timestamp:
Sep 7, 2022, 4:12:00 PM (22 months ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, ast-experimental, master, pthread-emulation
Children:
e4855f6
Parents:
7a0f798b
Message:

A whole bunch of small changes:
trying to setup a version that I can pass through a spell checker.
Fixing a whole bunch of grammar errors

File:
1 edited

Legend:

Unmodified
Added
Removed
  • doc/theses/thierry_delisle_PhD/thesis/glossary.tex

    r7a0f798b ra44514e  
    1414% Definitions
    1515
    16 \longnewglossaryentry{thrd}
    17 {name={thread}}
     16\longnewglossaryentry{at}
     17{name={Thread},text={thread}}
    1818{
    19 Threads created and managed inside user-space. Each thread has its own stack and its own thread of execution. User-level threads are invisible to the underlying operating system.
     19Abstract object representing a unit of work. Systems will offer one or more concrete implementations of this concept (\eg \gls{kthrd}, \gls{job}), however, most of the concepts of scheduling are independent of the particular implementations of the work representation. For this reason, this document uses the term \Gls{at} to mean any representation and not one in particular.
    2020
    21 \textit{Synonyms : User threads, Lightweight threads, Green threads, Virtual threads, Tasks.}
     21\textit{Synonyms : Tasks, Jobs, Blocks.}
    2222}
    2323
    2424\longnewglossaryentry{proc}
    25 {name={processor}}
     25{name={Processor},text={processor}}
    2626{
     27Entity that executes the \glspl{at}, \ie the resource being scheduled by the scheduler. In kernel level threading, \ats are kernel threads and \procs are the \glspl{hthrd} on which the kernel threads are scheduled. In user-level threading and in thread pools, \procs are kernel threads.
    2728
     29\textit{Synonyms : Server, Worker.}
    2830}
    2931
    3032\longnewglossaryentry{rQ}
    31 {name={ready-queue}}
     33{name={Ready Queue}, text={ready-queue}}
    3234{
    33 
     35Data structure holding \ats that are ready to be \glslink{atrun}{run}. Often a \glsxtrshort{fifo} queue, but can take many different forms, \eg binary trees are also common.
    3436}
    3537
    3638\longnewglossaryentry{uthrding}
    37 {name={user-level threading}}
     39{name={User-Level Threading},text={user-level threading}}
    3840{
    39 
     41Threading model where a scheduler runs in users space and maps threads managed and created inside the user-space onto \glspl{kthrd}.
    4042
    4143\textit{Synonyms : User threads, Lightweight threads, Green threads, Virtual threads, Tasks.}
     
    4345
    4446\longnewglossaryentry{rmr}
    45 {name={remote memory reference}}
     47{name={Remote Memory Reference},text={remote memory reference}}
    4648{
    47 
     49Reference to an address in memory that is considered \newterm{remote}, as opposed to \emph{local}. This can mean for example: a cache line that is in a cache not shared by the current \gls{hthrd}, a block of memory that belons to a different CPU socket in a \glsxtrshort{numa} context, etc.
    4850}
    4951
     
    5153
    5254\longnewglossaryentry{hthrd}
    53 {name={hardware thread}}
     55{name={Hardware Thread},text={hardware thread}}
    5456{
    5557Threads representing the underlying hardware directly, \eg the CPU core, or hyper-thread if the hardware supports multiple threads of execution per core. The number of hardware threads is considered to be always fixed to a specific number determined by the hardware.
    5658
    57 \textit{Synonyms : }
     59\textit{Synonyms : Core, Processing Unit, CPU.}
    5860}
    5961
    6062\longnewglossaryentry{kthrd}
    61 {name={kernel-level thread}}
     63{name={Kernel-Level Thread},text={kernel-level thread}}
    6264{
    6365Threads created and managed inside kernel-space. Each thread has its own stack and its own thread of execution. Kernel-level threads are owned, managed and scheduled by the underlying operating system.
     
    6769
    6870\longnewglossaryentry{fiber}
    69 {name={fiber}}
     71{name={Fiber},text={fiber}}
    7072{
    7173Fibers are non-preemptive user-level threads. They share most of the caracteristics of user-level threads except that they cannot be preempted by another fiber.
     
    7577
    7678\longnewglossaryentry{job}
    77 {name={job}}
     79{name={Job},text={job}}
    7880{
    7981Unit of work, often sent to a thread pool or worker pool to be executed. Has neither its own stack nor its own thread of execution.
     
    8385
    8486\longnewglossaryentry{pool}
    85 {name={thread-pool}}
     87{name={Thread Pool},text={thread-pool}}
    8688{
    87 Group of homogeneuous threads that loop executing units of works after another.
     89Group of homogeneuous threads that loop executing units of works. Often executing \glspl{jobs}.
    8890
    89 \textit{Synonyms : }
     91\textit{Synonyms : Executor.}
    9092}
    9193
    9294\longnewglossaryentry{preemption}
    93 {name={preemption}}
     95{name={Preemption},text={preemption}}
    9496{
    9597Involuntary context switch imposed on threads at a given rate.
     
    98100}
    99101
    100 
    101 
    102 \longnewglossaryentry{at}
    103 {name={task}}
    104 {
    105 Abstract object representing an unit of work. Systems will offer one or more concrete implementations of this concept (\eg \gls{kthrd}, \gls{job}), however, most of the concept of schedulings are independent of the particular implementations of the work representation. For this reason, this document use the term \Gls{at} to mean any representation and not one in particular.
    106 }
    107 
    108102\longnewglossaryentry{atsched}
    109103{name={Scheduling a \gls{at}}}
    110104{
    111 Scheduling an \gls{at} refers to the act of notifying the scheduler that a task is ready to be ran. When representing the scheduler as a queue of tasks, scheduling is the act of pushing a task onto the end of the queue. This doesn't necesserily means the task will ever be allocated CPU time (\gls{atrun}), for example, if the system terminates abruptly, scheduled \glspl{at} will probably never run.
     105Scheduling a \at refers to the act of notifying the scheduler that a task is ready to be run. When representing the scheduler as a queue of tasks, scheduling is the act of pushing a task onto the end of the queue. This does not necessarily mean the task will ever be allocated CPU time (\gls{atrun}), for example, if the system terminates abruptly, scheduled \glspl{at} will probably never run.
    112106
    113 \textit{Synonyms : None.}
     107\textit{Synonyms : Unparking.}
    114108}
    115109
     
    117111{name={Running a \gls{at}}}
    118112{
    119 Running an \gls{at} refers to the act of allocating CPU time to a task that is ready to run. When representing the scheduler as a queue of tasks, running is the act of poping a task from the front of the queue and putting it onto a \gls{proc}. The \gls{at} can than accomplish some or all of the work it is programmed to do.
     113Running a \at refers to the act of allocating CPU time to a task that is ready to run. When representing the scheduler as a queue of tasks, running is the act of popping a task from the front of the queue and putting it onto a \gls{proc}. The \gls{at} can then accomplish some or all of the work it is programmed to do.
    120114
    121115\textit{Synonyms : None.}
     
    123117
    124118\longnewglossaryentry{atmig}
    125 {name={migration of \gls{at}}}
     119{name={Migration of \glspl{at}}}
    126120{
    127 Migration refers to the idea of an \gls{at} running on a different worker/processor than the last time it was run. It is generally preferable to minimise migration as it incurs cost but any load balancing among workers requires some amount of migration.
     121Migration refers to the idea of an \gls{at} running on a different \proc than the last time it was run. It is generally preferable to minimise migration as it incurs cost but any load balancing among \proc requires some amount of migration.
    128122
    129123\textit{Synonyms : None.}
     
    131125
    132126\longnewglossaryentry{atpass}
    133 {name={overtaking \gls{at}}}
     127{name={Overtaking \gls{at}}}
    134128{
    135129When representing the scheduler as a queue of \glspl{at}, overtaking is the act breaking the FIFO-ness of the queue by moving a \gls{at} in front of some other \gls{at} when it arrived after. This remains true for schedulers that do not use a FIFO queue, when the order in which the \glspl{at} are \glslink{atsched}{scheduled} and \glslink{atrun}{run} in a different order. A \gls{at} is said to \emph{overtake} another if it is run \emph{before} but was \emph{scheduled} after the other \gls{at}.
     
    143137Blocking an abstract task refers to the act of taking a task that us running on a CPU off the CPU. Unless no other task is ready, this action is generally immediately followed by running an other task.
    144138
    145 \textit{Synonyms : None.}
     139\textit{Synonyms : Parking.}
    146140}
    147141
     
    157151
    158152\longnewglossaryentry{load}
    159 {name={System Load}}
     153{name={System Load},text={load}}
    160154{
    161 The load is refers to the rate at which \glspl{at} are \glslink{atsched}{scheduled} versus the rate at which they are \glslink{atrun}{run}. When \glspl{at} are being scheduled faster than they are run, the system is considered \emph{overloaded}. When \glspl{at} are being run faster than they are scheduled, the system is considered \emph{underloaded}. Conrrespondingly, if both rates are equal, the system is considered \emph{loaded}. Note that the system is considered loaded only of the rate at which \glspl{at} are scheduled/run is non-zero, otherwise the system is empty, it has no load.
     155The System Load refers to the rate at which \glspl{at} are \glslink{atsched}{scheduled} versus the rate at which they are \glslink{atrun}{run}. When \glspl{at} are being scheduled faster than they are run, the system is considered \emph{overloaded}. When \glspl{at} are being run faster than they are scheduled, the system is considered \emph{underloaded}. Conrrespondingly, if both rates are equal, the system is considered \emph{loaded}. Note that the system is considered loaded only of the rate at which \glspl{at} are scheduled/run is non-zero, otherwise the system is empty, it has no load.
     156
     157\textit{Synonyms : CPU Load, System Load.}
    162158}
    163159
Note: See TracChangeset for help on using the changeset viewer.