Mercurial > hg > truffle
annotate src/share/vm/gc_implementation/g1/ptrQueue.hpp @ 889:15c5903cf9e1
6865703: G1: Parallelize hot card cache cleanup
Summary: Have the GC worker threads clear the hot card cache in parallel by having each worker thread claim a chunk of the card cache and process the cards in that chunk. The size of the chunks that each thread will claim is determined at VM initialization from the size of the card cache and the number of worker threads.
Reviewed-by: jmasa, tonyp
| author | johnc |
|---|---|
| date | Mon, 03 Aug 2009 12:59:30 -0700 |
| parents | 7bb995fbd3c0 |
| children | 44f61c24ddab |
| rev | line source |
|---|---|
| 342 | 1 /* |
| 579 | 2 * Copyright 2001-2009 Sun Microsystems, Inc. All Rights Reserved. |
| 342 | 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 // There are various techniques that require threads to be able to log | |
| 26 // addresses. For example, a generational write barrier might log | |
| 27 // the addresses of modified old-generation objects. This type supports | |
| 28 // this operation. | |
| 29 | |
| 30 class PtrQueueSet; | |
| 31 | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
470
diff
changeset
|
32 class PtrQueue VALUE_OBJ_CLASS_SPEC { |
| 342 | 33 |
| 34 protected: | |
| 35 // The ptr queue set to which this queue belongs. | |
| 36 PtrQueueSet* _qset; | |
| 37 | |
| 38 // Whether updates should be logged. | |
| 39 bool _active; | |
| 40 | |
| 41 // The buffer. | |
| 42 void** _buf; | |
| 43 // The index at which an object was last enqueued. Starts at "_sz" | |
| 44 // (indicating an empty buffer) and goes towards zero. | |
| 45 size_t _index; | |
| 46 | |
| 47 // The size of the buffer. | |
| 48 size_t _sz; | |
| 49 | |
| 50 // If true, the queue is permanent, and doesn't need to deallocate | |
| 51 // its buffer in the destructor (since that obtains a lock which may not | |
| 52 // be legally locked by then. | |
| 53 bool _perm; | |
| 54 | |
| 55 // If there is a lock associated with this buffer, this is that lock. | |
| 56 Mutex* _lock; | |
| 57 | |
| 58 PtrQueueSet* qset() { return _qset; } | |
| 59 | |
| 60 public: | |
| 61 // Initialize this queue to contain a null buffer, and be part of the | |
| 62 // given PtrQueueSet. | |
| 63 PtrQueue(PtrQueueSet*, bool perm = false); | |
| 64 // Release any contained resources. | |
|
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
342
diff
changeset
|
65 void flush(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
342
diff
changeset
|
66 // Calls flush() when destroyed. |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
342
diff
changeset
|
67 ~PtrQueue() { flush(); } |
| 342 | 68 |
| 69 // Associate a lock with a ptr queue. | |
| 70 void set_lock(Mutex* lock) { _lock = lock; } | |
| 71 | |
| 72 void reset() { if (_buf != NULL) _index = _sz; } | |
| 73 | |
| 74 // Enqueues the given "obj". | |
| 75 void enqueue(void* ptr) { | |
| 76 if (!_active) return; | |
| 77 else enqueue_known_active(ptr); | |
| 78 } | |
| 79 | |
| 80 inline void handle_zero_index(); | |
| 81 void locking_enqueue_completed_buffer(void** buf); | |
| 82 | |
| 83 void enqueue_known_active(void* ptr); | |
| 84 | |
| 85 size_t size() { | |
| 86 assert(_sz >= _index, "Invariant."); | |
| 87 return _buf == NULL ? 0 : _sz - _index; | |
| 88 } | |
| 89 | |
| 90 // Set the "active" property of the queue to "b". An enqueue to an | |
| 91 // inactive thread is a no-op. Setting a queue to inactive resets its | |
| 92 // log to the empty state. | |
| 93 void set_active(bool b) { | |
| 94 _active = b; | |
| 95 if (!b && _buf != NULL) { | |
| 96 _index = _sz; | |
| 97 } else if (b && _buf != NULL) { | |
| 98 assert(_index == _sz, "invariant: queues are empty when activated."); | |
| 99 } | |
| 100 } | |
| 101 | |
| 102 static int byte_index_to_index(int ind) { | |
| 103 assert((ind % oopSize) == 0, "Invariant."); | |
| 104 return ind / oopSize; | |
| 105 } | |
| 106 | |
| 107 static int index_to_byte_index(int byte_ind) { | |
| 108 return byte_ind * oopSize; | |
| 109 } | |
| 110 | |
| 111 // To support compiler. | |
| 112 static ByteSize byte_offset_of_index() { | |
| 113 return byte_offset_of(PtrQueue, _index); | |
| 114 } | |
| 115 static ByteSize byte_width_of_index() { return in_ByteSize(sizeof(size_t)); } | |
| 116 | |
| 117 static ByteSize byte_offset_of_buf() { | |
| 118 return byte_offset_of(PtrQueue, _buf); | |
| 119 } | |
| 120 static ByteSize byte_width_of_buf() { return in_ByteSize(sizeof(void*)); } | |
| 121 | |
| 122 static ByteSize byte_offset_of_active() { | |
| 123 return byte_offset_of(PtrQueue, _active); | |
| 124 } | |
| 125 static ByteSize byte_width_of_active() { return in_ByteSize(sizeof(bool)); } | |
| 126 | |
| 127 }; | |
| 128 | |
| 129 // A PtrQueueSet represents resources common to a set of pointer queues. | |
| 130 // In particular, the individual queues allocate buffers from this shared | |
| 131 // set, and return completed buffers to the set. | |
| 132 // All these variables are are protected by the TLOQ_CBL_mon. XXX ??? | |
|
549
fe3d7c11b4b7
6700941: G1: allocation spec missing for some G1 classes
apetrusenko
parents:
470
diff
changeset
|
133 class PtrQueueSet VALUE_OBJ_CLASS_SPEC { |
| 342 | 134 |
| 135 protected: | |
| 136 | |
| 137 class CompletedBufferNode: public CHeapObj { | |
| 138 public: | |
| 139 void** buf; | |
| 140 size_t index; | |
| 141 CompletedBufferNode* next; | |
| 142 CompletedBufferNode() : buf(NULL), | |
| 143 index(0), next(NULL){ } | |
| 144 }; | |
| 145 | |
| 146 Monitor* _cbl_mon; // Protects the fields below. | |
| 147 CompletedBufferNode* _completed_buffers_head; | |
| 148 CompletedBufferNode* _completed_buffers_tail; | |
| 149 size_t _n_completed_buffers; | |
| 150 size_t _process_completed_threshold; | |
| 151 volatile bool _process_completed; | |
| 152 | |
| 153 // This (and the interpretation of the first element as a "next" | |
| 154 // pointer) are protected by the TLOQ_FL_lock. | |
| 155 Mutex* _fl_lock; | |
| 156 void** _buf_free_list; | |
| 157 size_t _buf_free_list_sz; | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
549
diff
changeset
|
158 // Queue set can share a freelist. The _fl_owner variable |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
549
diff
changeset
|
159 // specifies the owner. It is set to "this" by default. |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
549
diff
changeset
|
160 PtrQueueSet* _fl_owner; |
| 342 | 161 |
| 162 // The size of all buffers in the set. | |
| 163 size_t _sz; | |
| 164 | |
| 165 bool _all_active; | |
| 166 | |
| 167 // If true, notify_all on _cbl_mon when the threshold is reached. | |
| 168 bool _notify_when_complete; | |
| 169 | |
| 170 // Maximum number of elements allowed on completed queue: after that, | |
| 171 // enqueuer does the work itself. Zero indicates no maximum. | |
| 172 int _max_completed_queue; | |
| 173 | |
| 174 int completed_buffers_list_length(); | |
| 175 void assert_completed_buffer_list_len_correct_locked(); | |
| 176 void assert_completed_buffer_list_len_correct(); | |
| 177 | |
| 178 protected: | |
| 179 // A mutator thread does the the work of processing a buffer. | |
| 180 // Returns "true" iff the work is complete (and the buffer may be | |
| 181 // deallocated). | |
| 182 virtual bool mut_process_buffer(void** buf) { | |
| 183 ShouldNotReachHere(); | |
| 184 return false; | |
| 185 } | |
| 186 | |
| 187 public: | |
| 188 // Create an empty ptr queue set. | |
| 189 PtrQueueSet(bool notify_when_complete = false); | |
| 190 | |
| 191 // Because of init-order concerns, we can't pass these as constructor | |
| 192 // arguments. | |
| 193 void initialize(Monitor* cbl_mon, Mutex* fl_lock, | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
549
diff
changeset
|
194 int max_completed_queue = 0, |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
549
diff
changeset
|
195 PtrQueueSet *fl_owner = NULL) { |
| 342 | 196 _max_completed_queue = max_completed_queue; |
| 197 assert(cbl_mon != NULL && fl_lock != NULL, "Init order issue?"); | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
549
diff
changeset
|
198 _cbl_mon = cbl_mon; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
549
diff
changeset
|
199 _fl_lock = fl_lock; |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
549
diff
changeset
|
200 _fl_owner = (fl_owner != NULL) ? fl_owner : this; |
| 342 | 201 } |
| 202 | |
| 203 // Return an empty oop array of size _sz (required to be non-zero). | |
| 204 void** allocate_buffer(); | |
| 205 | |
| 206 // Return an empty buffer to the free list. The "buf" argument is | |
| 207 // required to be a pointer to the head of an array of length "_sz". | |
| 208 void deallocate_buffer(void** buf); | |
| 209 | |
| 210 // Declares that "buf" is a complete buffer. | |
| 211 void enqueue_complete_buffer(void** buf, size_t index = 0, | |
| 212 bool ignore_max_completed = false); | |
| 213 | |
| 214 bool completed_buffers_exist_dirty() { | |
| 215 return _n_completed_buffers > 0; | |
| 216 } | |
| 217 | |
| 218 bool process_completed_buffers() { return _process_completed; } | |
| 219 | |
| 220 bool active() { return _all_active; } | |
| 221 | |
| 222 // Set the buffer size. Should be called before any "enqueue" operation | |
| 223 // can be called. And should only be called once. | |
| 224 void set_buffer_size(size_t sz); | |
| 225 | |
| 226 // Get the buffer size. | |
| 227 size_t buffer_size() { return _sz; } | |
| 228 | |
| 229 // Set the number of completed buffers that triggers log processing. | |
| 230 void set_process_completed_threshold(size_t sz); | |
| 231 | |
| 232 // Must only be called at a safe point. Indicates that the buffer free | |
| 233 // list size may be reduced, if that is deemed desirable. | |
| 234 void reduce_free_list(); | |
| 235 | |
| 236 size_t completed_buffers_num() { return _n_completed_buffers; } | |
|
616
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
549
diff
changeset
|
237 |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
549
diff
changeset
|
238 void merge_bufferlists(PtrQueueSet* src); |
|
4f360ec815ba
6720309: G1: don't synchronously update RSet during evacuation pauses
iveresov
parents:
549
diff
changeset
|
239 void merge_freelists(PtrQueueSet* src); |
| 342 | 240 }; |