From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-ea0-f177.google.com ([209.85.215.177]:65220 "EHLO mail-ea0-f177.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1759962Ab3GSIk2 (ORCPT ); Fri, 19 Jul 2013 04:40:28 -0400 Date: Fri, 19 Jul 2013 10:40:23 +0200 From: Ingo Molnar Subject: Re: [PATCH RFC 1/2] qrwlock: A queue read/write lock implementation Message-ID: <20130719084023.GB25784@gmail.com> References: <1373679249-27123-1-git-send-email-Waiman.Long@hp.com> <1373679249-27123-2-git-send-email-Waiman.Long@hp.com> <51E49FA3.4030202@hp.com> <20130718074204.GA22623@gmail.com> <51E7F03A.4090305@hp.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <51E7F03A.4090305@hp.com> Sender: linux-arch-owner@vger.kernel.org List-ID: To: Waiman Long Cc: Thomas Gleixner , Ingo Molnar , "H. Peter Anvin" , Arnd Bergmann , linux-arch@vger.kernel.org, x86@kernel.org, linux-kernel@vger.kernel.org, Peter Zijlstra , Steven Rostedt , Andrew Morton , Richard Weinberger , Catalin Marinas , Greg Kroah-Hartman , Matt Fleming , Herbert Xu , Akinobu Mita , Rusty Russell , Michel Lespinasse , Andi Kleen , Rik van Riel , "Paul E. McKenney" , Linus Torvalds , "Chandramouleeswaran, Aswin" , "Norton, Scott J" Message-ID: <20130719084023.URyViXiOPDiM3FT5nmpUqvuifVV1yf0B0wFHP6GmMbI@z> * Waiman Long wrote: > On 07/18/2013 03:42 AM, Ingo Molnar wrote: > >* Waiman Long wrote: > > > >>>>+ * stealing the lock if come at the right moment, the granting of the > >>>>+ * lock is mostly in FIFO order. > >>>>+ * 2. It is faster in high contention situation. > >>>Again, why is it faster? > >>The current rwlock implementation suffers from a thundering herd > >>problem. When many readers are waiting for the lock hold by a writer, > >>they will all jump in more or less at the same time when the writer > >>releases the lock. That is not the case with qrwlock. It has been shown > >>in many cases that avoiding this thundering herd problem can lead to > >>better performance. > >Btw., it's possible to further optimize this "writer releases the lock to > >multiple readers spinning" thundering herd scenario in the classic > >read_lock() case, without changing the queueing model. > > > >Right now read_lock() fast path is a single atomic instruction. When a > >writer releases the lock then it makes it available to all readers and > >each reader will execute a LOCK DEC instruction which will succeed. > > > >This is the relevant code in arch/x86/lib/rwlock.S [edited for > >readability]: > > > >__read_lock_failed(): > > > >0: LOCK_PREFIX > > READ_LOCK_SIZE(inc) (%__lock_ptr) > > > >1: rep; nop > > READ_LOCK_SIZE(cmp) $1, (%__lock_ptr) > > js 1b > > > > LOCK_PREFIX READ_LOCK_SIZE(dec) (%__lock_ptr) > > js 0b > > > > ret > > > >This is where we could optimize: instead of signalling to each reader that > >it's fine to decrease the count and letting dozens of readers do that on > >the same cache-line, which ping-pongs around the numa cross-connect > >touching every other CPU as they execute the LOCK DEC instruction, we > >could let the _writer_ modify the count on unlock in essence, to the exact > >value that readers expect. > > > >Since read_lock() can never abort this should be relatively > >straightforward: the INC above could be left out, and the writer side > >needs to detect that there are no other writers waiting and can set the > >count to 'reader locked' value - which the readers will detect without > >modifying the cache line: > > > >__read_lock_failed(): > > > >0: rep; nop > > READ_LOCK_SIZE(cmp) $1, (%__lock_ptr) > > js 0b > > > > ret > > > >(Unless I'm missing something that is.) > > > >That way the current write_unlock() followed by a 'thundering herd' of > >__read_lock_failed() atomic accesses is transformed into an efficient > >read-only broadcast of information with only a single update to the > >cacheline: the writer-updated cacheline propagates in parallel to every > >CPU and is cached there. > > > >On typical hardware this will be broadcast to all CPUs as part of regular > >MESI invalidation bus traffic. > > > >reader unlock will still have to modify the cacheline, so rwlocks will > >still have a fundamental scalability limit even in the read-only usecase. > > I think that will work. The only drawback that I can see is the fairness > argument. The current read/write lock implementation is unfair to the > writer. That change will make it even more unfair to the writer and > there is no easy way to detect a waiting writer unless we change the > structure to add such a field. As a result, a steady stream of readers > will have a higher chance of blocking out a writer indefinitely. The effect will have to be measured - but I don't think it's particularly hard to tune the fairness balance between readers and writers: the change I suggested would only affect the case when a writer already holding the lock unlocks it. But when a writer already holds the lock it can decide to pass that lock to another writer-spinning instead of unlocking to all readers. This too should be relatively straightforward to implement because neither read_lock() nor write_lock() can abort and race. Instead of doing: static inline void arch_write_unlock(arch_rwlock_t *rw) { asm volatile(LOCK_PREFIX WRITE_LOCK_ADD(%1) "%0" : "+m" (rw->write) : "i" (RW_LOCK_BIAS) : "memory"); } the current owner could check whether there are other writers waiting and could drop into a slowpath that passes ownership to one of the writers via toggling bit 30 or so. This reduces the max number of writers by a factor of 2. But I'd implement this only if it proves to be a problem in practice. I'd strongly suggest to first address the thundering herd problem of write_unlock() and see how it affects scalability - before totally replacing it all with a new, fundamentally heavier locking primitive! Thanks, Ingo