Discussions of the Parallel Programming book
 help / color / mirror / Atom feed
* [PATCH 1/2] count: Use new scheme for updated 2 snippets
@ 2018-09-15  2:08 Akira Yokosawa
  2018-09-15  2:14 ` [PATCH 2/2] count: Reword Quick Quiz 5.6 to adjust context Akira Yokosawa
  2018-09-16 22:01 ` [PATCH 1/2] count: Use new scheme for updated 2 snippets Paul E. McKenney
  0 siblings, 2 replies; 7+ messages in thread
From: Akira Yokosawa @ 2018-09-15  2:08 UTC (permalink / raw)
  To: Paul E. McKenney, Palik, Imre; +Cc: perfbook, Akira Yokosawa

From e8d3761680aa3d5a978ddccf2b9c00b5920cd39e Mon Sep 17 00:00:00 2001
From: Akira Yokosawa <akiyks@gmail.com>
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@gmail.com>
CC: Imre Palik <imrep.amz@gmail.com>
---
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@inc-read.fcv}
 \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@inc-read.fcv}
 \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


^ permalink raw reply related	[flat|nested] 7+ messages in thread
end of thread, other threads:[~2018-09-17  0:11 UTC | newest]

Thread overview: 7+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2018-09-15  2:08 [PATCH 1/2] count: Use new scheme for updated 2 snippets Akira Yokosawa
2018-09-15  2:14 ` [PATCH 2/2] count: Reword Quick Quiz 5.6 to adjust context Akira Yokosawa
2018-09-16 22:02   ` Paul E. McKenney
2018-09-16 22:52     ` Akira Yokosawa
2018-09-16 23:01       ` [PATCH] Enable hyperlink to line label in code snippet Akira Yokosawa
2018-09-17  0:11         ` Paul E. McKenney
2018-09-16 22:01 ` [PATCH 1/2] count: Use new scheme for updated 2 snippets Paul E. McKenney

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox