>From e11254e95c6d33eaf999a1e1c4831af2e141fb91 Mon Sep 17 00:00:00 2001
From: Akira Yokosawa <akiyks@xxxxxxxxx>
Date: Sun, 4 Sep 2016 08:01:50 +0900
Subject: [PATCH] treewide: Add \noindent where necessary
Since commit 213f584cd55b ("Add a few epigraphs") and following
commits, implicit no-indentation of first paragraph of a Chapter
has been lost.
This commit adds explicit "\noindent" after \epigraph{}s.
It also adds "\noindent" where some environment is used just
after "\section{}", "subsection{}", or "subsubsection{}.
Signed-off-by: Akira Yokosawa <akiyks@xxxxxxxxx>
---
SMPdesign/SMPdesign.tex | 1 +
SMPdesign/beyond.tex | 1 +
advsync/advsync.tex | 1 +
appendix/primitives/primitives.tex | 1 +
appendix/questions/questions.tex | 1 +
appendix/questions/time.tex | 1 +
appendix/whymb/whymemorybarriers.tex | 1 +
count/count.tex | 7 +++++++
cpu/cpu.tex | 1 +
datastruct/datastruct.tex | 4 ++++
debugging/debugging.tex | 2 ++
defer/defer.tex | 1 +
defer/rcufundamental.tex | 1 +
defer/rcuusage.tex | 1 +
defer/refcnt.tex | 1 +
defer/toyrcu.tex | 9 +++++++++
formal/axiomatic.tex | 1 +
formal/dyntickrcu.tex | 7 +++++++
formal/formal.tex | 1 +
formal/ppcmem.tex | 1 +
formal/spinhint.tex | 3 +++
future/cpu.tex | 1 +
future/future.tex | 1 +
intro/intro.tex | 1 +
locking/locking-existence.tex | 1 +
locking/locking.tex | 4 ++++
owned/owned.tex | 1 +
rt/rt.tex | 4 ++++
together/applyrcu.tex | 4 ++++
together/together.tex | 1 +
toolsoftrade/toolsoftrade.tex | 1 +
31 files changed, 66 insertions(+)
diff --git a/SMPdesign/SMPdesign.tex b/SMPdesign/SMPdesign.tex
index 4006186..6534506 100644
--- a/SMPdesign/SMPdesign.tex
+++ b/SMPdesign/SMPdesign.tex
@@ -4,6 +4,7 @@
\epigraph{Divide and rule.}{\emph{Philip II of Macedon}}
+\noindent
This chapter describes how to design software to take advantage of
the multiple CPUs that are increasingly appearing in commodity systems.
It does this by presenting a number of idioms, or
diff --git a/SMPdesign/beyond.tex b/SMPdesign/beyond.tex
index c64f580..3a8b3a0 100644
--- a/SMPdesign/beyond.tex
+++ b/SMPdesign/beyond.tex
@@ -86,6 +86,7 @@ presents future directions and concluding remarks.
\label{fig:SMPdesign:SEQ Pseudocode}
\end{figure}
+\noindent
PWQ is based on SEQ, which is shown in
Figure~\ref{fig:SMPdesign:SEQ Pseudocode}
(\path{maze_seq.c}).
diff --git a/advsync/advsync.tex b/advsync/advsync.tex
index 4384ea2..a573674 100644
--- a/advsync/advsync.tex
+++ b/advsync/advsync.tex
@@ -5,6 +5,7 @@
\epigraph{If a little knowledge is a dangerous thing, just imagine all
the havoc you could wreak with a lot of knowledge!}{\emph{Unknown}}
+\noindent
This section discusses a number of ways of using weaker, and hopefully
lower-cost, synchronization primitives.
This weakening can be quite helpful, in fact, some have argued
diff --git a/appendix/primitives/primitives.tex b/appendix/primitives/primitives.tex
index e0ec93c..c815c7a 100644
--- a/appendix/primitives/primitives.tex
+++ b/appendix/primitives/primitives.tex
@@ -2,6 +2,7 @@
\QuickQuizChapter{app:primitives:Synchronization Primitives}{Synchronization Primitives}
+\noindent
All but the simplest parallel programs require synchronization
primitives.
This appendix gives a quick overview of a set of primitives based
diff --git a/appendix/questions/questions.tex b/appendix/questions/questions.tex
index b921a38..f94619f 100644
--- a/appendix/questions/questions.tex
+++ b/appendix/questions/questions.tex
@@ -6,6 +6,7 @@
\epigraph{Ask me no questions, and I'll tell you no fibs.}
{\emph{``She Stoops to Conquer'', Oliver Goldsmith}}
+\noindent
The following sections discuss some important questions relating to
SMP programming.
Each section also shows how to {\em avoid} having to worry about
diff --git a/appendix/questions/time.tex b/appendix/questions/time.tex
index 137375e..063307c 100644
--- a/appendix/questions/time.tex
+++ b/appendix/questions/time.tex
@@ -11,6 +11,7 @@
\ContributedBy{Figure}{fig:app:questions:What Time Is It?}{Melissa Broussard}
\end{figure}
+\noindent
A key issue with timekeeping on multicore computer systems is illustrated
by Figure~\ref{fig:app:questions:What Time Is It?}.
One problem is that it takes time to read out the time.
diff --git a/appendix/whymb/whymemorybarriers.tex b/appendix/whymb/whymemorybarriers.tex
index 2ee2db3..ba7e768 100644
--- a/appendix/whymb/whymemorybarriers.tex
+++ b/appendix/whymb/whymemorybarriers.tex
@@ -2,6 +2,7 @@
\QuickQuizChapter{chp:app:whymb:Why Memory Barriers?}{Why Memory Barriers?}
+\noindent
So what possessed CPU designers to cause them to inflict memory barriers
on poor unsuspecting SMP software designers?
diff --git a/count/count.tex b/count/count.tex
index e433bac..d2683fb 100644
--- a/count/count.tex
+++ b/count/count.tex
@@ -4,6 +4,7 @@
\epigraph{As easy as 1, 2, 3!}{\emph{Unknown}}
+\noindent
Counting is perhaps the simplest and most natural thing a computer can do.
However, counting efficiently and scalably on a large
shared-memory multiprocessor can be quite challenging.
@@ -187,6 +188,7 @@ are more appropriate for advanced students.
\label{fig:count:Just Count!}
\end{figure}
+\noindent
Let's start with something simple, for example, the straightforward
use of arithmetic shown in
Figure~\ref{fig:count:Just Count!} (\path{count_nonatomic.c}).
@@ -986,6 +988,7 @@ comes at the cost of the additional thread running \co{eventual()}.
\label{fig:count:Per-Thread Statistical Counters}
\end{figure}
+\noindent
Fortunately, gcc provides an \co{__thread} storage class that provides
per-thread storage.
This can be used as shown in
@@ -1412,6 +1415,7 @@ Section~\ref{sec:SMPdesign:Parallel Fastpath}.
\label{fig:count:Simple Limit Counter Variable Relationships}
\end{figure}
+\noindent
Figure~\ref{fig:count:Simple Limit Counter Variables}
shows both the per-thread and global variables used by this
implementation.
@@ -1944,6 +1948,7 @@ This task is undertaken in the next section.
\label{fig:count:Approximate Limit Counter Balancing}
\end{figure}
+\noindent
Because this implementation (\path{count_lim_app.c}) is quite similar to
that in the previous section
(Figures~\ref{fig:count:Simple Limit Counter Variables},
@@ -2580,6 +2585,7 @@ atomic operations are not necessary, as shown in the next section.
\label{fig:count:Signal-Theft State Machine}
\end{figure}
+\noindent
Even though per-thread state will now be manipulated only by the
corresponding thread, there will still need to be synchronization
with the signal handlers.
@@ -2695,6 +2701,7 @@ The slowpath then sets that thread's \co{theft} state to IDLE.
\label{fig:count:Signal-Theft Limit Counter Data}
\end{figure}
+\noindent
Figure~\ref{fig:count:Signal-Theft Limit Counter Data}
(\path{count_lim_sig.c})
shows the data structures used by the signal-theft based counter
diff --git a/cpu/cpu.tex b/cpu/cpu.tex
index 6bfdf91..43ccb38 100644
--- a/cpu/cpu.tex
+++ b/cpu/cpu.tex
@@ -6,6 +6,7 @@
\epigraph{Premature abstraction is the root of all evil.}
{\emph{A cast of thousands}}
+\noindent
Most people have an intuitive understanding that passing messages between
systems is considerably more expensive than performing simple calculations
within the confines of a single system.
diff --git a/datastruct/datastruct.tex b/datastruct/datastruct.tex
index c963da5..7a05fa8 100644
--- a/datastruct/datastruct.tex
+++ b/datastruct/datastruct.tex
@@ -6,6 +6,7 @@
about data structures and their relationships.}
{\emph{Linus Torvalds}}
+\noindent
Efficient access to data is critically important, so that
discussions of algorithms include time complexity of the related
data structures~\cite{ThomasHCorman2001Algorithms}.
@@ -172,6 +173,7 @@ offers excellent scalability.
\label{fig:datastruct:Hash-Table Data-Structure Diagram}
\end{figure}
+\noindent
Figure~\ref{fig:datastruct:Hash-Table Data Structures}
(\path{hash_bkt.c})
shows a set of data structures used in a simple fixed-sized hash
@@ -568,6 +570,7 @@ section~\cite{McKenney:2013:SDS:2483852.2483867}.
\label{fig:datastruct:RCU-Protected Hash-Table Read-Side Concurrency Control}
\end{figure}
+\noindent
For an RCU-protected hash table with per-bucket locking,
updaters use locking exactly as described in
Section~\ref{sec:datastruct:Partitionable Data Structures},
@@ -1055,6 +1058,7 @@ which is the subject of the next section.
\label{fig:datastruct:Resizable Hash-Table Data Structures}
\end{figure}
+\noindent
Resizing is accomplished by the classic approach of inserting a level
of indirection, in this case, the \co{ht} structure shown on
lines~12-25 of
diff --git a/debugging/debugging.tex b/debugging/debugging.tex
index 2207a0e..727357d 100644
--- a/debugging/debugging.tex
+++ b/debugging/debugging.tex
@@ -4,6 +4,7 @@
\epigraph{If it is not tested, it doesn't work.}{\emph{Unknown}}
+\noindent
I have had a few parallel programs work the first time, but that is only
because I have written a large number parallel programs over the past two
decades.
@@ -2305,6 +2306,7 @@ detecting interference via measurement
\ContributedBy{Figure}{fig:debugging:Choose Validation Methods Wisely}{Melissa Broussard}
\end{figure}
+\noindent
Although validation never will be an exact science, much can be gained
by taking an organized approach to it, as an organized approach will
help you choose the right validation tools for your job, avoiding
diff --git a/defer/defer.tex b/defer/defer.tex
index bb1e679..c83ba38 100644
--- a/defer/defer.tex
+++ b/defer/defer.tex
@@ -5,6 +5,7 @@
\epigraph{All things come to those who wait.}{\emph{Violet Fane}}
+\noindent
The strategy of deferring work goes back before the dawn of recorded
history. It has occasionally been derided as procrastination or
even as sheer laziness.
diff --git a/defer/rcufundamental.tex b/defer/rcufundamental.tex
index cf73f30..10c2caa 100644
--- a/defer/rcufundamental.tex
+++ b/defer/rcufundamental.tex
@@ -93,6 +93,7 @@ summarizes RCU fundamentals.
\label{fig:defer:Data Structure Publication (Unsafe)}
\end{figure}
+\noindent
One key attribute of RCU is the ability to safely scan data, even
though that data is being modified concurrently.
To provide this ability for concurrent insertion,
diff --git a/defer/rcuusage.tex b/defer/rcuusage.tex
index a8c0973..2f32e8a 100644
--- a/defer/rcuusage.tex
+++ b/defer/rcuusage.tex
@@ -135,6 +135,7 @@ Section~\ref{sec:defer:RCU Usage Summary} provides a summary.
\label{fig:defer:RCU Pre-BSD Routing Table Add/Delete}
\end{figure}
+\noindent
Figures~\ref{fig:defer:RCU Pre-BSD Routing Table Lookup}
and~\ref{fig:defer:RCU Pre-BSD Routing Table Add/Delete}
show code for an RCU-protected Pre-BSD routing table
diff --git a/defer/refcnt.tex b/defer/refcnt.tex
index 14aaf4d..424d181 100644
--- a/defer/refcnt.tex
+++ b/defer/refcnt.tex
@@ -117,6 +117,7 @@
\label{fig:defer:Reference-Counted Pre-BSD Routing Table Add/Delete}
\end{figure}
+\noindent
Reference counting tracks the number of references to a given object in
order to prevent that object from being prematurely freed.
As such, it has a long and honorable history of use dating back to
diff --git a/defer/toyrcu.tex b/defer/toyrcu.tex
index cd334ed..dfb69e1 100644
--- a/defer/toyrcu.tex
+++ b/defer/toyrcu.tex
@@ -59,6 +59,7 @@ provides a summary and a list of desirable RCU properties.
\label{fig:defer:Lock-Based RCU Implementation}
\end{figure}
+\noindent
Perhaps the simplest RCU implementation leverages locking, as
shown in
Figure~\ref{fig:defer:Lock-Based RCU Implementation}
@@ -201,6 +202,7 @@ in the next section.
\label{fig:defer:Per-Thread Lock-Based RCU Implementation}
\end{figure}
+\noindent
Figure~\ref{fig:defer:Per-Thread Lock-Based RCU Implementation}
(\path{rcu_lock_percpu.h} and \path{rcu_lock_percpu.c})
shows an implementation based on one lock per thread.
@@ -324,6 +326,7 @@ the shortcomings of the lock-based implementation.
\label{fig:defer:RCU Implementation Using Single Global Reference Counter}
\end{figure}
+\noindent
A slightly more sophisticated RCU implementation is shown in
Figure~\ref{fig:defer:RCU Implementation Using Single Global Reference Counter}
(\path{rcu_rcg.h} and \path{rcu_rcg.c}).
@@ -492,6 +495,7 @@ scheme that is more favorable to writers.
\label{fig:defer:RCU Read-Side Using Global Reference-Count Pair}
\end{figure}
+\noindent
Figure~\ref{fig:defer:RCU Read-Side Using Global Reference-Count Pair}
(\path{rcu_rcgp.h})
shows the read-side primitives of an RCU implementation that uses a pair
@@ -826,6 +830,7 @@ scheme that provides greatly improved read-side performance and scalability.
\label{fig:defer:RCU Read-Side Using Per-Thread Reference-Count Pair}
\end{figure}
+\noindent
Figure~\ref{fig:defer:RCU Read-Side Using Per-Thread Reference-Count Pair}
(\path{rcu_rcpl.h})
shows the read-side primitives of an RCU implementation that uses per-thread
@@ -1033,6 +1038,7 @@ concurrent RCU updates.
\label{fig:defer:RCU Read-Side Using Per-Thread Reference-Count Pair and Shared Update}
\end{figure}
+\noindent
Figure~\ref{fig:defer:RCU Read-Side Using Per-Thread Reference-Count Pair and Shared Update}
(\path{rcu_rcpls.h})
shows the read-side primitives for an RCU implementation using per-thread
@@ -1262,6 +1268,7 @@ thread-local accesses to one, as is done in the next section.
\label{fig:defer:Free-Running Counter Using RCU}
\end{figure}
+\noindent
Figure~\ref{fig:defer:Free-Running Counter Using RCU}
(\path{rcu.h} and \path{rcu.c})
shows an RCU implementation based on a single global free-running counter
@@ -1463,6 +1470,7 @@ variables.
\label{fig:defer:Nestable RCU Using a Free-Running Counter}
\end{figure}
+\noindent
Figure~\ref{fig:defer:Nestable RCU Using a Free-Running Counter}
(\path{rcu_nest.h} and \path{rcu_nest.c})
show an RCU implementation based on a single global free-running counter,
@@ -1730,6 +1738,7 @@ overhead.
\label{fig:defer:Quiescent-State-Based RCU Read Side}
\end{figure}
+\noindent
Figure~\ref{fig:defer:Quiescent-State-Based RCU Read Side}
(\path{rcu_qs.h})
shows the read-side primitives used to construct a user-level
diff --git a/formal/axiomatic.tex b/formal/axiomatic.tex
index cc420cf..2a32ca2 100644
--- a/formal/axiomatic.tex
+++ b/formal/axiomatic.tex
@@ -31,6 +31,7 @@
\label{fig:formal:IRIW Litmus Test}
\end{figure*}
+\noindent
Although the PPCMEM tool can solve the famous ``independent reads of
independent writes'' (IRIW) litmus test shown in
Figure~\ref{fig:formal:IRIW Litmus Test}, doing so requires no less than
diff --git a/formal/dyntickrcu.tex b/formal/dyntickrcu.tex
index 2cd8310..ade08c6 100644
--- a/formal/dyntickrcu.tex
+++ b/formal/dyntickrcu.tex
@@ -313,6 +313,7 @@ preemptible RCU's grace-period machinery.
\label{fig:formal:Preemptible RCU State Machine}
\end{figure}
+\noindent
Of the four preemptible RCU grace-period states shown in
Figure~\ref{fig:formal:Preemptible RCU State Machine},
only the \co{rcu_try_flip_waitack_state()}
@@ -1796,6 +1797,7 @@ states, passing without errors.
\label{fig:formal:Variable-Name-Typo Fix Patch}
\end{figure}
+\noindent
This effort provided some lessons (re)learned:
\begin{enumerate}
@@ -1876,6 +1878,7 @@ Manfred Spraul~\cite{ManfredSpraul2008StateMachineRCU}.
\label{fig:formal:Variables for Simple Dynticks Interface}
\end{figure}
+\noindent
Figure~\ref{fig:formal:Variables for Simple Dynticks Interface}
shows the new per-CPU state variables.
These variables are grouped into structs to allow multiple independent
@@ -1977,6 +1980,7 @@ passed through a quiescent state during that interval.
\label{fig:formal:Entering and Exiting Dynticks-Idle Mode}
\end{figure}
+\noindent
Figure~\ref{fig:formal:Entering and Exiting Dynticks-Idle Mode}
shows the \co{rcu_enter_nohz()} and \co{rcu_exit_nohz()},
which enter and exit dynticks-idle mode, also known as ``nohz'' mode.
@@ -2034,6 +2038,7 @@ the opposite \co{dynticks} polarity.
\label{fig:formal:NMIs From Dynticks-Idle Mode}
\end{figure}
+\noindent
Figure~\ref{fig:formal:NMIs From Dynticks-Idle Mode}
shows the \co{rcu_nmi_enter()} and \co{rcu_nmi_exit()} functions,
which inform RCU of NMI entry and exit, respectively, from dynticks-idle
@@ -2089,6 +2094,7 @@ respectively.
\label{fig:formal:Interrupts From Dynticks-Idle Mode}
\end{figure}
+\noindent
Figure~\ref{fig:formal:Interrupts From Dynticks-Idle Mode}
shows \co{rcu_irq_enter()} and \co{rcu_irq_exit()}, which
inform RCU of entry to and exit from, respectively, irq context.
@@ -2146,6 +2152,7 @@ a reschedule API if so.
\label{fig:formal:Saving Dyntick Progress Counters}
\end{figure}
+\noindent
Figure~\ref{fig:formal:Saving Dyntick Progress Counters}
shows \co{dyntick_save_progress_counter()}, which takes a snapshot
of the specified CPU's \co{dynticks} and \co{dynticks_nmi}
diff --git a/formal/formal.tex b/formal/formal.tex
index ed9d7a3..2963cf4 100644
--- a/formal/formal.tex
+++ b/formal/formal.tex
@@ -8,6 +8,7 @@
\OriginallyPublished{Appendix}{chp:formal:Formal Verification}{Formal Verification}{Linux Weekly News}{PaulEMcKenney2007QRCUspin,PaulEMcKenney2008dynticksRCU,PaulEMcKenney2011ppcmem}
+\noindent
Parallel algorithms can be hard to write, and even harder to debug.
Testing, though essential, is insufficient, as fatal race conditions
can have extremely low probabilities of occurrence.
diff --git a/formal/ppcmem.tex b/formal/ppcmem.tex
index c5ec6ed..99c48f3 100644
--- a/formal/ppcmem.tex
+++ b/formal/ppcmem.tex
@@ -85,6 +85,7 @@ discusses the implications.
\label{fig:sec:formal:PPCMEM Litmus Test}
\end{figure}
+\noindent
An example PowerPC litmus test for PPCMEM is shown in
Figure~\ref{fig:sec:formal:PPCMEM Litmus Test}.
The ARM interface works exactly the same way, but with ARM instructions
diff --git a/formal/spinhint.tex b/formal/spinhint.tex
index a5630f3..a7c9a7e 100644
--- a/formal/spinhint.tex
+++ b/formal/spinhint.tex
@@ -109,6 +109,7 @@ more complex uses.
\label{fig:analysis:Promela Code for Non-Atomic Increment}
\end{figure}
+\noindent
Figure~\ref{fig:analysis:Promela Code for Non-Atomic Increment}
demonstrates the textbook race condition
resulting from non-atomic increment.
@@ -337,6 +338,7 @@ unreached in proctype :init:
\label{fig:analysis:Atomic Increment spin Output}
\end{figure}
+\noindent
It is easy to fix this example by placing the body of the incrementer
processes in an atomic blocks as shown in
Figure~\ref{fig:analysis:Promela Code for Atomic Increment}.
@@ -632,6 +634,7 @@ Now we are ready for more complex examples.
\label{fig:analysis:Promela Code for Spinlock}
\end{figure}
+\noindent
Since locks are generally useful, \co{spin_lock()} and
\co{spin_unlock()}
macros are provided in \path{lock.h}, which may be included from
diff --git a/future/cpu.tex b/future/cpu.tex
index 31cbc18..18a69f4 100644
--- a/future/cpu.tex
+++ b/future/cpu.tex
@@ -180,6 +180,7 @@ Servers seem to be choosing the former, while embedded systems on a chip
\label{fig:future:Breakevens vs. r, Worst-Case lambda, Four CPUs}
\end{figure}
+\noindent
And one more quote from 2004~\cite{PaulEdwardMcKenneyPhD}:
\begin{quote}
diff --git a/future/future.tex b/future/future.tex
index 3a19b04..c924cbe 100644
--- a/future/future.tex
+++ b/future/future.tex
@@ -6,6 +6,7 @@
\epigraph{Prediction is very difficult, especially about the future.}
{\emph{Niels Bohr}}
+\noindent
This chapter presents some conflicting visions of the future of parallel
programming.
It is not clear which of these will come to pass, in fact, it is not
diff --git a/intro/intro.tex b/intro/intro.tex
index e54e5ad..8e9770f 100644
--- a/intro/intro.tex
+++ b/intro/intro.tex
@@ -6,6 +6,7 @@
\epigraph{If parallel programming is so hard, why are there any
parallel programs?}{\emph{Unknown}}
+\noindent
Parallel programming has earned a reputation as one of the most
difficult areas a hacker can tackle.
Papers and textbooks warn of the perils of deadlock, livelock,
diff --git a/locking/locking-existence.tex b/locking/locking-existence.tex
index 506f0b5..b50cb00 100644
--- a/locking/locking-existence.tex
+++ b/locking/locking-existence.tex
@@ -29,6 +29,7 @@
\label{fig:locking:Per-Element Locking Without Existence Guarantees}
\end{figure}
+\noindent
A key challenge in parallel programming is to provide
\emph{existence guarantees}~\cite{Gamsa99},
so that attempts to access a given object can rely on that object
diff --git a/locking/locking.tex b/locking/locking.tex
index c5e45bf..16ab0df 100644
--- a/locking/locking.tex
+++ b/locking/locking.tex
@@ -8,6 +8,7 @@
to the memory of Winston Churchill and to whoever he was
quoting}}
+\noindent
In recent concurrency research, the role of villain is often played
by locking.
In many papers and presentations,
@@ -531,6 +532,7 @@ this is unlikely.
\label{fig:locking:Protocol Layering and Deadlock}
\end{figure}
+\noindent
But suppose that there is no reasonable locking hierarchy.
This can happen in real life, for example, in layered network protocol stacks
where packets flow in both directions.
@@ -874,6 +876,7 @@ quite useful in many settings.
\label{fig:locking:Abusing Conditional Locking}
\end{figure}
+\noindent
Although conditional locking can be an effective deadlock-avoidance
mechanism, it can be abused.
Consider for example the beautifully symmetric example shown in
@@ -1649,6 +1652,7 @@ environments.
\label{fig:locking:Sample Lock Based on Atomic Exchange}
\end{figure}
+\noindent
This section reviews the implementation shown in
Figure~\ref{fig:locking:Sample Lock Based on Atomic Exchange}.
The data structure for this lock is just an \co{int}, as shown on
diff --git a/owned/owned.tex b/owned/owned.tex
index b6e9e02..2d1188d 100644
--- a/owned/owned.tex
+++ b/owned/owned.tex
@@ -5,6 +5,7 @@
\epigraph{It is mine, I tell you. My own. My precious. Yes, my precious.}
{\emph{Gollum in ``The Fellowship of the Ring'', J.R.R.~Tolkien}}
+\noindent
One of the simplest ways to avoid the synchronization overhead that
comes with locking is to parcel the data out among the threads (or,
in the case of kernels, CPUs)
diff --git a/rt/rt.tex b/rt/rt.tex
index 1fe1e7c..ecd2fec 100644
--- a/rt/rt.tex
+++ b/rt/rt.tex
@@ -5,6 +5,7 @@
\epigraph{The difference between you and me is that I was right in time.}
{\emph{Konrad Adenauer}}
+\noindent
An important emerging area in computing is that of parallel real-time
computing.
Section~\ref{sec:rt:What is Real-Time Computing?}
@@ -80,6 +81,7 @@ some measure of exactly how soft it is.
\ContributedBy{Figure}{fig:rt:Hard Real-Time Response Guarantee, Meet Hammer}{Melissa Broussard}
\end{figure}
+\noindent
In contrast, the definition of hard real time is quite definite.
After all, a given system either always meets its deadlines or it
doesn't.
@@ -685,6 +687,7 @@ the next section.
\label{fig:rt:Linux Ported to RTOS}
\end{figure}
+\noindent
There are a number of strategies that may be used to implement a
real-time system.
One approach is to port a general-purpose non-real-time OS on top
@@ -1882,6 +1885,7 @@ data-structure access to real-time programs.
\ContributedBy{Figure}{fig:rt:The Dark Side of Real-Fast Computing}{Sarah McKenney}
\end{figure}
+\noindent
The choice between real-time and real-fast computing can be a difficult one.
Because real-time systems often inflict a throughput penalty on non-real-time
computing, using real-time when it is not required can cause problems,
diff --git a/together/applyrcu.tex b/together/applyrcu.tex
index 7309fe2..5cab8da 100644
--- a/together/applyrcu.tex
+++ b/together/applyrcu.tex
@@ -189,6 +189,7 @@ held constant, ensuring that \co{read_count()} sees consistent data.
\label{fig:together:RCU and Per-Thread Statistical Counters}
\end{figure}
+\noindent
Lines~1-4 of
Figure~\ref{fig:together:RCU and Per-Thread Statistical Counters}
show the \co{countarray} structure, which contains a
@@ -306,6 +307,7 @@ Line~69 can then safely free the old \co{countarray} structure.
Figure~\ref{fig:together:RCU and Per-Thread Statistical Counters}!
} \QuickQuizEnd
+\noindent
Use of RCU enables exiting threads to wait until other threads are
guaranteed to be done using the exiting threads' \co{__thread} variables.
This allows the \co{read_count()} function to dispense with locking,
@@ -404,6 +406,7 @@ tradeoff.
\label{fig:together:RCU-Protected Variable-Length Array}
\end{figure}
+\noindent
Suppose we have an RCU-protected variable-length array, as shown in
Figure~\ref{fig:together:RCU-Protected Variable-Length Array}.
The length of the array \co{->a[]} can change dynamically, and at any
@@ -499,6 +502,7 @@ A more general version of this approach is presented in the next section.
\label{fig:together:Uncorrelated Measurement Fields}
\end{figure}
+\noindent
Suppose that each of Sch\"odinger's animals is represented by the
data element shown in
Figure~\ref{fig:together:Uncorrelated Measurement Fields}.
diff --git a/together/together.tex b/together/together.tex
index 8a8e8cb..46b33cf 100644
--- a/together/together.tex
+++ b/together/together.tex
@@ -10,6 +10,7 @@
% And the paragraph preceding this is also instructive:
% ``I may be pissed off, but that doesn't mean I can't learn.
+\noindent
This chapter gives a few hints on handling some concurrent-programming
puzzles, starting with counter conundrums in
Section~\ref{sec:together:Counter Conundrums},
diff --git a/toolsoftrade/toolsoftrade.tex b/toolsoftrade/toolsoftrade.tex
index 130faaf..58427da 100644
--- a/toolsoftrade/toolsoftrade.tex
+++ b/toolsoftrade/toolsoftrade.tex
@@ -5,6 +5,7 @@
\epigraph{You are only as good as your tools, and your tools are only
as good as you are.}{\emph{Unknown}}
+\noindent
This chapter provides a brief introduction to some basic tools of the
parallel-programming trade, focusing mainly on those available to
user applications running on operating systems similar to Linux.
--
1.9.1
--
To unsubscribe from this list: send the line "unsubscribe perfbook" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
