Re: [PATCH 2/2] mm: add PageWaiters indicating tasks are waiting for a page bit
From: Nicholas Piggin
Date: Tue Dec 27 2016 - 22:54:44 EST
On Tue, 27 Dec 2016 10:58:59 -0800
Linus Torvalds <torvalds@xxxxxxxxxxxxxxxxxxxx> wrote:
> On Tue, Dec 27, 2016 at 3:19 AM, Nicholas Piggin <npiggin@xxxxxxxxx> wrote:
> > Attached is part of a patch I've been mulling over for a while. I
> > expect you to hate it, and it does not solve this problem for x86,
> > but I like being able to propagate values from atomic ops back
> > to the compiler. Of course, volatile then can't be used either which
> > is another spanner...
> Yeah, that patch is disgusting, and doesn't even help x86.
No, although it would help some cases (but granted the bitops tend to
be problematic in this regard). To be clear I'm not asking to merge it,
just wondered your opinion. (We need something more for unlock_page
anyway because the memory barrier in the way).
> It also
> depends on the compiler doing the right thing in ways that are not
> obviously true.
Can you elaborate on this? GCC will do the optimization (modulo a
> I'd much rather just add the "xyz_return()" primitives for and/or, the
> way we already have atomic_add_return() and friends.
> In fact, we could probably play games with bit numbering, and actually
> use the atomic ops we already have. For example, if the lock bit was
> the top bit, we could unlock by doing "atomic_add_return()" with that
> bit, and look at the remaining bits that way.
> That would actually work really well on x86, since there we have
> "xadd", but we do *not* have "set/clear bit and return old word".
> We could make a special case for just the page lock bit, make it bit #7, and use
> movb $128,%al
> lock xaddb %al,flags
> and then test the bits in %al.
> And all the RISC architectures would be ok with that too, because they
> can just use ll/sc and test the bits with that. So for them, adding a
> "atomic_long_and_return()" would be very natural in the general case.
> The other alternative is to keep the lock bit as bit #0, and just make
> the contention bit be the high bit. Then, on x86, you can do
> lock andb $0xfe,flags
> js contention
> which might be even better. Again, it would be a very special
> operation just for unlock. Something like
> bit_clear_and_branch_if_negative_byte(mem, label);
> and again, it would be trivial to do on most architectures.
> Let me try to write a patch or two for testing.
Patch seems okay, but it's kind of a horrible primitive. What if you
did clear_bit_unlock_and_test_bit, which does a __builtin_constant_p
test on the bit numbers and if they are < 7 and == 7, then do the
Nitpick, can the enum do "= 7" to catch careless bugs? Or BUILD_BUG_ON.
And I'd to do the same for PG_writeback. AFAIKS whatever approach is
used for PG_locked should work just the same, so no problem there.