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 #include "precompiled.hpp"
26 #include "gc/parallel/mutableSpace.hpp"
27 #include "gc/parallel/parallelScavengeHeap.hpp"
28 #include "gc/parallel/psOldGen.hpp"
29 #include "gc/parallel/psPromotionManager.inline.hpp"
30 #include "gc/parallel/psScavenge.inline.hpp"
31 #include "gc/shared/gcTrace.hpp"
32 #include "gc/shared/preservedMarks.inline.hpp"
33 #include "gc/shared/taskqueue.inline.hpp"
34 #include "logging/log.hpp"
35 #include "memory/allocation.inline.hpp"
36 #include "memory/memRegion.hpp"
37 #include "memory/padded.inline.hpp"
38 #include "memory/resourceArea.hpp"
39 #include "oops/instanceKlass.inline.hpp"
40 #include "oops/instanceMirrorKlass.inline.hpp"
41 #include "oops/objArrayKlass.inline.hpp"
42 #include "oops/oop.inline.hpp"
43
44 PaddedEnd<PSPromotionManager>* PSPromotionManager::_manager_array = NULL;
45 OopStarTaskQueueSet* PSPromotionManager::_stack_array_depth = NULL;
220
221 // Do not prefill the LAB's, save heap wastage!
222 HeapWord* lab_base = young_space()->top();
223 _young_lab.initialize(MemRegion(lab_base, (size_t)0));
224 _young_gen_is_full = false;
225
226 lab_base = old_gen()->object_space()->top();
227 _old_lab.initialize(MemRegion(lab_base, (size_t)0));
228 _old_gen_is_full = false;
229
230 _promotion_failed_info.reset();
231
232 TASKQUEUE_STATS_ONLY(reset_stats());
233 }
234
235 void PSPromotionManager::register_preserved_marks(PreservedMarks* preserved_marks) {
236 assert(_preserved_marks == NULL, "do not set it twice");
237 _preserved_marks = preserved_marks;
238 }
239
240 void PSPromotionManager::restore_preserved_marks() {
241 _preserved_marks_set->restore(PSScavenge::gc_task_manager());
242 }
243
244 void PSPromotionManager::drain_stacks_depth(bool totally_drain) {
245 totally_drain = totally_drain || _totally_drain;
246
247 #ifdef ASSERT
248 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
249 MutableSpace* to_space = heap->young_gen()->to_space();
250 MutableSpace* old_space = heap->old_gen()->object_space();
251 #endif /* ASSERT */
252
253 OopStarTaskQueue* const tq = claimed_stack_depth();
254 do {
255 StarTask p;
256
257 // Drain overflow stack first, so other threads can steal from
258 // claimed stack while we work.
259 while (tq->pop_overflow(p)) {
260 process_popped_location_depth(p);
261 }
|
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 #include "precompiled.hpp"
26 #include "gc/parallel/gcTaskManager.hpp"
27 #include "gc/parallel/mutableSpace.hpp"
28 #include "gc/parallel/parallelScavengeHeap.hpp"
29 #include "gc/parallel/psOldGen.hpp"
30 #include "gc/parallel/psPromotionManager.inline.hpp"
31 #include "gc/parallel/psScavenge.inline.hpp"
32 #include "gc/shared/gcTrace.hpp"
33 #include "gc/shared/preservedMarks.inline.hpp"
34 #include "gc/shared/taskqueue.inline.hpp"
35 #include "logging/log.hpp"
36 #include "memory/allocation.inline.hpp"
37 #include "memory/memRegion.hpp"
38 #include "memory/padded.inline.hpp"
39 #include "memory/resourceArea.hpp"
40 #include "oops/instanceKlass.inline.hpp"
41 #include "oops/instanceMirrorKlass.inline.hpp"
42 #include "oops/objArrayKlass.inline.hpp"
43 #include "oops/oop.inline.hpp"
44
45 PaddedEnd<PSPromotionManager>* PSPromotionManager::_manager_array = NULL;
46 OopStarTaskQueueSet* PSPromotionManager::_stack_array_depth = NULL;
221
222 // Do not prefill the LAB's, save heap wastage!
223 HeapWord* lab_base = young_space()->top();
224 _young_lab.initialize(MemRegion(lab_base, (size_t)0));
225 _young_gen_is_full = false;
226
227 lab_base = old_gen()->object_space()->top();
228 _old_lab.initialize(MemRegion(lab_base, (size_t)0));
229 _old_gen_is_full = false;
230
231 _promotion_failed_info.reset();
232
233 TASKQUEUE_STATS_ONLY(reset_stats());
234 }
235
236 void PSPromotionManager::register_preserved_marks(PreservedMarks* preserved_marks) {
237 assert(_preserved_marks == NULL, "do not set it twice");
238 _preserved_marks = preserved_marks;
239 }
240
241 class ParRestoreGCTask : public GCTask {
242 private:
243 const uint _id;
244 PreservedMarksSet* const _preserved_marks_set;
245 volatile size_t* const _total_size_addr;
246
247 public:
248 virtual char* name() {
249 return (char*) "preserved mark restoration task";
250 }
251
252 virtual void do_it(GCTaskManager* manager, uint which){
253 _preserved_marks_set->get(_id)->restore_and_increment(_total_size_addr);
254 }
255
256 ParRestoreGCTask(uint id,
257 PreservedMarksSet* preserved_marks_set,
258 volatile size_t* total_size_addr)
259 : _id(id),
260 _preserved_marks_set(preserved_marks_set),
261 _total_size_addr(total_size_addr) { }
262 };
263
264 class PSPreservedMarksTaskExecutor : public RestorePreservedMarksTaskExecutor {
265 public:
266 GCTaskManager* _gc_task_manager;
267
268 PSPreservedMarksTaskExecutor(GCTaskManager* gc_task_manager)
269 : _gc_task_manager(gc_task_manager) { }
270
271 void restore(PreservedMarksSet* preserved_marks_set,
272 volatile size_t* total_size_addr) {
273 // GCTask / GCTaskQueue are ResourceObjs
274 ResourceMark rm;
275
276 GCTaskQueue* q = GCTaskQueue::create();
277 for (uint i = 0; i < preserved_marks_set->num(); i += 1) {
278 q->enqueue(new ParRestoreGCTask(i, preserved_marks_set, total_size_addr));
279 }
280 _gc_task_manager->execute_and_wait(q);
281 }
282 };
283
284 void PSPromotionManager::restore_preserved_marks() {
285 PSPreservedMarksTaskExecutor task_executor(PSScavenge::gc_task_manager());
286 _preserved_marks_set->restore(&task_executor);
287 }
288
289 void PSPromotionManager::drain_stacks_depth(bool totally_drain) {
290 totally_drain = totally_drain || _totally_drain;
291
292 #ifdef ASSERT
293 ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
294 MutableSpace* to_space = heap->young_gen()->to_space();
295 MutableSpace* old_space = heap->old_gen()->object_space();
296 #endif /* ASSERT */
297
298 OopStarTaskQueue* const tq = claimed_stack_depth();
299 do {
300 StarTask p;
301
302 // Drain overflow stack first, so other threads can steal from
303 // claimed stack while we work.
304 while (tq->pop_overflow(p)) {
305 process_popped_location_depth(p);
306 }
|