[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Message-ID: <20200727152827.GM23808@casper.infradead.org>
Date: Mon, 27 Jul 2020 16:28:27 +0100
From: Matthew Wilcox <willy@...radead.org>
To: Alan Stern <stern@...land.harvard.edu>
Cc: Eric Biggers <ebiggers@...nel.org>, linux-kernel@...r.kernel.org,
linux-arch@...r.kernel.org,
"Paul E . McKenney" <paulmck@...nel.org>,
linux-fsdevel@...r.kernel.org, Akira Yokosawa <akiyks@...il.com>,
Andrea Parri <parri.andrea@...il.com>,
Boqun Feng <boqun.feng@...il.com>,
Daniel Lustig <dlustig@...dia.com>,
"Darrick J . Wong" <darrick.wong@...cle.com>,
Dave Chinner <david@...morbit.com>,
David Howells <dhowells@...hat.com>,
Jade Alglave <j.alglave@....ac.uk>,
Luc Maranget <luc.maranget@...ia.fr>,
Nicholas Piggin <npiggin@...il.com>,
Peter Zijlstra <peterz@...radead.org>,
Will Deacon <will@...nel.org>
Subject: Re: [PATCH] tools/memory-model: document the "one-time init" pattern
On Mon, Jul 27, 2020 at 11:17:46AM -0400, Alan Stern wrote:
> Given a type "T", an object x of type pointer-to-T, and a function
> "func" that takes various arguments and returns a pointer-to-T, the
> accepted API for calling func once would be to create once_func() as
> follows:
>
> T *once_func(T **ppt, args...)
> {
> static DEFINE_MUTEX(mut);
> T *p;
>
> p = smp_load_acquire(ppt); /* Mild optimization */
> if (p)
> return p;
>
> mutex_lock(mut);
> p = smp_load_acquire(ppt);
> if (!p) {
> p = func(args...);
> if (!IS_ERR_OR_NULL(p))
> smp_store_release(ppt, p);
> }
> mutex_unlock(mut);
> return p;
> }
>
> Users then would have to call once_func(&x, args...) and check the
> result. Different x objects would constitute different "once"
> domains.
[...]
> In fact, the only drawback I can think of is that because this relies
> on a single mutex for all the different possible x's, it might lead to
> locking conflicts (if func had to call once_func() recursively, for
> example). In most reasonable situations such conflicts would not
> arise.
Another drawback for this approach relative to my get_foo() approach
upthread is that, because we don't have compiler support, there's no
enforcement that accesses to 'x' go through once_func(). My approach
wraps accesses in a deliberately-opaque struct so you have to write
some really ugly code to get at the raw value, and it's just easier to
call get_foo().
Powered by blists - more mailing lists