From patchwork Sat May 5 10:48:58 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ingo Molnar X-Patchwork-Id: 10382115 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 553BD60318 for ; Sat, 5 May 2018 10:49:27 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 3CE002945B for ; Sat, 5 May 2018 10:49:27 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 317E429460; Sat, 5 May 2018 10:49:27 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: * X-Spam-Status: No, score=1.1 required=2.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID, FSL_HELO_FAKE, MAILING_LIST_MULTI autolearn=no version=3.3.1 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.wl.linuxfoundation.org (Postfix) with ESMTPS id F3D852945B for ; Sat, 5 May 2018 10:49:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=m9lWDICuQOAVtjoTHRYdRYHQjrLMdLPuWVgehkJbVXQ=; b=bpP1CByjNDApL5 pEGTETJql/T3XalVUDvAB9Ex9LaJqL0vpczJ5+w2VVP9vCyl3zJ7qOVhO+HkDU+vCUh8A25NGycpU h/7und6WQycikz7Oz8d0gbJHH7eXG82KreVEDKuRauqHi90lbmajfDDcrBo9dD7bOob1rHLZ8N2Eg ytH9YgHHZB4mZPYbkZhaZDP5ImMNkTg25fh8JFCLFhfDo8X03o6DtmuWrQu4Hs76isMrYwLpns+Mq s9SvWo0s3/1DFUZDBSDxrNrCz2PID3Em55N1BlLWLj0KkSAWsx1KJOZCNXdgud56OFlhhOm7G/0Y7 WhPD1oFSFZAcKsBGffew==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1fEukf-0007Rn-Fx; Sat, 05 May 2018 10:49:17 +0000 Received: from mail-wm0-x244.google.com ([2a00:1450:400c:c09::244]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1fEukb-0007QR-2t for linux-arm-kernel@lists.infradead.org; Sat, 05 May 2018 10:49:15 +0000 Received: by mail-wm0-x244.google.com with SMTP id j5-v6so8712546wme.5 for ; Sat, 05 May 2018 03:49:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=sender:date:from:to:cc:subject:message-id:references:mime-version :content-disposition:in-reply-to:user-agent; bh=JiEQfI0wwUw2llmgyDXdQ5BghXDayh7ZORRpBitfxeE=; b=lPJluEfUuP+as8TOkUmepWF9qLiPQwBWpvPXQpRBHxwLaQy3sH5hQD/NAZHT5D2zeb MJAcZ9YbHi2GtD3kyyBWEyMCUBV5Z5j82wEVKKG232owph/2ylWubsJIDVy3zC2uPpTA a3GGRJaxQYz7fk6h6/w8YYUVvvlGkgYmbrkiThnx6cS9bDCIoAmOdeKQf15WMGW/ZZ/q zy6IMihbeiTVFSV+Q2uY7kk7FH3kVdkhTo1SV2kfEL8i9KLUtWzpPDRSSq49f0Grewzx DajSQ6CDjb5WTLwAXEVpTOs4TytYPPYH8AsLEo1QFvQWtLm3A8H2DUajt/+qr+RZhJQ1 FaHQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:date:from:to:cc:subject:message-id :references:mime-version:content-disposition:in-reply-to:user-agent; bh=JiEQfI0wwUw2llmgyDXdQ5BghXDayh7ZORRpBitfxeE=; b=EYBxQGJLQmghxhPYomEBTDOyBgty7uTBJ8nrFDVpQ44HjgffAQHEs3l4lahlLzn8QC Q64SDom3M0LmJjnyOoUyI6M1kd1srnAR0FkJVZqWo4CakTX5HBkw4ZnZkN5qLK/lSQQn Kv9iN0BcOPLjk/fdpDA38p+ljoChp5/fpDYTsH7Yl7Lm1wTFBwG7o/vzweyksLdYr9kX EW9/MHIu6z394EJBp6qTmltm8EKyKRJ9U/3ECs+6RZrQQlyXZRQxKxST628i11wyyATz bimQ35+/RQTzF7VkSKoO8z2BV27PX7VQ9T4b+akQbf8dFYlDS6UmdWdzZgIgR/rxb/Ft pjxA== X-Gm-Message-State: ALQs6tDYOOYZIHxI68Wdj+RxgR1EPQCOEO89yHxOmkv/egZLVTEycHG4 mvUT16LA+hOINow/df0k7+U= X-Google-Smtp-Source: AB8JxZpLFOXEe9q85UKWuGCGC7vxdhRZRrfjxK5c/7AvND+reUcAjDiGe38cV+hP9IdvAGPJzuLIiw== X-Received: by 10.28.128.14 with SMTP id b14mr19928460wmd.143.1525517341207; Sat, 05 May 2018 03:49:01 -0700 (PDT) Received: from gmail.com (2E8B0CD5.catv.pool.telekom.hu. [46.139.12.213]) by smtp.gmail.com with ESMTPSA id b105-v6sm22054415wrd.64.2018.05.05.03.49.00 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Sat, 05 May 2018 03:49:00 -0700 (PDT) Date: Sat, 5 May 2018 12:48:58 +0200 From: Ingo Molnar To: Peter Zijlstra Subject: [PATCH] locking/atomics: Shorten the __atomic_op() defines to __op() Message-ID: <20180505104858.ap4bfv6ip2vprzyj@gmail.com> References: <20180504173937.25300-1-mark.rutland@arm.com> <20180504173937.25300-2-mark.rutland@arm.com> <20180504180105.GS12217@hirez.programming.kicks-ass.net> <20180504180909.dnhfflibjwywnm4l@lakrids.cambridge.arm.com> <20180505081100.nsyrqrpzq2vd27bk@gmail.com> <20180505084721.GA32344@noisy.programming.kicks-ass.net> <20180505090903.ebsf5vosgwckxooy@gmail.com> <20180505092911.GC12217@hirez.programming.kicks-ass.net> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20180505092911.GC12217@hirez.programming.kicks-ass.net> User-Agent: NeoMutt/20170609 (1.8.3) X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20180505_034913_135286_069F5E98 X-CRM114-Status: GOOD ( 23.69 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Mark Rutland , catalin.marinas@arm.com, boqun.feng@gmail.com, will.deacon@arm.com, linux-kernel@vger.kernel.org, dvyukov@google.com, aryabinin@virtuozzo.com, linux-arm-kernel@lists.infradead.org Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org X-Virus-Scanned: ClamAV using ClamSMTP * Peter Zijlstra wrote: > On Sat, May 05, 2018 at 11:09:03AM +0200, Ingo Molnar wrote: > > > > # ifndef atomic_fetch_dec_acquire > > > > # define atomic_fetch_dec_acquire(...) __atomic_op_acquire(atomic_fetch_dec, __VA_ARGS__) > > > > # endif > > > > # ifndef atomic_fetch_dec_release > > > > # define atomic_fetch_dec_release(...) __atomic_op_release(atomic_fetch_dec, __VA_ARGS__) > > > > # endif > > > > # ifndef atomic_fetch_dec > > > > # define atomic_fetch_dec(...) __atomic_op_fence(atomic_fetch_dec, __VA_ARGS__) > > > > # endif > > > > #endif > > > > > > > > The new variant is readable at a glance, and the hierarchy of defines is very > > > > obvious as well. > > > > > > It wraps and looks hideous in my normal setup. And I do detest that indent > > > after # thing. > > > > You should use wider terminals if you take a look at such code - there's already > > numerous areas of the kernel that are not readable on 80x25 terminals. > > > > _Please_ try the following experiment, for me: > > > > Enter the 21st century temporarily and widen two of your terminals from 80 cols to > > 100 cols - it's only ~20% wider. > > Doesn't work that way. The only way I get more columns is if I shrink my > font further. I work with tiles per monitor (left/right obv.) and use > two columns per editor. This gets me a total of 4 columns. > > On my desktop that is slightly over 100 characters per column, on my > laptop that is slightly below 100 -- mostly because I'm pixel limited on > fontsize on that thing (FullHD sucks). > > If it wraps it wraps. Out of the 707 lines in atomic.h only 25 are wider than 100 chars - and the max length is 104 chars. If that's too then there's a few more things we could do - for example the attached patch renames a (very minor) misnomer to a shorter name and thus saves on the longest lines, the column histogram now looks like this: 79 4 80 7 81 3 82 9 84 4 85 2 86 3 87 1 88 4 89 13 90 7 91 20 92 18 93 12 94 11 96 5 I.e. the longest line is down to 96 columns, and 99% of the file is 94 cols or shorter. Is this still too long? Thanks, Ingo ============================> From: Ingo Molnar Date: Sat, 5 May 2018 12:41:57 +0200 Subject: [PATCH] locking/atomics: Shorten the __atomic_op() defines to __op() The __atomic prefix is somewhat of a misnomer, because not all APIs we use with these macros have an atomic_ prefix. This also reduces the length of the longest lines in the header, making them more readable on PeterZ's terminals. Cc: Andrew Morton Cc: Linus Torvalds Cc: Mark Rutland Cc: Paul E. McKenney Cc: Paul E. McKenney Cc: Peter Zijlstra Cc: Peter Zijlstra Cc: Thomas Gleixner Cc: Will Deacon Cc: aryabinin@virtuozzo.com Cc: boqun.feng@gmail.com Cc: catalin.marinas@arm.com Cc: dvyukov@google.com Cc: linux-arm-kernel@lists.infradead.org Signed-off-by: Ingo Molnar --- include/linux/atomic.h | 204 +++++++++++++++++++++++++------------------------ 1 file changed, 103 insertions(+), 101 deletions(-) diff --git a/include/linux/atomic.h b/include/linux/atomic.h index 1176cf7c6f03..f32ff6d9e4d2 100644 --- a/include/linux/atomic.h +++ b/include/linux/atomic.h @@ -37,33 +37,35 @@ * variant is already fully ordered, no additional barriers are needed. * * Besides, if an arch has a special barrier for acquire/release, it could - * implement its own __atomic_op_* and use the same framework for building + * implement its own __op_* and use the same framework for building * variants * - * If an architecture overrides __atomic_op_acquire() it will probably want + * If an architecture overrides __op_acquire() it will probably want * to define smp_mb__after_spinlock(). */ -#ifndef __atomic_op_acquire -#define __atomic_op_acquire(op, args...) \ +#ifndef __op_acquire +#define __op_acquire(op, args...) \ ({ \ typeof(op##_relaxed(args)) __ret = op##_relaxed(args); \ + \ smp_mb__after_atomic(); \ __ret; \ }) #endif -#ifndef __atomic_op_release -#define __atomic_op_release(op, args...) \ +#ifndef __op_release +#define __op_release(op, args...) \ ({ \ smp_mb__before_atomic(); \ op##_relaxed(args); \ }) #endif -#ifndef __atomic_op_fence -#define __atomic_op_fence(op, args...) \ +#ifndef __op_fence +#define __op_fence(op, args...) \ ({ \ typeof(op##_relaxed(args)) __ret; \ + \ smp_mb__before_atomic(); \ __ret = op##_relaxed(args); \ smp_mb__after_atomic(); \ @@ -77,9 +79,9 @@ # define atomic_add_return_release atomic_add_return #else # ifndef atomic_add_return -# define atomic_add_return(...) __atomic_op_fence(atomic_add_return, __VA_ARGS__) -# define atomic_add_return_acquire(...) __atomic_op_acquire(atomic_add_return, __VA_ARGS__) -# define atomic_add_return_release(...) __atomic_op_release(atomic_add_return, __VA_ARGS__) +# define atomic_add_return(...) __op_fence(atomic_add_return, __VA_ARGS__) +# define atomic_add_return_acquire(...) __op_acquire(atomic_add_return, __VA_ARGS__) +# define atomic_add_return_release(...) __op_release(atomic_add_return, __VA_ARGS__) # endif #endif @@ -89,9 +91,9 @@ # define atomic_inc_return_release atomic_inc_return #else # ifndef atomic_inc_return -# define atomic_inc_return(...) __atomic_op_fence(atomic_inc_return, __VA_ARGS__) -# define atomic_inc_return_acquire(...) __atomic_op_acquire(atomic_inc_return, __VA_ARGS__) -# define atomic_inc_return_release(...) __atomic_op_release(atomic_inc_return, __VA_ARGS__) +# define atomic_inc_return(...) __op_fence(atomic_inc_return, __VA_ARGS__) +# define atomic_inc_return_acquire(...) __op_acquire(atomic_inc_return, __VA_ARGS__) +# define atomic_inc_return_release(...) __op_release(atomic_inc_return, __VA_ARGS__) # endif #endif @@ -101,9 +103,9 @@ # define atomic_sub_return_release atomic_sub_return #else # ifndef atomic_sub_return -# define atomic_sub_return(...) __atomic_op_fence(atomic_sub_return, __VA_ARGS__) -# define atomic_sub_return_acquire(...) __atomic_op_acquire(atomic_sub_return, __VA_ARGS__) -# define atomic_sub_return_release(...) __atomic_op_release(atomic_sub_return, __VA_ARGS__) +# define atomic_sub_return(...) __op_fence(atomic_sub_return, __VA_ARGS__) +# define atomic_sub_return_acquire(...) __op_acquire(atomic_sub_return, __VA_ARGS__) +# define atomic_sub_return_release(...) __op_release(atomic_sub_return, __VA_ARGS__) # endif #endif @@ -113,9 +115,9 @@ # define atomic_dec_return_release atomic_dec_return #else # ifndef atomic_dec_return -# define atomic_dec_return(...) __atomic_op_fence(atomic_dec_return, __VA_ARGS__) -# define atomic_dec_return_acquire(...) __atomic_op_acquire(atomic_dec_return, __VA_ARGS__) -# define atomic_dec_return_release(...) __atomic_op_release(atomic_dec_return, __VA_ARGS__) +# define atomic_dec_return(...) __op_fence(atomic_dec_return, __VA_ARGS__) +# define atomic_dec_return_acquire(...) __op_acquire(atomic_dec_return, __VA_ARGS__) +# define atomic_dec_return_release(...) __op_release(atomic_dec_return, __VA_ARGS__) # endif #endif @@ -125,9 +127,9 @@ # define atomic_fetch_add_release atomic_fetch_add #else # ifndef atomic_fetch_add -# define atomic_fetch_add(...) __atomic_op_fence(atomic_fetch_add, __VA_ARGS__) -# define atomic_fetch_add_acquire(...) __atomic_op_acquire(atomic_fetch_add, __VA_ARGS__) -# define atomic_fetch_add_release(...) __atomic_op_release(atomic_fetch_add, __VA_ARGS__) +# define atomic_fetch_add(...) __op_fence(atomic_fetch_add, __VA_ARGS__) +# define atomic_fetch_add_acquire(...) __op_acquire(atomic_fetch_add, __VA_ARGS__) +# define atomic_fetch_add_release(...) __op_release(atomic_fetch_add, __VA_ARGS__) # endif #endif @@ -144,9 +146,9 @@ # endif #else # ifndef atomic_fetch_inc -# define atomic_fetch_inc(...) __atomic_op_fence(atomic_fetch_inc, __VA_ARGS__) -# define atomic_fetch_inc_acquire(...) __atomic_op_acquire(atomic_fetch_inc, __VA_ARGS__) -# define atomic_fetch_inc_release(...) __atomic_op_release(atomic_fetch_inc, __VA_ARGS__) +# define atomic_fetch_inc(...) __op_fence(atomic_fetch_inc, __VA_ARGS__) +# define atomic_fetch_inc_acquire(...) __op_acquire(atomic_fetch_inc, __VA_ARGS__) +# define atomic_fetch_inc_release(...) __op_release(atomic_fetch_inc, __VA_ARGS__) # endif #endif @@ -156,9 +158,9 @@ # define atomic_fetch_sub_release atomic_fetch_sub #else # ifndef atomic_fetch_sub -# define atomic_fetch_sub(...) __atomic_op_fence(atomic_fetch_sub, __VA_ARGS__) -# define atomic_fetch_sub_acquire(...) __atomic_op_acquire(atomic_fetch_sub, __VA_ARGS__) -# define atomic_fetch_sub_release(...) __atomic_op_release(atomic_fetch_sub, __VA_ARGS__) +# define atomic_fetch_sub(...) __op_fence(atomic_fetch_sub, __VA_ARGS__) +# define atomic_fetch_sub_acquire(...) __op_acquire(atomic_fetch_sub, __VA_ARGS__) +# define atomic_fetch_sub_release(...) __op_release(atomic_fetch_sub, __VA_ARGS__) # endif #endif @@ -175,9 +177,9 @@ # endif #else # ifndef atomic_fetch_dec -# define atomic_fetch_dec(...) __atomic_op_fence(atomic_fetch_dec, __VA_ARGS__) -# define atomic_fetch_dec_acquire(...) __atomic_op_acquire(atomic_fetch_dec, __VA_ARGS__) -# define atomic_fetch_dec_release(...) __atomic_op_release(atomic_fetch_dec, __VA_ARGS__) +# define atomic_fetch_dec(...) __op_fence(atomic_fetch_dec, __VA_ARGS__) +# define atomic_fetch_dec_acquire(...) __op_acquire(atomic_fetch_dec, __VA_ARGS__) +# define atomic_fetch_dec_release(...) __op_release(atomic_fetch_dec, __VA_ARGS__) # endif #endif @@ -187,9 +189,9 @@ # define atomic_fetch_or_release atomic_fetch_or #else # ifndef atomic_fetch_or -# define atomic_fetch_or(...) __atomic_op_fence(atomic_fetch_or, __VA_ARGS__) -# define atomic_fetch_or_acquire(...) __atomic_op_acquire(atomic_fetch_or, __VA_ARGS__) -# define atomic_fetch_or_release(...) __atomic_op_release(atomic_fetch_or, __VA_ARGS__) +# define atomic_fetch_or(...) __op_fence(atomic_fetch_or, __VA_ARGS__) +# define atomic_fetch_or_acquire(...) __op_acquire(atomic_fetch_or, __VA_ARGS__) +# define atomic_fetch_or_release(...) __op_release(atomic_fetch_or, __VA_ARGS__) # endif #endif @@ -199,9 +201,9 @@ # define atomic_fetch_and_release atomic_fetch_and #else # ifndef atomic_fetch_and -# define atomic_fetch_and(...) __atomic_op_fence(atomic_fetch_and, __VA_ARGS__) -# define atomic_fetch_and_acquire(...) __atomic_op_acquire(atomic_fetch_and, __VA_ARGS__) -# define atomic_fetch_and_release(...) __atomic_op_release(atomic_fetch_and, __VA_ARGS__) +# define atomic_fetch_and(...) __op_fence(atomic_fetch_and, __VA_ARGS__) +# define atomic_fetch_and_acquire(...) __op_acquire(atomic_fetch_and, __VA_ARGS__) +# define atomic_fetch_and_release(...) __op_release(atomic_fetch_and, __VA_ARGS__) # endif #endif @@ -211,9 +213,9 @@ # define atomic_fetch_xor_release atomic_fetch_xor #else # ifndef atomic_fetch_xor -# define atomic_fetch_xor(...) __atomic_op_fence(atomic_fetch_xor, __VA_ARGS__) -# define atomic_fetch_xor_acquire(...) __atomic_op_acquire(atomic_fetch_xor, __VA_ARGS__) -# define atomic_fetch_xor_release(...) __atomic_op_release(atomic_fetch_xor, __VA_ARGS__) +# define atomic_fetch_xor(...) __op_fence(atomic_fetch_xor, __VA_ARGS__) +# define atomic_fetch_xor_acquire(...) __op_acquire(atomic_fetch_xor, __VA_ARGS__) +# define atomic_fetch_xor_release(...) __op_release(atomic_fetch_xor, __VA_ARGS__) # endif #endif @@ -223,9 +225,9 @@ #define atomic_xchg_release atomic_xchg #else # ifndef atomic_xchg -# define atomic_xchg(...) __atomic_op_fence(atomic_xchg, __VA_ARGS__) -# define atomic_xchg_acquire(...) __atomic_op_acquire(atomic_xchg, __VA_ARGS__) -# define atomic_xchg_release(...) __atomic_op_release(atomic_xchg, __VA_ARGS__) +# define atomic_xchg(...) __op_fence(atomic_xchg, __VA_ARGS__) +# define atomic_xchg_acquire(...) __op_acquire(atomic_xchg, __VA_ARGS__) +# define atomic_xchg_release(...) __op_release(atomic_xchg, __VA_ARGS__) # endif #endif @@ -235,9 +237,9 @@ # define atomic_cmpxchg_release atomic_cmpxchg #else # ifndef atomic_cmpxchg -# define atomic_cmpxchg(...) __atomic_op_fence(atomic_cmpxchg, __VA_ARGS__) -# define atomic_cmpxchg_acquire(...) __atomic_op_acquire(atomic_cmpxchg, __VA_ARGS__) -# define atomic_cmpxchg_release(...) __atomic_op_release(atomic_cmpxchg, __VA_ARGS__) +# define atomic_cmpxchg(...) __op_fence(atomic_cmpxchg, __VA_ARGS__) +# define atomic_cmpxchg_acquire(...) __op_acquire(atomic_cmpxchg, __VA_ARGS__) +# define atomic_cmpxchg_release(...) __op_release(atomic_cmpxchg, __VA_ARGS__) # endif #endif @@ -267,9 +269,9 @@ # define cmpxchg_release cmpxchg #else # ifndef cmpxchg -# define cmpxchg(...) __atomic_op_fence(cmpxchg, __VA_ARGS__) -# define cmpxchg_acquire(...) __atomic_op_acquire(cmpxchg, __VA_ARGS__) -# define cmpxchg_release(...) __atomic_op_release(cmpxchg, __VA_ARGS__) +# define cmpxchg(...) __op_fence(cmpxchg, __VA_ARGS__) +# define cmpxchg_acquire(...) __op_acquire(cmpxchg, __VA_ARGS__) +# define cmpxchg_release(...) __op_release(cmpxchg, __VA_ARGS__) # endif #endif @@ -279,9 +281,9 @@ # define cmpxchg64_release cmpxchg64 #else # ifndef cmpxchg64 -# define cmpxchg64(...) __atomic_op_fence(cmpxchg64, __VA_ARGS__) -# define cmpxchg64_acquire(...) __atomic_op_acquire(cmpxchg64, __VA_ARGS__) -# define cmpxchg64_release(...) __atomic_op_release(cmpxchg64, __VA_ARGS__) +# define cmpxchg64(...) __op_fence(cmpxchg64, __VA_ARGS__) +# define cmpxchg64_acquire(...) __op_acquire(cmpxchg64, __VA_ARGS__) +# define cmpxchg64_release(...) __op_release(cmpxchg64, __VA_ARGS__) # endif #endif @@ -291,9 +293,9 @@ # define xchg_release xchg #else # ifndef xchg -# define xchg(...) __atomic_op_fence(xchg, __VA_ARGS__) -# define xchg_acquire(...) __atomic_op_acquire(xchg, __VA_ARGS__) -# define xchg_release(...) __atomic_op_release(xchg, __VA_ARGS__) +# define xchg(...) __op_fence(xchg, __VA_ARGS__) +# define xchg_acquire(...) __op_acquire(xchg, __VA_ARGS__) +# define xchg_release(...) __op_release(xchg, __VA_ARGS__) # endif #endif @@ -330,9 +332,9 @@ static inline int atomic_add_unless(atomic_t *v, int a, int u) # define atomic_fetch_andnot_release atomic_fetch_andnot #else # ifndef atomic_fetch_andnot -# define atomic_fetch_andnot(...) __atomic_op_fence(atomic_fetch_andnot, __VA_ARGS__) -# define atomic_fetch_andnot_acquire(...) __atomic_op_acquire(atomic_fetch_andnot, __VA_ARGS__) -# define atomic_fetch_andnot_release(...) __atomic_op_release(atomic_fetch_andnot, __VA_ARGS__) +# define atomic_fetch_andnot(...) __op_fence(atomic_fetch_andnot, __VA_ARGS__) +# define atomic_fetch_andnot_acquire(...) __op_acquire(atomic_fetch_andnot, __VA_ARGS__) +# define atomic_fetch_andnot_release(...) __op_release(atomic_fetch_andnot, __VA_ARGS__) # endif #endif @@ -472,9 +474,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # define atomic64_add_return_release atomic64_add_return #else # ifndef atomic64_add_return -# define atomic64_add_return(...) __atomic_op_fence(atomic64_add_return, __VA_ARGS__) -# define atomic64_add_return_acquire(...) __atomic_op_acquire(atomic64_add_return, __VA_ARGS__) -# define atomic64_add_return_release(...) __atomic_op_release(atomic64_add_return, __VA_ARGS__) +# define atomic64_add_return(...) __op_fence(atomic64_add_return, __VA_ARGS__) +# define atomic64_add_return_acquire(...) __op_acquire(atomic64_add_return, __VA_ARGS__) +# define atomic64_add_return_release(...) __op_release(atomic64_add_return, __VA_ARGS__) # endif #endif @@ -484,9 +486,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # define atomic64_inc_return_release atomic64_inc_return #else # ifndef atomic64_inc_return -# define atomic64_inc_return(...) __atomic_op_fence(atomic64_inc_return, __VA_ARGS__) -# define atomic64_inc_return_acquire(...) __atomic_op_acquire(atomic64_inc_return, __VA_ARGS__) -# define atomic64_inc_return_release(...) __atomic_op_release(atomic64_inc_return, __VA_ARGS__) +# define atomic64_inc_return(...) __op_fence(atomic64_inc_return, __VA_ARGS__) +# define atomic64_inc_return_acquire(...) __op_acquire(atomic64_inc_return, __VA_ARGS__) +# define atomic64_inc_return_release(...) __op_release(atomic64_inc_return, __VA_ARGS__) # endif #endif @@ -496,9 +498,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # define atomic64_sub_return_release atomic64_sub_return #else # ifndef atomic64_sub_return -# define atomic64_sub_return(...) __atomic_op_fence(atomic64_sub_return, __VA_ARGS__) -# define atomic64_sub_return_acquire(...) __atomic_op_acquire(atomic64_sub_return, __VA_ARGS__) -# define atomic64_sub_return_release(...) __atomic_op_release(atomic64_sub_return, __VA_ARGS__) +# define atomic64_sub_return(...) __op_fence(atomic64_sub_return, __VA_ARGS__) +# define atomic64_sub_return_acquire(...) __op_acquire(atomic64_sub_return, __VA_ARGS__) +# define atomic64_sub_return_release(...) __op_release(atomic64_sub_return, __VA_ARGS__) # endif #endif @@ -508,9 +510,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # define atomic64_dec_return_release atomic64_dec_return #else # ifndef atomic64_dec_return -# define atomic64_dec_return(...) __atomic_op_fence(atomic64_dec_return, __VA_ARGS__) -# define atomic64_dec_return_acquire(...) __atomic_op_acquire(atomic64_dec_return, __VA_ARGS__) -# define atomic64_dec_return_release(...) __atomic_op_release(atomic64_dec_return, __VA_ARGS__) +# define atomic64_dec_return(...) __op_fence(atomic64_dec_return, __VA_ARGS__) +# define atomic64_dec_return_acquire(...) __op_acquire(atomic64_dec_return, __VA_ARGS__) +# define atomic64_dec_return_release(...) __op_release(atomic64_dec_return, __VA_ARGS__) # endif #endif @@ -520,9 +522,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # define atomic64_fetch_add_release atomic64_fetch_add #else # ifndef atomic64_fetch_add -# define atomic64_fetch_add(...) __atomic_op_fence(atomic64_fetch_add, __VA_ARGS__) -# define atomic64_fetch_add_acquire(...) __atomic_op_acquire(atomic64_fetch_add, __VA_ARGS__) -# define atomic64_fetch_add_release(...) __atomic_op_release(atomic64_fetch_add, __VA_ARGS__) +# define atomic64_fetch_add(...) __op_fence(atomic64_fetch_add, __VA_ARGS__) +# define atomic64_fetch_add_acquire(...) __op_acquire(atomic64_fetch_add, __VA_ARGS__) +# define atomic64_fetch_add_release(...) __op_release(atomic64_fetch_add, __VA_ARGS__) # endif #endif @@ -539,9 +541,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # endif #else # ifndef atomic64_fetch_inc -# define atomic64_fetch_inc(...) __atomic_op_fence(atomic64_fetch_inc, __VA_ARGS__) -# define atomic64_fetch_inc_acquire(...) __atomic_op_acquire(atomic64_fetch_inc, __VA_ARGS__) -# define atomic64_fetch_inc_release(...) __atomic_op_release(atomic64_fetch_inc, __VA_ARGS__) +# define atomic64_fetch_inc(...) __op_fence(atomic64_fetch_inc, __VA_ARGS__) +# define atomic64_fetch_inc_acquire(...) __op_acquire(atomic64_fetch_inc, __VA_ARGS__) +# define atomic64_fetch_inc_release(...) __op_release(atomic64_fetch_inc, __VA_ARGS__) # endif #endif @@ -551,9 +553,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # define atomic64_fetch_sub_release atomic64_fetch_sub #else # ifndef atomic64_fetch_sub -# define atomic64_fetch_sub(...) __atomic_op_fence(atomic64_fetch_sub, __VA_ARGS__) -# define atomic64_fetch_sub_acquire(...) __atomic_op_acquire(atomic64_fetch_sub, __VA_ARGS__) -# define atomic64_fetch_sub_release(...) __atomic_op_release(atomic64_fetch_sub, __VA_ARGS__) +# define atomic64_fetch_sub(...) __op_fence(atomic64_fetch_sub, __VA_ARGS__) +# define atomic64_fetch_sub_acquire(...) __op_acquire(atomic64_fetch_sub, __VA_ARGS__) +# define atomic64_fetch_sub_release(...) __op_release(atomic64_fetch_sub, __VA_ARGS__) # endif #endif @@ -570,9 +572,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # endif #else # ifndef atomic64_fetch_dec -# define atomic64_fetch_dec(...) __atomic_op_fence(atomic64_fetch_dec, __VA_ARGS__) -# define atomic64_fetch_dec_acquire(...) __atomic_op_acquire(atomic64_fetch_dec, __VA_ARGS__) -# define atomic64_fetch_dec_release(...) __atomic_op_release(atomic64_fetch_dec, __VA_ARGS__) +# define atomic64_fetch_dec(...) __op_fence(atomic64_fetch_dec, __VA_ARGS__) +# define atomic64_fetch_dec_acquire(...) __op_acquire(atomic64_fetch_dec, __VA_ARGS__) +# define atomic64_fetch_dec_release(...) __op_release(atomic64_fetch_dec, __VA_ARGS__) # endif #endif @@ -582,9 +584,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # define atomic64_fetch_or_release atomic64_fetch_or #else # ifndef atomic64_fetch_or -# define atomic64_fetch_or(...) __atomic_op_fence(atomic64_fetch_or, __VA_ARGS__) -# define atomic64_fetch_or_acquire(...) __atomic_op_acquire(atomic64_fetch_or, __VA_ARGS__) -# define atomic64_fetch_or_release(...) __atomic_op_release(atomic64_fetch_or, __VA_ARGS__) +# define atomic64_fetch_or(...) __op_fence(atomic64_fetch_or, __VA_ARGS__) +# define atomic64_fetch_or_acquire(...) __op_acquire(atomic64_fetch_or, __VA_ARGS__) +# define atomic64_fetch_or_release(...) __op_release(atomic64_fetch_or, __VA_ARGS__) # endif #endif @@ -594,9 +596,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # define atomic64_fetch_and_release atomic64_fetch_and #else # ifndef atomic64_fetch_and -# define atomic64_fetch_and(...) __atomic_op_fence(atomic64_fetch_and, __VA_ARGS__) -# define atomic64_fetch_and_acquire(...) __atomic_op_acquire(atomic64_fetch_and, __VA_ARGS__) -# define atomic64_fetch_and_release(...) __atomic_op_release(atomic64_fetch_and, __VA_ARGS__) +# define atomic64_fetch_and(...) __op_fence(atomic64_fetch_and, __VA_ARGS__) +# define atomic64_fetch_and_acquire(...) __op_acquire(atomic64_fetch_and, __VA_ARGS__) +# define atomic64_fetch_and_release(...) __op_release(atomic64_fetch_and, __VA_ARGS__) # endif #endif @@ -606,9 +608,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # define atomic64_fetch_xor_release atomic64_fetch_xor #else # ifndef atomic64_fetch_xor -# define atomic64_fetch_xor(...) __atomic_op_fence(atomic64_fetch_xor, __VA_ARGS__) -# define atomic64_fetch_xor_acquire(...) __atomic_op_acquire(atomic64_fetch_xor, __VA_ARGS__) -# define atomic64_fetch_xor_release(...) __atomic_op_release(atomic64_fetch_xor, __VA_ARGS__) +# define atomic64_fetch_xor(...) __op_fence(atomic64_fetch_xor, __VA_ARGS__) +# define atomic64_fetch_xor_acquire(...) __op_acquire(atomic64_fetch_xor, __VA_ARGS__) +# define atomic64_fetch_xor_release(...) __op_release(atomic64_fetch_xor, __VA_ARGS__) # endif #endif @@ -618,9 +620,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # define atomic64_xchg_release atomic64_xchg #else # ifndef atomic64_xchg -# define atomic64_xchg(...) __atomic_op_fence(atomic64_xchg, __VA_ARGS__) -# define atomic64_xchg_acquire(...) __atomic_op_acquire(atomic64_xchg, __VA_ARGS__) -# define atomic64_xchg_release(...) __atomic_op_release(atomic64_xchg, __VA_ARGS__) +# define atomic64_xchg(...) __op_fence(atomic64_xchg, __VA_ARGS__) +# define atomic64_xchg_acquire(...) __op_acquire(atomic64_xchg, __VA_ARGS__) +# define atomic64_xchg_release(...) __op_release(atomic64_xchg, __VA_ARGS__) # endif #endif @@ -630,9 +632,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # define atomic64_cmpxchg_release atomic64_cmpxchg #else # ifndef atomic64_cmpxchg -# define atomic64_cmpxchg(...) __atomic_op_fence(atomic64_cmpxchg, __VA_ARGS__) -# define atomic64_cmpxchg_acquire(...) __atomic_op_acquire(atomic64_cmpxchg, __VA_ARGS__) -# define atomic64_cmpxchg_release(...) __atomic_op_release(atomic64_cmpxchg, __VA_ARGS__) +# define atomic64_cmpxchg(...) __op_fence(atomic64_cmpxchg, __VA_ARGS__) +# define atomic64_cmpxchg_acquire(...) __op_acquire(atomic64_cmpxchg, __VA_ARGS__) +# define atomic64_cmpxchg_release(...) __op_release(atomic64_cmpxchg, __VA_ARGS__) # endif #endif @@ -664,9 +666,9 @@ static inline int atomic_dec_if_positive(atomic_t *v) # define atomic64_fetch_andnot_release atomic64_fetch_andnot #else # ifndef atomic64_fetch_andnot -# define atomic64_fetch_andnot(...) __atomic_op_fence(atomic64_fetch_andnot, __VA_ARGS__) -# define atomic64_fetch_andnot_acquire(...) __atomic_op_acquire(atomic64_fetch_andnot, __VA_ARGS__) -# define atomic64_fetch_andnot_release(...) __atomic_op_release(atomic64_fetch_andnot, __VA_ARGS__) +# define atomic64_fetch_andnot(...) __op_fence(atomic64_fetch_andnot, __VA_ARGS__) +# define atomic64_fetch_andnot_acquire(...) __op_acquire(atomic64_fetch_andnot, __VA_ARGS__) +# define atomic64_fetch_andnot_release(...) __op_release(atomic64_fetch_andnot, __VA_ARGS__) # endif #endif