Index: doc/theses/thierry_delisle_PhD/thesis/text/practice.tex
===================================================================
--- doc/theses/thierry_delisle_PhD/thesis/text/practice.tex	(revision 6a6544da839d9f16847257dffabd6818341b0273)
+++ doc/theses/thierry_delisle_PhD/thesis/text/practice.tex	(revision 32d13834026c45a070b8ffbeecf6d71de04dd54a)
@@ -199,9 +199,10 @@
 Interestingly, general notification, \ie waking any idle processor versus a specific one, does not strictly require modifying the list.
 Here, contention can be reduced notably by having notifiers avoid the lock entirely by adding a pointer to the event @fd@ of the first idle \proc, as in Figure~\ref{fig:idle2}.
-To avoid contention among notifiers, notifiers atomically exchange it to @NULL@ so only one notifier contends on the system call.
-The first notifier will succeed the atomic exchange and obtain the @fd@ of an idle \proc.
-The notifier will the normally write to the @fd@, which will wake a \proc.
-The woken \proc can then update the atomic pointer while it is updating the head of the list.
-Notifiers that obtained a @NULL@ in the exchange simply move on, knowing that another notifier is already waking a \proc.
+To avoid contention among notifiers, notifiers atomically exchange the pointer with @NULL@.
+The first notifier succeeds on the exchange and obtains the @fd@ of an idle \proc;
+hence, only one notifier contends on the system call.
+This notifier writes to the @fd@ to wake a \proc.
+The woken \proc then updates the atomic pointer, while it is updating the head of the list, as it removes itself from the list.
+Notifiers that obtained a @NULL@ in the exchange simply move on knowing that another notifier is already waking a \proc.
 This behaviour is equivalent to having multiple notifier write to the @fd@ since reads consume all previous writes.
 Note that with and without this atomic pointer, bursts of notification can lead to an unspecified number of \procs being woken up, depending on how the arrival notification compares witht the latency of \procs waking up.
@@ -217,5 +218,5 @@
 
 The next optimization is to avoid the latency of the event @fd@, which can be done by adding what is effectively a binary benaphore\cit{benaphore} in front of the event @fd@.
-A simple three state flag is added beside the event @fd@ to avoid unnecessary system calls, as shown in Figure~\ref{fig:idle:state}.
+The benaphore over the event @fd@ logically provides a three state flag to avoid unnecessary system calls, where the states are expressed explicit in Figure~\ref{fig:idle:state}.
 A \proc begins its idle sleep by adding itself to the idle list before searching for an \at.
 In the process of adding itself to the idle list, it sets the state flag to @SEARCH@.