Index: doc/theses/thierry_delisle_PhD/thesis/text/intro.tex
===================================================================
--- doc/theses/thierry_delisle_PhD/thesis/text/intro.tex	(revision 62424af292b77c62439ac8a7107e71e4bc01b55b)
+++ doc/theses/thierry_delisle_PhD/thesis/text/intro.tex	(revision fc96890db1a384795e9b3cb96a77554f585268ec)
@@ -3,5 +3,5 @@
 \Gls{uthrding} (M:N) is gaining popularity over kernel-level threading (1:1) in many programming languages.
 The user threading approach is often a better mechanism to express complex concurrent applications by efficiently running 10,000+ threads on multicore systems.
-Indeed, over-partitioning into small work-units with user threading significantly eases load bal\-ancing, while simultaneously providing advanced synchronization and mutual exclusion capabilities.
+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 the question of how many kernel threads are needed and should the number be dynamically reevaluated.
@@ -11,10 +11,10 @@
 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 \gls{uthrding}.
-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.
+This thesis analyzes multiple scheduler systems, where each system attempts to fulfill the requirements for \gls{uthrding}.
+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.
 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.
+Fairness is handled through preemption and/or ad hoc solutions, which leads to coarse-grained fairness with some pathological cases.
 
-After examining, testing and selecting specific approaches to these scheduling issues, a completely new scheduler was created and tested in the \CFA (C-for-all) user-threading runtime-system.
+After examining, testing and selecting specific approaches to these scheduling issues, a completely new scheduler was created and tested in the \CFA (C-for-all) user-threading runtime system.
 The goal of the new scheduler is to offer increased safety and productivity without sacrificing performance.
 The quality of the new scheduler is demonstrated by comparing it with other user-threading work-stealing schedulers with, the aim of showing equivalent or better performance while offering better fairness.
@@ -35,5 +35,5 @@
 In general, work units without threads, like routines and coroutines, are self-scheduling, while work units with threads, like tasks and programs, are scheduled.
 For scheduled work-units, a scheduler takes a sequence of threads and attempts to run them to completion, subject to shared resource restrictions and utilization.
-A general-purpose dynamic-scheduler for an open system cannot anticipate work requests, so its performance is rarely optimal.
+In an open system, a general-purpose dynamic scheduler cannot anticipate work requests, so its performance is rarely optimal.
 Even with complete knowledge of arrival order and work, creating an optimal solution is a bin packing problem~\cite{wiki:binpak}.
 However, optimal solutions are often not required: schedulers often produce excellent solutions, without needing optimality, by taking advantage of regularities in work patterns.
@@ -53,5 +53,5 @@
 timer alarm for preemption (running $\rightarrow$ ready)
 \item
-long term delay versus spinning (running $\rightarrow$ blocked)
+long-term delay versus spinning (running $\rightarrow$ blocked)
 \item
 completion of delay, \eg network or I/O completion (blocked $\rightarrow$ ready)
@@ -84,5 +84,5 @@
 
 \noindent
-Essentially, all multi-processor computers have non-uniform memory access (NUMA), with one or more quantized steps to access data at different levels in the memory hierarchy.
+Essentially, all multiprocessor computers have non-uniform memory access (NUMA), with one or more quantized steps to access data at different levels in the memory hierarchy.
 When a system has a large number of independently executing threads, affinity becomes difficult because of \newterm{thread churn}.
 That is, threads must be scheduled on different processors to obtain high processor utilization because the number of threads $\ggg$ processors.
@@ -120,8 +120,8 @@
 To complete the scheduler, an idle sleep mechanism is implemented that significantly reduces wasted CPU cycles, which are then available outside the application.
 
-As a research project, this work builds exclusively on newer versions of the Linux operating-system and gcc/clang compilers.
+As a research project, this work builds exclusively on newer versions of the Linux operating system and gcc/clang compilers.
 The new scheduler implementation uses several optimizations to successfully balance the cost of fairness against performance;
 some of these optimizations rely on interesting hardware optimizations only present on modern CPUs.
-The \io implementation is based on the @io_uring@ kernel-interface, a recent addition to the Linux kernel, because it purports to handle nonblocking \emph{file} and network \io.
+The \io implementation is based on the @io_uring@ kernel interface, a recent addition to the Linux kernel, because it purports to handle nonblocking \emph{file} and network \io.
 This decision allowed an interesting performance and fairness comparison with other threading systems using @select@, @epoll@, \etc.
 While the current \CFA release supports older versions of Linux ($\ge$~Ubuntu 16.04) and gcc/clang compilers ($\ge$~gcc 6.0), it is not the purpose of this project to find workarounds in these older systems to provide backwards compatibility.
@@ -129,5 +129,5 @@
 
 \section{Contributions}\label{s:Contributions}
-This work provides the following scheduling contributions for advanced \gls{uthrding} runtime-systems:
+This work provides the following scheduling contributions for advanced \gls{uthrding} runtime systems:
 \begin{enumerate}[leftmargin=*]
 \item
@@ -140,5 +140,5 @@
 A mechanism for adding fairness on top of MQMS algorithm through helping, used both for scalable scheduling algorithm and the user-level \glsxtrshort{io}.
 \item
-An optimization of the helping-mechanism for load balancing to reduce scheduling costs.
+An optimization of the helping mechanism for load balancing to reduce scheduling costs.
 \item
 An optimization for the alternative relaxed-list for load balancing to reduce scheduling costs in embarrassingly parallel cases.
