1 /*
2 * Copyright (c) 2001, 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_GC_SHENANDOAH_SATBMARKQUEUE_HPP
26 #define SHARE_VM_GC_SHENANDOAH_SATBMARKQUEUE_HPP
27
28 #include "gc/g1/ptrQueue.hpp"
29 #include "memory/allocation.hpp"
30
31 class JavaThread;
32 class ShenandoahSATBMarkQueueSet;
33
34 // Base class for processing the contents of a SATB buffer.
35 class ShenandoahSATBBufferClosure : public StackObj {
36 protected:
37 ~ShenandoahSATBBufferClosure() { }
38
39 public:
40 // Process the SATB entries in the designated buffer range.
41 virtual void do_buffer(void** buffer, size_t size) = 0;
42 };
43
44 // A PtrQueue whose elements are (possibly stale) pointers to object heads.
45 class ShenandoahSATBMarkQueue: public PtrQueue {
46 friend class ShenandoahSATBMarkQueueSet;
47
48 private:
49 // Filter out unwanted entries from the buffer.
50 void filter();
51
52 template <class HeapType>
53 void filter_impl();
54
55 public:
56 ShenandoahSATBMarkQueue(ShenandoahSATBMarkQueueSet* qset, bool permanent = false);
57
58 // Process queue entries and free resources.
59 void flush();
60
61 // Apply cl to the active part of the buffer.
62 // Prerequisite: Must be at a safepoint.
63 void apply_closure_and_empty(ShenandoahSATBBufferClosure* cl);
64
65 // Overrides PtrQueue::should_enqueue_buffer(). See the method's
66 // definition for more information.
67 virtual bool should_enqueue_buffer();
68
69 #ifndef PRODUCT
70 // Helpful for debugging
71 void print(const char* name);
72 #endif // PRODUCT
73
74 // Compiler support.
75 static ByteSize byte_offset_of_index() {
76 return PtrQueue::byte_offset_of_index<ShenandoahSATBMarkQueue>();
77 }
78 using PtrQueue::byte_width_of_index;
79
80 static ByteSize byte_offset_of_buf() {
81 return PtrQueue::byte_offset_of_buf<ShenandoahSATBMarkQueue>();
82 }
83 using PtrQueue::byte_width_of_buf;
84
85 static ByteSize byte_offset_of_active() {
86 return PtrQueue::byte_offset_of_active<ShenandoahSATBMarkQueue>();
87 }
88 using PtrQueue::byte_width_of_active;
89
90 };
91
92 class ShenandoahSATBMarkQueueSet: public PtrQueueSet {
93 ShenandoahSATBMarkQueue _shared_satb_queue;
94
95 #ifdef ASSERT
96 void dump_active_states(bool expected_active);
97 void verify_active_states(bool expected_active);
98 #endif // ASSERT
99
100 public:
101 ShenandoahSATBMarkQueueSet();
102
103 void initialize(Monitor* cbl_mon, Mutex* fl_lock,
104 int process_completed_threshold,
105 Mutex* lock);
106
107 ShenandoahSATBMarkQueue& satb_queue_for_thread(Thread* t);
108
109 // Apply "set_active(active)" to all SATB queues in the set. It should be
110 // called only with the world stopped. The method will assert that the
111 // SATB queues of all threads it visits, as well as the SATB queue
112 // set itself, has an active value same as expected_active.
113 void set_active_all_threads(bool active, bool expected_active);
114
115 // Filter all the currently-active SATB buffers.
116 void filter_thread_buffers();
117
118 // If there exists some completed buffer, pop and process it, and
119 // return true. Otherwise return false. Processing a buffer
120 // consists of applying the closure to the active range of the
121 // buffer; the leading entries may be excluded due to filtering.
122 bool apply_closure_to_completed_buffer(ShenandoahSATBBufferClosure* cl);
123
124 #ifndef PRODUCT
125 // Helpful for debugging
126 void print_all(const char* msg);
127 #endif // PRODUCT
128
129 ShenandoahSATBMarkQueue* shared_satb_queue() { return &_shared_satb_queue; }
130
131 // If a marking is being abandoned, reset any unprocessed log buffers.
132 void abandon_partial_marking();
133 };
134
135 #endif // SHARE_VM_GC_SHENANDOAH_SATBMARKQUEUE_HPP