RFR (S) CR 8014966: Add the proper Javadoc to @Contended

Mike Duigou mike.duigou at oracle.com
Thu May 30 23:04:39 UTC 2013

Hi Aleksey;

Прогресс! (One of the few Russian words I know thanks to the ISS)

Since the statements are grouped by fields and classes, move this to the classes paragraph:

"A contention
+ * group tag has no meaning in a class level {@code @Contended} annotation,
+ * and is ignored."

Describing the behaviour of the class annotation by referencing unavailable functionality seems strange:

"the effect is
+ * roughly equivalent to placing the {@code @Contended} annotation
+ * with the <i>same</i> anonymous tag over all the unannotated fields of
+ * the object."

The reader is left wondering "how would I annotate multiple fields with the same anonymous tag?" Perhaps a statement in the fields paragraph that "To put multiple fields into the same anonymous group use the class level @C annotation".

"over all the unannotated fields of
+ * the object."

This refers, of course, to fields without their own @C annotation not fields without annotations.


<p>The class level {@code @Contended} annotation is not inherited and has
+ * no effect on the fields [defined] in any sub-classes. 


"The effects of all
+ * {@code @Contended} annotations [upon layout of object fields] remain in force for all"

As I told Brian during the lambda javadoc efforts, writing specification is the best kind of task--demanding, exacting and tedious! :-)


On May 29 2013, at 04:20 , Aleksey Shipilev wrote:

> Thanks for the review!
> On 05/29/2013 04:28 AM, Martin Buchholz wrote:
>> Yeah, we have the same problem with javadoc issuing very verbose
>> warnings.  I've been ignoring/filtering them and hoping they get fixed
>> before jdk8 ships.
> Ok, reverted back to <p>.
>>> + * in concurrent contexts in which each instance of the annotated
>>> + * object is often accessed by a different thread.</p>
>>> Hmmm...  makes it sound like it applies even if each instance is
>>> thread-confined (in a different thread) or is immutable.
>>    I think all the magic of ignoring @C when VM can prove the
>>    instance/fields would not experience contention, should be omitted from
>>    the documentation. The practical considerations also apply: since we can
>>    not at the moment retransform the class after the publication, it seems
>>    a good idea to treat all instances as potentially shared. This eases the
>>    reasoning (and documentation) significantly.
>>> "objects" are not annotated.
>>    Yes, should be "instances".
>> I was thinking "classes, not objects, are annotated".
> Fixed.
>>> however, remain in force for all
>>> + * superclass and subclass instances
>>> "remain in force for superclass instances" doesn't make sense to me.  Do
>>> you mean "remain in force when fields are inherited in subclasses"
>> Yes, that sounds better!
> Reverted back to David's version. It does sound even cleaner in that
> version.
>>> Maybe "instances of the annotated class are frequently accessed by
>>> multiple threads and have fields that are frequently written".
>>    "Accessed" matters there. False sharing also happens on reads. Also, the
>>    innocent read-only classes sometimes also need the protection from the
>>    adjacent writers' racket :)
>> Hmmm... tricky ... This also then applies to pure immutable popular
>> objects like Boolean.TRUE. But you want those kinds of objects to all be
>> colocated and tightly packed with other such objects, not give each of
>> them their own cache line.
> Yes, that's true. I do, however, think we have to have the provisioning
> for the read-only protected fields/instances.
>> Sounds like a Quality of Implementation issue.  In general, I think you
>> *DO* want the subclass fields to be potentially in the same location as
>> the superclass padding fields.
>> A >: B
>> A layout: ppppaaaapppp
>> B layout: ppppaaaabbbbpppp
>> which is not asking too much of a jit.
>> I believe it is already common for VMs to allocate subclass fields in
>> natural padding space of superclasses.
> This gets very tricky even in a slightly complicated case:
>  A >: B
>  A layout: ppppAAppppCCpppp
>  B layout: ppppAABBppCCpppp
> Note that we can't move CC in B because the fields are bound statically;
> so we end up ruining the padding for both BB and CC. We can, of course,
> have the gap in the padding to tolerate this, but before knowing in
> advance what subclasses will be loaded next, we can not prepare enough;
> or, we can redefine all the classes up the hierarchy... (Current HotSpot
> classloader code is completely not ready for things like these).
> However, implementation issues aside:
> Allowing contended tags to be inherited will force users to look at the
> entire hierarchy to search for the colliding tags; or (what's worse)
> push the superclass maintainers to use cryptic tags so no possible
> subclasses can collide with the protected fields. IMO, that is way
> messier than pushing users to aggregate the semantically-close fields in
> the same class. Hence, I left the inheritance clause as is.
> The new webrev is here:
>  http://cr.openjdk.java.net/~shade/8014966/webrev.03/
> Thanks everyone, writing specs is fun!
> -Aleksey.

More information about the core-libs-dev mailing list