From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=to:cc:from:subject:message-id:date:user-agent:mime-version :content-language:content-transfer-encoding; bh=W3i7XjYMlF6SVNLPq92sU2UFF0hPNpMQV0byBzJtBdk=; b=Ys62e2km+qidnBTCFWWNP7c3RDaqR25/PvNz369IHrVWXsXuZwFjt/yzynmjQKX+XL 2PNWtmCl9RdQ7NwiTAcO1OJBiSDmhwwlaUqfuruCw8I5L8Lj1+j3WWyO+elELxvHh7W3 JwLdpxF6yAnkFitB5Rbta2TNLRjgnMC4kgNRxPQskXYJ5JfimuKvtiT7knsfNoS/24X2 /Hv1JK7IvT+yFjEYdg6K/eKOzMUtUS2k2ejzkmPVRXihrCEOMM/0YzJ+Nm5eD/j+O18V 3U08iZ3yXRAKqLF2miG7rR1m9Qf9aIUZe0z3ZfjpzLqztQ75cag8b3IdkW+6VhlT/TUd C5HA== From: Akira Yokosawa Subject: [PATCH] count: Employ new scheme for snippet of count_stat_eventual.c Message-ID: Date: Sat, 6 Oct 2018 07:35:42 +0900 MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 7bit To: "Paul E. McKenney" Cc: perfbook@vger.kernel.org, Akira Yokosawa List-ID: >From 16fb7e39700268cd498f88c16b34170e3b91fd24 Mon Sep 17 00:00:00 2001 From: Akira Yokosawa Date: Thu, 6 Oct 2018 07:20:06 +0900 Subject: [PATCH] count: Employ new scheme for snippet of count_stat_eventual.c Also omit READ_ONCE()s which access variables owned and modified only by the owning thread. Read part of stopflag's increment in eventual() doesn't need READ_ONCE() because once the "if" statement stands, stopflag won't be modified by any other thread. Also modify code around pthread_create() in count_init() so that the "if" statement won't be too wide for a code snippet in two- column layout. Signed-off-by: Akira Yokosawa --- Paul, I might be missing something in omitting READ_ONCE() of stopflag's increment in eventual(). If this were kernel code, we wouldn't be able to make sure that eventual() is the only updater after the particular point in execution. Thoughts? Thanks, Akira -- CodeSamples/count/count_stat_eventual.c | 38 +++++++++------- count/count.tex | 81 +++++++-------------------------- 2 files changed, 37 insertions(+), 82 deletions(-) diff --git a/CodeSamples/count/count_stat_eventual.c b/CodeSamples/count/count_stat_eventual.c index 324bc24..fa8972f 100644 --- a/CodeSamples/count/count_stat_eventual.c +++ b/CodeSamples/count/count_stat_eventual.c @@ -21,22 +21,24 @@ #include "../api.h" -DEFINE_PER_THREAD(unsigned long, counter); -unsigned long global_count; -int stopflag; +//\begin{snippet}[labelbase=ln:count:count_stat_eventual:whole,commandchars=\$\[\]] +DEFINE_PER_THREAD(unsigned long, counter); //\lnlbl{per_thr_cnt} +unsigned long global_count; //\lnlbl{glb_cnt} +int stopflag; //\lnlbl{stopflag} -void inc_count(void) +static __inline__ void inc_count(void) //\lnlbl{inc:b} { - WRITE_ONCE(__get_thread_var(counter), - READ_ONCE(__get_thread_var(counter)) + 1); -} + unsigned long *p_counter = &__get_thread_var(counter); -__inline__ unsigned long read_count(void) + WRITE_ONCE(*p_counter, *p_counter + 1); +} //\lnlbl{inc:e} + +static __inline__ unsigned long read_count(void) //\lnlbl{read:b} { return READ_ONCE(global_count); -} +} //\lnlbl{read:e} -void *eventual(void *arg) +void *eventual(void *arg) //\lnlbl{eventual:b} { int t; unsigned long sum; @@ -49,29 +51,31 @@ void *eventual(void *arg) poll(NULL, 0, 1); if (READ_ONCE(stopflag)) { smp_mb(); - WRITE_ONCE(stopflag, READ_ONCE(stopflag) + 1); + WRITE_ONCE(stopflag, stopflag + 1); } } return NULL; -} +} //\lnlbl{eventual:e} -void count_init(void) +void count_init(void) //\lnlbl{init:b} { int en; thread_id_t tid; - if ((en = pthread_create(&tid, NULL, eventual, NULL)) != 0) { + en = pthread_create(&tid, NULL, eventual, NULL); + if (en != 0) { fprintf(stderr, "pthread_create: %s\n", strerror(en)); exit(EXIT_FAILURE); } -} +} //\lnlbl{init:e} -void count_cleanup(void) +void count_cleanup(void) //\lnlbl{cleanup:b} { WRITE_ONCE(stopflag, 1); while (READ_ONCE(stopflag) < 3) poll(NULL, 0, 1); smp_mb(); -} +} //\lnlbl{cleanup:e} +//\end{snippet} #include "counttorture.h" diff --git a/count/count.tex b/count/count.tex index c36e7d8..aea7b93 100644 --- a/count/count.tex +++ b/count/count.tex @@ -785,94 +785,45 @@ converge on the true value---hence this approach qualifies as eventually consistent. \begin{listing}[tbp] -{ \scriptsize -\begin{verbbox} - 1 DEFINE_PER_THREAD(unsigned long, counter); - 2 unsigned long global_count; - 3 int stopflag; - 4 - 5 void inc_count(void) - 6 { - 7 WRITE_ONCE(__get_thread_var(counter), - 8 READ_ONCE(__get_thread_var(counter)) + 1); - 9 } -10 -11 unsigned long read_count(void) -12 { -13 return READ_ONCE(global_count); -14 } -15 -16 void *eventual(void *arg) -17 { -18 int t; -19 unsigned long sum; -20 -21 while (READ_ONCE(stopflag) < 3) { -22 sum = 0; -23 for_each_thread(t) -24 sum += READ_ONCE(per_thread(counter, t)); -25 WRITE_ONCE(global_count, sum); -26 poll(NULL, 0, 1); -27 if (READ_ONCE(stopflag)) { -28 smp_mb(); -29 WRITE_ONCE(stopflag, READ_ONCE(stopflag) + 1); -30 } -31 } -32 return NULL; -33 } -34 -35 void count_init(void) -36 { -37 int en; -38 thread_id_t tid; -39 -40 if ((en = pthread_create(&tid, NULL, eventual, NULL)) != 0) { -41 fprintf(stderr, "pthread_create: %s\n", strerror(en)); -42 exit(-1); -43 } -44 } -45 -46 void count_cleanup(void) -47 { -48 WRITE_ONCE(stopflag, 1); -49 while (READ_ONCE(stopflag) < 3) -50 poll(NULL, 0, 1); -51 smp_mb(); -52 } -\end{verbbox} -} -\centering -\theverbbox +\input{CodeSamples/count/count_stat_eventual@whole.fcv} \caption{Array-Based Per-Thread Eventually Consistent Counters} \label{lst:count:Array-Based Per-Thread Eventually Consistent Counters} \end{listing} +\begin{lineref}[ln:count:count_stat_eventual:whole] The implementation is shown in Listing~\ref{lst:count:Array-Based Per-Thread Eventually Consistent Counters} (\path{count_stat_eventual.c}). -Lines~1-2 show the per-thread variable and the global variable that -track the counter's value, and line three shows \co{stopflag} +Lines~\lnref{per_thr_cnt}-\lnref{glb_cnt} +show the per-thread variable and the global variable that +track the counter's value, and line~\lnref{stopflag} shows \co{stopflag} which is used to coordinate termination (for the case where we want to terminate the program with an accurate counter value). -The \co{inc_count()} function shown on lines~5-9 is similar to its +The \co{inc_count()} function shown on +lines~\lnref{inc:b}-\lnref{inc:e} is similar to its counterpart in Listing~\ref{lst:count:Array-Based Per-Thread Statistical Counters}. -The \co{read_count()} function shown on lines~11-14 simply returns the +The \co{read_count()} function shown on +lines~\lnref{read:b}-\lnref{read:e} simply returns the value of the \co{global_count} variable. -However, the \co{count_init()} function on lines~35-44 -creates the \co{eventual()} thread shown on lines~16-33, which +However, the \co{count_init()} function on +lines~\lnref{init:b}-\lnref{init:e} +creates the \co{eventual()} thread shown on +lines~\lnref{eventual:b}-\lnref{eventual:e}, which cycles through all the threads, summing the per-thread local \co{counter} and storing the sum to the \co{global_count} variable. The \co{eventual()} thread waits an arbitrarily chosen one millisecond between passes. -The \co{count_cleanup()} function on lines~46-52 coordinates termination. +The \co{count_cleanup()} function on +lines~\lnref{cleanup:b}-\lnref{cleanup:e} coordinates termination. This approach gives extremely fast counter read-out while still supporting linear counter-update performance. However, this excellent read-side performance and update-side scalability comes at the cost of the additional thread running \co{eventual()}. +\end{lineref} \QuickQuiz{} Why doesn't \co{inc_count()} in -- 2.7.4