250 |
250 |
251 // This is lock-free; assumes that it will only be called in parallel |
251 // This is lock-free; assumes that it will only be called in parallel |
252 // with other "push" operations (no pops). |
252 // with other "push" operations (no pops). |
253 void push(MemRegion mr); |
253 void push(MemRegion mr); |
254 |
254 |
|
255 #if 0 |
|
256 // This is currently not used. See the comment in the .cpp file. |
|
257 |
255 // Lock-free; assumes that it will only be called in parallel |
258 // Lock-free; assumes that it will only be called in parallel |
256 // with other "pop" operations (no pushes). |
259 // with other "pop" operations (no pushes). |
257 MemRegion pop(); |
260 MemRegion pop(); |
|
261 #endif // 0 |
|
262 |
|
263 // These two are the implementations that use a lock. They can be |
|
264 // called concurrently with each other but they should not be called |
|
265 // concurrently with the lock-free versions (push() / pop()). |
|
266 void push_with_lock(MemRegion mr); |
|
267 MemRegion pop_with_lock(); |
258 |
268 |
259 bool isEmpty() { return _index == 0; } |
269 bool isEmpty() { return _index == 0; } |
260 bool isFull() { return _index == _capacity; } |
270 bool isFull() { return _index == _capacity; } |
261 |
271 |
262 bool overflow() { return _overflow; } |
272 bool overflow() { return _overflow; } |
538 bool mark_stack_overflow() { return _markStack.overflow(); } |
548 bool mark_stack_overflow() { return _markStack.overflow(); } |
539 bool mark_stack_empty() { return _markStack.isEmpty(); } |
549 bool mark_stack_empty() { return _markStack.isEmpty(); } |
540 |
550 |
541 // Manipulation of the region stack |
551 // Manipulation of the region stack |
542 bool region_stack_push(MemRegion mr) { |
552 bool region_stack_push(MemRegion mr) { |
|
553 // Currently we only call the lock-free version during evacuation |
|
554 // pauses. |
|
555 assert(SafepointSynchronize::is_at_safepoint(), "world should be stopped"); |
|
556 |
543 _regionStack.push(mr); |
557 _regionStack.push(mr); |
544 if (_regionStack.overflow()) { |
558 if (_regionStack.overflow()) { |
545 set_has_overflown(); |
559 set_has_overflown(); |
546 return false; |
560 return false; |
547 } |
561 } |
548 return true; |
562 return true; |
549 } |
563 } |
550 MemRegion region_stack_pop() { return _regionStack.pop(); } |
564 #if 0 |
|
565 // Currently this is not used. See the comment in the .cpp file. |
|
566 MemRegion region_stack_pop() { return _regionStack.pop(); } |
|
567 #endif // 0 |
|
568 |
|
569 bool region_stack_push_with_lock(MemRegion mr) { |
|
570 // Currently we only call the lock-based version during either |
|
571 // concurrent marking or remark. |
|
572 assert(!SafepointSynchronize::is_at_safepoint() || !concurrent(), |
|
573 "if we are at a safepoint it should be the remark safepoint"); |
|
574 |
|
575 _regionStack.push_with_lock(mr); |
|
576 if (_regionStack.overflow()) { |
|
577 set_has_overflown(); |
|
578 return false; |
|
579 } |
|
580 return true; |
|
581 } |
|
582 MemRegion region_stack_pop_with_lock() { |
|
583 // Currently we only call the lock-based version during either |
|
584 // concurrent marking or remark. |
|
585 assert(!SafepointSynchronize::is_at_safepoint() || !concurrent(), |
|
586 "if we are at a safepoint it should be the remark safepoint"); |
|
587 |
|
588 return _regionStack.pop_with_lock(); |
|
589 } |
|
590 |
551 int region_stack_size() { return _regionStack.size(); } |
591 int region_stack_size() { return _regionStack.size(); } |
552 bool region_stack_overflow() { return _regionStack.overflow(); } |
592 bool region_stack_overflow() { return _regionStack.overflow(); } |
553 bool region_stack_empty() { return _regionStack.isEmpty(); } |
593 bool region_stack_empty() { return _regionStack.isEmpty(); } |
554 |
594 |
555 bool concurrent_marking_in_progress() { |
595 bool concurrent_marking_in_progress() { |