Changeset 918e0137 for doc/theses/thierry_delisle_PhD/thesis/text/front.tex

Timestamp:

Sep 8, 2022, 5:11:19 PM (21 months ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, master, pthread-emulation

Children:

264f6c9

Parents:

e4855f6

Message:

First pass at spellchecking until chapter 2

File:

• doc/theses/thierry_delisle_PhD/thesis/text/front.tex (modified) (1 diff)

doc/theses/thierry_delisle_PhD/thesis/text/front.tex

@@ -127 +127 @@
 Indeed, over-partitioning into small work-units with user threading significantly eases load bal\-ancing, while simultaneously providing advanced synchronization and mutual exclusion capabilities.
 To manage these high levels of concurrency, the underlying runtime must efficiently schedule many user threads across a few kernel threads;
-which begs of the question of how many kernel threads are needed and should the number be dynamically reevaluated.
+which begs the question of how many kernel threads are needed and should the number be dynamically reevaluated.
 Furthermore, scheduling must prevent kernel threads from blocking, otherwise user-thread parallelism drops.
-When user-threading parallelism does drop, how and when should idle kernel-threads be put to sleep to avoid wasting CPU resources.
+When user-threading parallelism does drop, how and when should idle \glspl{kthrd} be put to sleep to avoid wasting CPU resources.
 Finally, the scheduling system must provide fairness to prevent a user thread from monopolizing a kernel thread;
-otherwise other user threads can experience short/long term starvation or kernel threads can deadlock waiting for events to occur on busy kernel threads.
-
-This thesis analyses multiple scheduler systems, where each system attempts to fulfill the necessary requirements for user-level threading.
-The predominant technique for managing high levels of concurrency is sharding the ready-queue with one queue per kernel-thread and using some form of work stealing/sharing to dynamically rebalance workload shifts.
+otherwise, other user threads can experience short/long term starvation or kernel threads can deadlock waiting for events to occur on busy kernel threads.
+
+This thesis analyses multiple scheduler systems, where each system attempts to fulfill the requirements for user-level threading.
+The predominant technique for managing high levels of concurrency is sharding the ready-queue with one queue per \gls{kthrd} and using some form of work stealing/sharing to dynamically rebalance workload shifts.
 Preventing kernel blocking is accomplished by transforming kernel locks and I/O operations into user-level operations that do not block the kernel thread or spin up new kernel threads to manage the blocking.
 Fairness is handled through preemption and/or ad-hoc solutions, which leads to coarse-grained fairness with some pathological cases.