RFR: 8186838: Generalize Atomic::inc/dec with templates

[Erik Österlund]

Hi Mario,

On 2017-09-01 12:43, Mario Torre wrote:
> On Fri, Sep 1, 2017 at 11:29 AM, Erik Österlund
> <erik.osterlund at oracle.com> wrote:
>> Hi David,
>>
>> On 2017-09-01 02:49, David Holmes wrote:
>>> Hi Erik,
>>>
>>> Sorry but this one is really losing me.
>>>
>>> What is the role of Adjustment ??
>>
>> Adjustment represents the increment/decrement value as an IntegralConstant -
>> your template friend for passing around a constant with both a specified
>> type and value in templates. The type of the increment/decrement is the type
>> of the destination when the destination is an integral type, otherwise if it
>> is a pointer type, the increment/decrement type is ptrdiff_t.
>>
>>> How are inc/dec anything but "using constant" ??
>>
>> I was also a bit torn on that name (I assume you are referring to
>> IncUsingConstant/DecUsingConstant). It was hard to find a name that depicted
>> what this platform helper does. I considered calling the helper something
>> with immediate in the name because it is really used to embed the constant
>> as immediate values in inline assembly today. But then again that seemed too
>> specific, as it is not completely obvious platform specializations will use
>> it in that way. One might just want to specialize this to send it into some
>> compiler Atomic::inc intrinsic for example. Do you have any other preferred
>> names? Here are a few possible names for IncUsingConstant:
>>
>> IncUsingScaledConstant
>> IncUsingAdjustedConstant
>> IncUsingPlatformHelper
>>
>> Any favourites?
>>
>>> Why do we special case jshort??
>>
>> To be consistent with the special case of Atomic::add on jshort. Do you want
>> it removed?
>>
>>> This is indecipherable to normal people ;-)
>>>
>>>   This()->template inc<I, Adjustment>(dest);
>>>
>>> For something as trivial as adding or subtracting 1 the template
>>> machinations here are just mind boggling!
>>
>> This uses the CRTP (Curiously Recurring Template Pattern) C++ idiom. The
>> idea is to devirtualize a virtual call by passing in the derived type as a
>> template parameter to a base class, and then let the base class static_cast
>> to the derived class to devirtualize the call. I hope this explanation sheds
>> some light on what is going on. The same CRTP idiom was used in the
>> Atomic::add implementation in a similar fashion.
>>
>> I will add some comments describing this in the next round after Coleen
>> replies.
>>
> Isn't that a lot more slower than the current inline?

What makes you think so? Everything is inlined all the way to the 
underlying platform layer. Achieving that is the very reason why CRTP is 
used instead of virtual calls.

> BTW, I think I see what those magic constants are (4, 8... rings a
> bell ;), but I think a define here could make things more readable.

Sorry, I am not sure I am following what you mean here.

Thanks,
/Erik

> Cheers,
> Mario