32 _satb_mark_queue_buffer_allocator("SATB Buffer Allocator", ShenandoahSATBBufferSize)
33 {}
34
35 void ShenandoahSATBMarkQueueSet::initialize(ShenandoahHeap* const heap,
36 Monitor* cbl_mon,
37 int process_completed_threshold,
38 uint buffer_enqueue_threshold_percentage,
39 Mutex* lock) {
40 SATBMarkQueueSet::initialize(cbl_mon,
41 &_satb_mark_queue_buffer_allocator,
42 process_completed_threshold,
43 buffer_enqueue_threshold_percentage,
44 lock);
45 _heap = heap;
46 }
47
48 SATBMarkQueue& ShenandoahSATBMarkQueueSet::satb_queue_for_thread(JavaThread* const t) const {
49 return ShenandoahThreadLocalData::satb_mark_queue(t);
50 }
51
52 static inline bool discard_entry(const void* entry, ShenandoahHeap* heap) {
53 return !heap->requires_marking(entry);
54 }
55
56 class ShenandoahSATBMarkQueueFilterFn {
57 ShenandoahHeap* _heap;
58
59 public:
60 ShenandoahSATBMarkQueueFilterFn(ShenandoahHeap* heap) : _heap(heap) {}
61
62 // Return true if entry should be filtered out (removed), false if
63 // it should be retained.
64 bool operator()(const void* entry) const {
65 return discard_entry(entry, _heap);
66 }
67 };
68
69 void ShenandoahSATBMarkQueueSet::filter(SATBMarkQueue* queue) {
70 assert(_heap != NULL, "SATB queue set not initialized");
71 apply_filter(ShenandoahSATBMarkQueueFilterFn(_heap), queue);
72 }
73
74 bool ShenandoahSATBMarkQueue::should_enqueue_buffer() {
75 bool should_enqueue = SATBMarkQueue::should_enqueue_buffer();
76 size_t cap = capacity();
77 Thread* t = Thread::current();
78 if (ShenandoahThreadLocalData::is_force_satb_flush(t)) {
79 if (!should_enqueue && cap != index()) {
80 // Non-empty buffer is compacted, and we decided not to enqueue it.
81 // We still want to know about leftover work in that buffer eventually.
82 // This avoid dealing with these leftovers during the final-mark, after
83 // the buffers are drained completely. See JDK-8205353 for more discussion.
84 should_enqueue = true;
85 }
86 ShenandoahThreadLocalData::set_force_satb_flush(t, false);
87 }
88 return should_enqueue;
89 }
|
32 _satb_mark_queue_buffer_allocator("SATB Buffer Allocator", ShenandoahSATBBufferSize)
33 {}
34
35 void ShenandoahSATBMarkQueueSet::initialize(ShenandoahHeap* const heap,
36 Monitor* cbl_mon,
37 int process_completed_threshold,
38 uint buffer_enqueue_threshold_percentage,
39 Mutex* lock) {
40 SATBMarkQueueSet::initialize(cbl_mon,
41 &_satb_mark_queue_buffer_allocator,
42 process_completed_threshold,
43 buffer_enqueue_threshold_percentage,
44 lock);
45 _heap = heap;
46 }
47
48 SATBMarkQueue& ShenandoahSATBMarkQueueSet::satb_queue_for_thread(JavaThread* const t) const {
49 return ShenandoahThreadLocalData::satb_mark_queue(t);
50 }
51
52 template <bool RESOLVE>
53 class ShenandoahSATBMarkQueueFilterFn {
54 ShenandoahHeap* const _heap;
55
56 public:
57 ShenandoahSATBMarkQueueFilterFn(ShenandoahHeap* heap) : _heap(heap) {}
58
59 // Return true if entry should be filtered out (removed), false if
60 // it should be retained.
61 bool operator()(const void* entry) const {
62 return !_heap->requires_marking<RESOLVE>(entry);
63 }
64 };
65
66 void ShenandoahSATBMarkQueueSet::filter(SATBMarkQueue* queue) {
67 assert(_heap != NULL, "SATB queue set not initialized");
68 if (_heap->has_forwarded_objects()) {
69 apply_filter(ShenandoahSATBMarkQueueFilterFn<true>(_heap), queue);
70 } else {
71 apply_filter(ShenandoahSATBMarkQueueFilterFn<false>(_heap), queue);
72 }
73 }
74
75 bool ShenandoahSATBMarkQueue::should_enqueue_buffer() {
76 bool should_enqueue = SATBMarkQueue::should_enqueue_buffer();
77 size_t cap = capacity();
78 Thread* t = Thread::current();
79 if (ShenandoahThreadLocalData::is_force_satb_flush(t)) {
80 if (!should_enqueue && cap != index()) {
81 // Non-empty buffer is compacted, and we decided not to enqueue it.
82 // We still want to know about leftover work in that buffer eventually.
83 // This avoid dealing with these leftovers during the final-mark, after
84 // the buffers are drained completely. See JDK-8205353 for more discussion.
85 should_enqueue = true;
86 }
87 ShenandoahThreadLocalData::set_force_satb_flush(t, false);
88 }
89 return should_enqueue;
90 }
|