graal-jvmci-8: src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp comparison

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 22936:fb69749583e8

8072621: Clean up around VM_GC_Operations Reviewed-by: brutisso, jmasa

author	mlarsson
date	Thu, 09 Apr 2015 15:58:49 +0200
parents	c04f46b4abe4
children	33e421924c67

comparison

equal deleted inserted replaced

-:bff23dedb306
+:fb69749583e8
 /*
-* Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 void YoungList::print() {
 HeapRegion* lists[] = {_head,   _survivor_head};
 const char* names[] = {"YOUNG", "SURVIVOR"};
-for (unsigned int list = 0; list < ARRAY_SIZE(lists); ++list) {
+for (uint list = 0; list < ARRAY_SIZE(lists); ++list) {
 gclog_or_tty->print_cr("%s LIST CONTENTS", names[list]);
 HeapRegion *curr = lists[list];
 if (curr == NULL)
 gclog_or_tty->print_cr("  empty");
 while (curr != NULL) {
 HeapWord* G1CollectedHeap::allocate_new_tlab(size_t word_size) {
 assert_heap_not_locked_and_not_at_safepoint();
 assert(!isHumongous(word_size), "we do not allow humongous TLABs");
-unsigned int dummy_gc_count_before;
+uint dummy_gc_count_before;
-int dummy_gclocker_retry_count = 0;
+uint dummy_gclocker_retry_count = 0;
 return attempt_allocation(word_size, &dummy_gc_count_before, &dummy_gclocker_retry_count);
 }
 HeapWord*
 G1CollectedHeap::mem_allocate(size_t word_size,
 bool*  gc_overhead_limit_was_exceeded) {
 assert_heap_not_locked_and_not_at_safepoint();
 // Loop until the allocation is satisfied, or unsatisfied after GC.
-for (int try_count = 1, gclocker_retry_count = 0; /* we'll return */; try_count += 1) {
+for (uint try_count = 1, gclocker_retry_count = 0; /* we'll return */; try_count += 1) {
-unsigned int gc_count_before;
+uint gc_count_before;
 HeapWord* result = NULL;
 if (!isHumongous(word_size)) {
 result = attempt_allocation(word_size, &gc_count_before, &gclocker_retry_count);
 } else {
 return NULL;
 }
 HeapWord* G1CollectedHeap::attempt_allocation_slow(size_t word_size,
 AllocationContext_t context,
-unsigned int *gc_count_before_ret,
+uint* gc_count_before_ret,
-int* gclocker_retry_count_ret) {
+uint* gclocker_retry_count_ret) {
 // Make sure you read the note in attempt_allocation_humongous().
 assert_heap_not_locked_and_not_at_safepoint();
 assert(!isHumongous(word_size), "attempt_allocation_slow() should not "
 "be called for humongous allocation requests");
 // fails to perform the allocation. b) is the only case when we'll
 // return NULL.
 HeapWord* result = NULL;
 for (int try_count = 1; /* we'll return */; try_count += 1) {
 bool should_try_gc;
-unsigned int gc_count_before;
+uint gc_count_before;
 {
 MutexLockerEx x(Heap_lock);
 result = _allocator->mutator_alloc_region(context)->attempt_allocation_locked(word_size,
 false /* bot_updates */);
 }
 if (should_try_gc) {
 bool succeeded;
 result = do_collection_pause(word_size, gc_count_before, &succeeded,
 GCCause::_g1_inc_collection_pause);
 if (result != NULL) {
 assert(succeeded, "only way to get back a non-NULL result");
 return result;
 }
 ShouldNotReachHere();
 return NULL;
 }
 HeapWord* G1CollectedHeap::attempt_allocation_humongous(size_t word_size,
-unsigned int * gc_count_before_ret,
+uint* gc_count_before_ret,
-int* gclocker_retry_count_ret) {
+uint* gclocker_retry_count_ret) {
 // The structure of this method has a lot of similarities to
 // attempt_allocation_slow(). The reason these two were not merged
 // into a single one is that such a method would require several "if
 // allocation is not humongous do this, otherwise do that"
 // conditional paths which would obscure its flow. In fact, an early
 // fails to perform the allocation. b) is the only case when we'll
 // return NULL.
 HeapWord* result = NULL;
 for (int try_count = 1; /* we'll return */; try_count += 1) {
 bool should_try_gc;
-unsigned int gc_count_before;
+uint gc_count_before;
 {
 MutexLockerEx x(Heap_lock);
 // Given that humongous objects are not allocated in young
 // do a collection pause (if we're allowed) in case it reclaims
 // enough space for the allocation to succeed after the pause.
 bool succeeded;
 result = do_collection_pause(word_size, gc_count_before, &succeeded,
 GCCause::_g1_humongous_allocation);
 if (result != NULL) {
 assert(succeeded, "only way to get back a non-NULL result");
 return result;
 }
 uint n_rem_sets = HeapRegionRemSet::num_par_rem_sets();
 assert(n_rem_sets > 0, "Invariant.");
 _worker_cset_start_region = NEW_C_HEAP_ARRAY(HeapRegion*, n_queues, mtGC);
-_worker_cset_start_region_time_stamp = NEW_C_HEAP_ARRAY(unsigned int, n_queues, mtGC);
+_worker_cset_start_region_time_stamp = NEW_C_HEAP_ARRAY(uint, n_queues, mtGC);
 _evacuation_failed_info_array = NEW_C_HEAP_ARRAY(EvacuationFailedInfo, n_queues, mtGC);
 for (int i = 0; i < n_queues; i++) {
 RefToScanQueue* q = new RefToScanQueue();
 q->initialize();
 }
 void G1CollectedHeap::collect(GCCause::Cause cause) {
 assert_heap_not_locked();
-unsigned int gc_count_before;
+uint gc_count_before;
-unsigned int old_marking_count_before;
+uint old_marking_count_before;
-unsigned int full_gc_count_before;
+uint full_gc_count_before;
 bool retry_gc;
 do {
 retry_gc = false;
 // policy with the new heap occupancy
 Universe::update_heap_info_at_gc();
 }
 HeapWord* G1CollectedHeap::do_collection_pause(size_t word_size,
-unsigned int gc_count_before,
+uint gc_count_before,
 bool* succeeded,
 GCCause::Cause gc_cause) {
 assert_heap_not_locked_and_not_at_safepoint();
 g1_policy()->record_stop_world_start();
 VM_G1IncCollectionPause op(gc_count_before,

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp @ 22936:fb69749583e8