CRR (XS): 7098085: G1: partially-young GCs not initiated under certain circumstances

Tony Printezis tony.printezis at oracle.com
Fri Oct 7 04:46:42 PDT 2011


Ramki,

Thanks again for the feedback. So two votes for Regulate / Ignore so 
far. :-)

Tony

On 10/6/2011 7:15 PM, Y. S. Ramakrishna wrote:
>
>
> On 10/06/11 11:23, Tony Printezis wrote:
>> Hi again,
>>
>> Disclaimer: John and I IMed behind your backs. :-)
>>
>> Y. S. Ramakrishna wrote:
>>> I think the "notice" / "ignore" here would be slightly different
>>> and use of the similar terminology may possibly cause some confusion.
>>> AllowSafepoints / DisallowSafepoints would perhaps be closer to what 
>>> one is
>>> doing in this specific case.
>>
>> Well, if I can be a bit picky too :-), DisallowSafepoints is not 
>> totally true either given that the thread can allow safepoints to 
>> happen but it has to do so explicitly with a yield call.
>
> True, as I indicated further below.
>
>>
>> How about (and it'd be obvious that I resorted in consulting a 
>> thesaurus):
>>
>> RegulateSafepoints and IgnoreSafepoints
>>
>> Both are descriptive in what the thread will do.
>
> Sounds good to me.
>
>>
>>> If AllowSafepoints / DisallowSafepoints is not favoured, perhaps
>>> something like SafepointLocker/Unlocker terminology in analogy to 
>>> MutexLocker/Unlocker
>>> might be acceptable to people here because admission to the set
>>> actually does lockout safepoints until the members of the set 
>>> cooperatively
>>> allow the safepoint because of "yield"s etc.
>>
>> I'll be OK with SafepointLocker / Unlocker even though I think it's 
>> less descriptive than Regulate / Ignore.
>
> I agree.
>
>>
>>> Tony, I agree that MutexLocker/Unlocker exposes the fact that 
>>> there's a lock,
>>> but that's a historical artifact of mutual exlcusion and critical 
>>> sections
>>> having evolved primarily as mutexes in most of computer science and
>>> systems history. Thus readers closely associate one with the other.
>>> In fact "mutex" is after all "mutual exclusion" (which is a high level
>>> concept independent of the mechanism of "locks" used for it).
>>
>> Indeed, and point taken.
>>
>>> Having said that, I agree with Tony that there are pros and cons in 
>>> both cases
>>> and may be mentioning safepoints makes it too high level and abstract
>>> and in fact we do want the mention of suspendible thread sets, the 
>>> underlying
>>> mechanism.
>>>
>>> So, having aired some of these thoughts, I'll go with whatever you
>>> folks decide sounds best here.
>>
>> As always, thanks for the feedback!
>
> I think I like the names you have chosen above; thanks!
>
> -- ramki
>
>>
>> Tony
>>
>>> thanks!
>>> -- ramki
>>>
>>> On 10/06/11 09:29, John Cuthbertson wrote:
>>>> Hi Everyone,
>>>>
>>>> I think the template interpreter uses the names notice_safepoints() 
>>>> and ignore_safepoints() so in the same vein: NoticeSafepoints and 
>>>> IgnoreSafepoints.
>>>>
>>>> JohnC
>>>>
>>>> On 10/06/11 07:27, Tony Printezis wrote:
>>>>> Ramki,
>>>>>
>>>>> Thanks for your thoughts on this. Please see inline.
>>>>>
>>>>> On 10/6/2011 2:41 AM, Ramki Ramakrishna wrote:
>>>>>> Doing some late night  loud thinking here ... so please take this
>>>>>> with an adequate dose of salt....
>>>>>>
>>>>>> I am not sure joining or leaving the suspendible thread set
>>>>>> says anything about the actual intent of that action. In other words
>>>>>> the suspendible thread set is a mechanism or an implementation
>>>>>> of what is actually a synchronizing mechanism -- the intent is
>>>>>> that the actions in a {join; act; leave} scope are those that
>>>>>> want to somehow control the synchronization points of their
>>>>>> execution wrt safepoints because safepoints will probably
>>>>>> step on their toes or manipulate the same values. It's
>>>>>> really a form of mutual exclusion.
>>>>>
>>>>> Either way has pros and cons. I agree that abstracting away from 
>>>>> how the exclusion is implemented is helpful for someone who's not 
>>>>> familiar with the code. However, I'd claim that it's also 
>>>>> important to show that we're using the STS in this exclusion so 
>>>>> that the reader fully understands what the assumptions of the 
>>>>> exclusion are and also because they might need to explicitly yield 
>>>>> at some point, which is done through the STS.
>>>>>
>>>>> Let me predict what someone will say next: Ah, but we can also 
>>>>> wrap the yielding call in those nesting (is that the right word 
>>>>> for them?) objects too. Which would be nice. But there are cases 
>>>>> where the call to yield() (or the call to should_yield()) is deep 
>>>>> into the call hierarchy that's impractical to use the top-level 
>>>>> nesting objects for that.
>>>>>
>>>>> Also please note: (For better or worse) MutexLocker x(&my_mutex) 
>>>>> is very explicit in what it does. It doesn't say "we provide 
>>>>> mutual exclusion of that critical section using the given mutex". 
>>>>> It says "we'll keep that mutex locked during this critical 
>>>>> section". Unfortunately, I cannot think of a similar name for the 
>>>>> case we're discussing here.
>>>>>
>>>>>> In the same vein, the reverse namely {leave; act; join} seems
>>>>>> to be an explicit mechanism to get out of a synchronizing protocol
>>>>>> wrt safepoints (in this case presumably because such synchronization
>>>>>> would otherwise cause circular dependencies that might result in
>>>>>> a deadlock).
>>>>>
>>>>> This is indeed correct.
>>>>>
>>>>>> Thus while the suspendible thread sets is a specific implementation,
>>>>>> the high level idea involves synchronization wrt JVM safepoints
>>>>>> during which foreground gc's may do stuff to the same structures
>>>>>> that the wrapped actions are manipulating.
>>>>>>
>>>>>> It is for that reason that I had suggested the name 
>>>>>> "SynchronizeWithSafepoints"
>>>>>> although that is not an adequate name either. 
>>>>>
>>>>> I understand what "synchronize with safepoints" tries to convey 
>>>>> (i.e., "synchronize with the safepoint mechanism so that a 
>>>>> safepoint does not happen without my consent"). But it's a bit too 
>>>>> high-level to cover all the assumptions related to that mechanism.
>>>>>
>>>>>> (Perhaps your
>>>>>> suggestion of a name that describes the mechanism/implementation
>>>>>> may be better suited because of the inadequacy of my suggestion.)
>>>>>> Hopefully someone will think of a better name than either of these.
>>>>>
>>>>> So, if we want to keep it high level, how about IncludeSafepoints 
>>>>> / ExcludeSafepoints or WithSafepoints / WithoutSafepoints? But I 
>>>>> have to say my preference would be InsideSuspendibleThreadSet / 
>>>>> OutsideSuspendibleThreadSet.
>>>>>
>>>>> Tony
>>>>>
>>>>>> -- ramki
>>>>>>
>>>>>> On 10/5/2011 5:52 PM, Tony Printezis wrote:
>>>>>>>
>>>>>>>
>>>>>>> On 10/5/2011 8:27 PM, Tony Printezis wrote:
>>>>>>>>> [1] you will have to invent a suitable other name, perhaps 
>>>>>>>>> DesynchronizeWithSafepoints
>>>>>>>>> for when you do the reverse, i.e. perform an action outside of 
>>>>>>>>> the _sts, as happens
>>>>>>>>> when you are doing those synch barriers amongst the concurrent 
>>>>>>>>> marking
>>>>>>>>> threads in case of overflow and restart.
>>>>>>>>
>>>>>>>> I can't think of a good name off-hand but I'll think about it 
>>>>>>>> for a bit... (suggestions are welcome!) 
>>>>>>>
>>>>>>> How about JoinSuspendibleThreadSet / LeaveSuspendibleThreadSet, 
>>>>>>> example:
>>>>>>>
>>>>>>> {
>>>>>>>   JoinSuspendibleThreadSet x;
>>>>>>>   ...
>>>>>>> }
>>>>>>>
>>>>>>> Both sound very descriptive to me. Alternatively, maybe 
>>>>>>> InsideSuspendibleThreadSet / OutsideSuspendibleThreadSet?
>>>>>>>
>>>>>>> I'd love to have something like MutexLocker / MutexUnlocker but 
>>>>>>> I can't think of an appropriate noun 
>>>>>>> (SuspendibleThreadSetJoiner?!?!?!? this sounds SO wrong!).
>>>>>>>
>>>>>>> Tony
>>>>


More information about the hotspot-gc-dev mailing list