>From e8d3761680aa3d5a978ddccf2b9c00b5920cd39e Mon Sep 17 00:00:00 2001
From: Akira Yokosawa <akiyks@xxxxxxxxx>
Date: Fri, 14 Sep 2018 22:11:18 +0900
Subject: [PATCH 1/2] count: Use new scheme for updated 2 snippets
Also use "static __inline__" for inlined function definitions.
Commit b1bab635598b ("Making the counter implementations safer")
introduced the __inline__ keyword. Inline functions defined in CodeSamples/api_pthreads/api-gcc.h have "static __inline__"
keywords. Such functions can not be used in functions which have
only __inline__. The commit avoided the mismatch by not adding
__inline__ to inc_count() in count_atomic.c.
Consistently using "static __inline__" should be a better
approach in this case.
Side effect: This change slightly increases height of code
snippets, and the "[bp]" placement specifier to
count_nonatomic.c originally appeared in commit 216744f9918e
("Add non-optimized counter material to the count chapter.")
back in 2009, which repeatedly swung among "[hp]", [tp], and
"[bp]" during 2016 and 2017, has finally become moot.
We can settle with the default "[tbp]".
Signed-off-by: Akira Yokosawa <akiyks@xxxxxxxxx>
CC: Imre Palik <imrep.amz@xxxxxxxxx>
---
Imre,
Changes in count_atomic.c and count_nonatomic.c should not affect
their performance so much. So all we need for now is the performance
data of count_nonatomic after applying the previous patch (now
commit c1e1273b3e17 in the repository.
Paul,
My plan is to take care of the other code under CodeSamples/count/
and update code snippets in Chapter 5 after the Figure 5.1 fix.
Thanks, Akira
--
CodeSamples/count/count_atomic.c | 16 +++++++-----
CodeSamples/count/count_nonatomic.c | 16 +++++++-----
count/count.tex | 51 +++++++++----------------------------
3 files changed, 30 insertions(+), 53 deletions(-)
diff --git a/CodeSamples/count/count_atomic.c b/CodeSamples/count/count_atomic.c
index fc73717..298f104 100644
--- a/CodeSamples/count/count_atomic.c
+++ b/CodeSamples/count/count_atomic.c
@@ -20,23 +20,25 @@
#include "../api.h"
-atomic_t counter = ATOMIC_INIT(0);
+//\begin{snippet}[labelbase=ln:count:count_atomic:inc-read,commandchars=\\\[\]]
+atomic_t counter = ATOMIC_INIT(0); //\lnlbl{counter}
-void inc_count(void)
+static __inline__ void inc_count(void)
{
- atomic_inc(&counter);
+ atomic_inc(&counter); //\lnlbl{inc}
}
-__inline__ long read_count(void)
+static __inline__ long read_count(void)
{
- return atomic_read(&counter);
+ return atomic_read(&counter); //\lnlbl{read}
}
+//\end{snippet}
-__inline__ void count_init(void)
+static __inline__ void count_init(void)
{
}
-__inline__ void count_cleanup(void)
+static __inline__ void count_cleanup(void)
{
}
diff --git a/CodeSamples/count/count_nonatomic.c b/CodeSamples/count/count_nonatomic.c
index 50df475..d5582b1 100644
--- a/CodeSamples/count/count_nonatomic.c
+++ b/CodeSamples/count/count_nonatomic.c
@@ -21,23 +21,25 @@
#include "../api.h"
-unsigned long counter = 0;
+//\begin{snippet}[labelbase=ln:count:count_nonatomic:inc-read,commandchars=\\\[\]]
+unsigned long counter = 0; //\lnlbl{counter}
-__inline__ void inc_count(void)
+static __inline__ void inc_count(void)
{
- WRITE_ONCE(counter, READ_ONCE(counter) + 1);
+ WRITE_ONCE(counter, READ_ONCE(counter) + 1); //\lnlbl{inc}
}
-__inline__ unsigned long read_count(void)
+static __inline__ unsigned long read_count(void)
{
- return READ_ONCE(counter);
+ return READ_ONCE(counter); //\lnlbl{read}
}
+//\end{snippet}
-__inline__ void count_init(void)
+static __inline__ void count_init(void)
{
}
-__inline__ void count_cleanup(void)
+static __inline__ void count_cleanup(void)
{
}
diff --git a/count/count.tex b/count/count.tex
index b9cd888..cfdacb5 100644
--- a/count/count.tex
+++ b/count/count.tex
@@ -165,24 +165,8 @@ are more appropriate for advanced students.
\section{Why Isn't Concurrent Counting Trivial?}
\label{sec:count:Why Isn't Concurrent Counting Trivial?}
-\begin{listing}[bp]
-{ \scriptsize
-\begin{verbbox}
- 1 long counter = 0;
- 2
- 3 void inc_count(void)
- 4 {
- 5 counter++;
- 6 }
- 7
- 8 long read_count(void)
- 9 {
- 10 return counter;
- 11 }
-\end{verbbox}
-}
-\centering
-\theverbbox
+\begin{listing}[tbp]
+\input{CodeSamples/count/count_nonatomic@xxxxxxxxxxxx}
\caption{Just Count!}
\label{lst:count:Just Count!}
\end{listing}
@@ -190,9 +174,11 @@ are more appropriate for advanced students.
Let's start with something simple, for example, the straightforward
use of arithmetic shown in
Listing~\ref{lst:count:Just Count!} (\path{count_nonatomic.c}).
-Here, we have a counter on line~1, we increment it on line~5, and we
-read out its value on line~10.
+\begin{lineref}[ln:count:count_nonatomic:inc-read]
+Here, we have a counter on line~\lnref{counter}, we increment it on
+line~\lnref{inc}, and we read out its value on line~\lnref{read}.
What could be simpler?
+\end{lineref}
This approach has the additional advantage of being blazingly fast if
you are doing lots of reading and almost no incrementing, and on small
@@ -243,23 +229,7 @@ accuracies far greater than 50\,\% are almost always necessary.
} \QuickQuizEnd
\begin{listing}[tbp]
-{ \scriptsize
-\begin{verbbox}
- 1 atomic_t counter = ATOMIC_INIT(0);
- 2
- 3 void inc_count(void)
- 4 {
- 5 atomic_inc(&counter);
- 6 }
- 7
- 8 long read_count(void)
- 9 {
- 10 return atomic_read(&counter);
- 11 }
-\end{verbbox}
-}
-\centering
-\theverbbox
+\input{CodeSamples/count/count_atomic@xxxxxxxxxxxx}
\caption{Just Count Atomically!}
\label{lst:count:Just Count Atomically!}
\end{listing}
@@ -274,8 +244,11 @@ accuracies far greater than 50\,\% are almost always necessary.
The straightforward way to count accurately is to use atomic operations,
as shown in
Listing~\ref{lst:count:Just Count Atomically!} (\path{count_atomic.c}).
-Line~1 defines an atomic variable, line~5 atomically increments it, and
-line~10 reads it out.
+\begin{lineref}[ln:count:count_atomic:inc-read]
+Line~\lnref{counter} defines an atomic variable,
+line~\lnref{inc} atomically increments it, and
+line~\lnref{read} reads it out.
+\end{lineref}
Because this is atomic, it keeps perfect count.
However, it is slower: on a Intel Core Duo laptop, it is about
six times slower than non-atomic increment
--
2.7.4
