--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/memory/GenCollectedHeap.java Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/memory/GenCollectedHeap.java Thu Apr 02 13:38:47 2015 -0700
@@ -37,7 +37,9 @@
private static CIntegerField nGensField;
private static AddressField youngGenField;
private static AddressField oldGenField;
- private static AddressField genSpecsField;
+
+ private static AddressField youngGenSpecField;
+ private static AddressField oldGenSpecField;
private static GenerationFactory genFactory;
@@ -55,9 +57,12 @@
nGensField = type.getCIntegerField("_n_gens");
youngGenField = type.getAddressField("_young_gen");
oldGenField = type.getAddressField("_old_gen");
- genSpecsField = type.getAddressField("_gen_specs");
genFactory = new GenerationFactory();
+
+ Type collectorPolicyType = db.lookupType("GenCollectorPolicy");
+ youngGenSpecField = collectorPolicyType.getAddressField("_young_gen_spec");
+ oldGenSpecField = collectorPolicyType.getAddressField("_old_gen_spec");
}
public GenCollectedHeap(Address addr) {
@@ -115,21 +120,23 @@
/** Package-private access to GenerationSpecs */
GenerationSpec spec(int level) {
if (Assert.ASSERTS_ENABLED) {
- Assert.that((level >= 0) && (level < nGens()), "Index " + level +
- " out of range (should be between 0 and " + nGens() + ")");
+ Assert.that((level == 0) || (level == 1), "Index " + level +
+ " out of range (should be 0 or 1)");
}
- if ((level < 0) || (level >= nGens())) {
+ if ((level != 0) && (level != 1)) {
return null;
}
- Address ptrList = genSpecsField.getValue(addr);
- if (ptrList == null) {
- return null;
+ if (level == 0) {
+ return (GenerationSpec)
+ VMObjectFactory.newObject(GenerationSpec.class,
+ youngGenSpecField.getAddress());
+ } else {
+ return (GenerationSpec)
+ VMObjectFactory.newObject(GenerationSpec.class,
+ oldGenSpecField.getAddress());
}
- return (GenerationSpec)
- VMObjectFactory.newObject(GenerationSpec.class,
- ptrList.getAddressAt(level * VM.getVM().getAddressSize()));
}
public CollectedHeapName kind() {
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2007, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 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
@@ -52,9 +52,10 @@
}
void ConcurrentMarkSweepPolicy::initialize_generations() {
- _generations = NEW_C_HEAP_ARRAY(GenerationSpecPtr, number_of_generations(), mtGC);
- _generations[0] = new GenerationSpec(Generation::ParNew, _initial_young_size, _max_young_size);
- _generations[1] = new GenerationSpec(Generation::ConcurrentMarkSweep, _initial_old_size, _max_old_size);
+ _young_gen_spec = new GenerationSpec(Generation::ParNew, _initial_young_size,
+ _max_young_size, _gen_alignment);
+ _old_gen_spec = new GenerationSpec(Generation::ConcurrentMarkSweep,
+ _initial_old_size, _max_old_size, _gen_alignment);
}
void ConcurrentMarkSweepPolicy::initialize_size_policy(size_t init_eden_size,
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -65,8 +65,6 @@
#include "services/memoryService.hpp"
#include "services/runtimeService.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
// statics
CMSCollector* ConcurrentMarkSweepGeneration::_collector = NULL;
bool CMSCollector::_full_gc_requested = false;
@@ -1593,7 +1591,7 @@
bitMapLock()->lock_without_safepoint_check();
if (TraceCMSState) {
gclog_or_tty->print_cr("CMS foreground collector has asked for control "
- INTPTR_FORMAT " with first state %d", Thread::current(), first_state);
+ INTPTR_FORMAT " with first state %d", p2i(Thread::current()), first_state);
gclog_or_tty->print_cr(" gets control with state %d", _collectorState);
}
@@ -1763,27 +1761,27 @@
// Eden
if (_eden_chunk_array != NULL) {
gclog_or_tty->print_cr("eden " PTR_FORMAT "-" PTR_FORMAT "-" PTR_FORMAT "(" SIZE_FORMAT ")",
- eden_space->bottom(), eden_space->top(),
- eden_space->end(), eden_space->capacity());
+ p2i(eden_space->bottom()), p2i(eden_space->top()),
+ p2i(eden_space->end()), eden_space->capacity());
gclog_or_tty->print_cr("_eden_chunk_index=" SIZE_FORMAT ", "
"_eden_chunk_capacity=" SIZE_FORMAT,
_eden_chunk_index, _eden_chunk_capacity);
for (size_t i = 0; i < _eden_chunk_index; i++) {
gclog_or_tty->print_cr("_eden_chunk_array[" SIZE_FORMAT "]=" PTR_FORMAT,
- i, _eden_chunk_array[i]);
+ i, p2i(_eden_chunk_array[i]));
}
}
// Survivor
if (_survivor_chunk_array != NULL) {
gclog_or_tty->print_cr("survivor " PTR_FORMAT "-" PTR_FORMAT "-" PTR_FORMAT "(" SIZE_FORMAT ")",
- from_space->bottom(), from_space->top(),
- from_space->end(), from_space->capacity());
+ p2i(from_space->bottom()), p2i(from_space->top()),
+ p2i(from_space->end()), from_space->capacity());
gclog_or_tty->print_cr("_survivor_chunk_index=" SIZE_FORMAT ", "
"_survivor_chunk_capacity=" SIZE_FORMAT,
_survivor_chunk_index, _survivor_chunk_capacity);
for (size_t i = 0; i < _survivor_chunk_index; i++) {
gclog_or_tty->print_cr("_survivor_chunk_array[" SIZE_FORMAT "]=" PTR_FORMAT,
- i, _survivor_chunk_array[i]);
+ i, p2i(_survivor_chunk_array[i]));
}
}
}
@@ -1890,7 +1888,7 @@
while (_collectorState != Idling) {
if (TraceCMSState) {
gclog_or_tty->print_cr("Thread " INTPTR_FORMAT " in CMS state %d",
- Thread::current(), _collectorState);
+ p2i(Thread::current()), _collectorState);
}
// The foreground collector
// holds the Heap_lock throughout its collection.
@@ -1924,7 +1922,7 @@
if (TraceCMSState) {
gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT
" exiting collection CMS state %d",
- Thread::current(), _collectorState);
+ p2i(Thread::current()), _collectorState);
}
return;
} else {
@@ -2031,7 +2029,7 @@
}
if (TraceCMSState) {
gclog_or_tty->print_cr(" Thread " INTPTR_FORMAT " done - next CMS state %d",
- Thread::current(), _collectorState);
+ p2i(Thread::current()), _collectorState);
}
assert(_foregroundGCShouldWait, "block post-condition");
}
@@ -2054,7 +2052,7 @@
if (TraceCMSState) {
gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT
" exiting collection CMS state %d",
- Thread::current(), _collectorState);
+ p2i(Thread::current()), _collectorState);
}
if (PrintGC && Verbose) {
_cmsGen->print_heap_change(prev_used);
@@ -2112,7 +2110,7 @@
CGC_lock->notify();
if (TraceCMSState) {
gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT " waiting at CMS state %d",
- Thread::current(), _collectorState);
+ p2i(Thread::current()), _collectorState);
}
while (_foregroundGCIsActive) {
CGC_lock->wait(Mutex::_no_safepoint_check_flag);
@@ -2124,7 +2122,7 @@
}
if (TraceCMSState) {
gclog_or_tty->print_cr("CMS Thread " INTPTR_FORMAT " continuing at CMS state %d",
- Thread::current(), _collectorState);
+ p2i(Thread::current()), _collectorState);
}
return res;
}
@@ -2356,13 +2354,13 @@
// Clear the marking bit map array before starting, but, just
// for kicks, first report if the given address is already marked
- gclog_or_tty->print_cr("Start: Address " PTR_FORMAT " is%s marked", addr,
+ gclog_or_tty->print_cr("Start: Address " PTR_FORMAT " is%s marked", p2i(addr),
_markBitMap.isMarked(addr) ? "" : " not");
if (verify_after_remark()) {
MutexLockerEx x(verification_mark_bm()->lock(), Mutex::_no_safepoint_check_flag);
bool result = verification_mark_bm()->isMarked(addr);
- gclog_or_tty->print_cr("TransitiveMark: Address " PTR_FORMAT " %s marked", addr,
+ gclog_or_tty->print_cr("TransitiveMark: Address " PTR_FORMAT " %s marked", p2i(addr),
result ? "IS" : "is NOT");
return result;
} else {
@@ -2377,13 +2375,13 @@
CMSCollector* collector = ConcurrentMarkSweepGeneration::_collector;
if (collector != NULL) {
CMSBitMap* bitmap = &collector->_markBitMap;
- st->print_cr("Marking Bits: (CMSBitMap*) " PTR_FORMAT, bitmap);
+ st->print_cr("Marking Bits: (CMSBitMap*) " PTR_FORMAT, p2i(bitmap));
bitmap->print_on_error(st, " Bits: ");
st->cr();
CMSBitMap* mut_bitmap = &collector->_modUnionTable;
- st->print_cr("Mod Union Table: (CMSBitMap*) " PTR_FORMAT, mut_bitmap);
+ st->print_cr("Mod Union Table: (CMSBitMap*) " PTR_FORMAT, p2i(mut_bitmap));
mut_bitmap->print_on_error(st, " Bits: ");
}
}
@@ -2406,7 +2404,7 @@
HeapWord* addr = _marks->offsetToHeapWord(offset);
if (!_marks->isMarked(addr)) {
oop(addr)->print_on(gclog_or_tty);
- gclog_or_tty->print_cr(" ("INTPTR_FORMAT" should have been marked)", addr);
+ gclog_or_tty->print_cr(" ("INTPTR_FORMAT" should have been marked)", p2i(addr));
_failed = true;
}
return true;
@@ -2474,7 +2472,7 @@
// presumably, a mutation to A failed to be picked up by preclean/remark?
verify_after_remark_work_2();
} else {
- warning("Unrecognized value %d for CMSRemarkVerifyVariant",
+ warning("Unrecognized value " UINTX_FORMAT " for CMSRemarkVerifyVariant",
CMSRemarkVerifyVariant);
}
if (!silent) gclog_or_tty->print(" done] ");
@@ -5056,7 +5054,7 @@
for (size_t i = 0; i < total - 1; i++) {
if (PrintCMSStatistics > 0) {
gclog_or_tty->print(" (chunk" SIZE_FORMAT ":" INTPTR_FORMAT ") ",
- i, _survivor_chunk_array[i]);
+ i, p2i(_survivor_chunk_array[i]));
}
assert(_survivor_chunk_array[i] < _survivor_chunk_array[i+1],
"Not sorted");
@@ -5700,8 +5698,8 @@
gclog_or_tty->print_cr(
"CMS: Large Block: " PTR_FORMAT ";"
" Proximity: " PTR_FORMAT " -> " PTR_FORMAT,
- largestAddr,
- _cmsSpace->nearLargestChunk(), minAddr + nearLargestOffset);
+ p2i(largestAddr),
+ p2i(_cmsSpace->nearLargestChunk()), p2i(minAddr + nearLargestOffset));
}
_cmsSpace->set_nearLargestChunk(minAddr + nearLargestOffset);
}
@@ -6184,7 +6182,7 @@
_verification_bm->mark(addr);
if (!_cms_bm->isMarked(addr)) {
oop(addr)->print();
- gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)", addr);
+ gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)", p2i(addr));
fatal("... aborting");
}
}
@@ -6979,7 +6977,7 @@
if (!_cms_bm->isMarked(addr)) {
oop(addr)->print();
gclog_or_tty->print_cr(" (" INTPTR_FORMAT " should have been marked)",
- addr);
+ p2i(addr));
fatal("... aborting");
}
@@ -7375,16 +7373,16 @@
"sweep _limit out of bounds");
if (CMSTraceSweeper) {
gclog_or_tty->print_cr("\n====================\nStarting new sweep with limit " PTR_FORMAT,
- _limit);
+ p2i(_limit));
}
}
void SweepClosure::print_on(outputStream* st) const {
tty->print_cr("_sp = [" PTR_FORMAT "," PTR_FORMAT ")",
- _sp->bottom(), _sp->end());
- tty->print_cr("_limit = " PTR_FORMAT, _limit);
- tty->print_cr("_freeFinger = " PTR_FORMAT, _freeFinger);
- NOT_PRODUCT(tty->print_cr("_last_fc = " PTR_FORMAT, _last_fc);)
+ p2i(_sp->bottom()), p2i(_sp->end()));
+ tty->print_cr("_limit = " PTR_FORMAT, p2i(_limit));
+ tty->print_cr("_freeFinger = " PTR_FORMAT, p2i(_freeFinger));
+ NOT_PRODUCT(tty->print_cr("_last_fc = " PTR_FORMAT, p2i(_last_fc));)
tty->print_cr("_inFreeRange = %d, _freeRangeInFreeLists = %d, _lastFreeRangeCoalesced = %d",
_inFreeRange, _freeRangeInFreeLists, _lastFreeRangeCoalesced);
}
@@ -7428,7 +7426,7 @@
}
if (CMSTraceSweeper) {
gclog_or_tty->print_cr("end of sweep with _limit = " PTR_FORMAT "\n================",
- _limit);
+ p2i(_limit));
}
}
#endif // PRODUCT
@@ -7437,7 +7435,7 @@
bool freeRangeInFreeLists) {
if (CMSTraceSweeper) {
gclog_or_tty->print("---- Start free range at " PTR_FORMAT " with free block (%d)\n",
- freeFinger, freeRangeInFreeLists);
+ p2i(freeFinger), freeRangeInFreeLists);
}
assert(!inFreeRange(), "Trampling existing free range");
set_inFreeRange(true);
@@ -7501,14 +7499,14 @@
// coalesced chunk to the appropriate free list.
if (inFreeRange()) {
assert(freeFinger() >= _sp->bottom() && freeFinger() < _limit,
- err_msg("freeFinger() " PTR_FORMAT" is out-of-bounds", freeFinger()));
+ err_msg("freeFinger() " PTR_FORMAT" is out-of-bounds", p2i(freeFinger())));
flush_cur_free_chunk(freeFinger(),
pointer_delta(addr, freeFinger()));
if (CMSTraceSweeper) {
gclog_or_tty->print("Sweep: last chunk: ");
gclog_or_tty->print("put_free_blk " PTR_FORMAT " ("SIZE_FORMAT") "
"[coalesced:%d]\n",
- freeFinger(), pointer_delta(addr, freeFinger()),
+ p2i(freeFinger()), pointer_delta(addr, freeFinger()),
lastFreeRangeCoalesced() ? 1 : 0);
}
}
@@ -7652,7 +7650,7 @@
// the midst of a free range, we are coalescing
print_free_block_coalesced(fc);
if (CMSTraceSweeper) {
- gclog_or_tty->print(" -- pick up free block " PTR_FORMAT " (" SIZE_FORMAT ")\n", fc, size);
+ gclog_or_tty->print(" -- pick up free block " PTR_FORMAT " (" SIZE_FORMAT ")\n", p2i(fc), size);
}
// remove it from the free lists
_sp->removeFreeChunkFromFreeLists(fc);
@@ -7714,7 +7712,7 @@
// this will be swept up when we hit the end of the
// free range
if (CMSTraceSweeper) {
- gclog_or_tty->print(" -- pick up garbage " PTR_FORMAT " (" SIZE_FORMAT ")\n", fc, size);
+ gclog_or_tty->print(" -- pick up garbage " PTR_FORMAT " (" SIZE_FORMAT ")\n", p2i(fc), size);
}
// If the chunk is being coalesced and the current free range is
// in the free lists, remove the current free range so that it
@@ -7807,7 +7805,7 @@
}
if (CMSTraceSweeper) {
- gclog_or_tty->print_cr(" -- pick up another chunk at " PTR_FORMAT " (" SIZE_FORMAT ")", fc, chunkSize);
+ gclog_or_tty->print_cr(" -- pick up another chunk at " PTR_FORMAT " (" SIZE_FORMAT ")", p2i(fc), chunkSize);
}
HeapWord* const fc_addr = (HeapWord*) fc;
@@ -7906,14 +7904,14 @@
err_msg("eob = " PTR_FORMAT " eob-1 = " PTR_FORMAT " _limit = " PTR_FORMAT
" out of bounds wrt _sp = [" PTR_FORMAT "," PTR_FORMAT ")"
" when examining fc = " PTR_FORMAT "(" SIZE_FORMAT ")",
- eob, eob-1, _limit, _sp->bottom(), _sp->end(), fc, chunk_size));
+ p2i(eob), p2i(eob-1), p2i(_limit), p2i(_sp->bottom()), p2i(_sp->end()), p2i(fc), chunk_size));
if (eob >= _limit) {
assert(eob == _limit || fc->is_free(), "Only a free chunk should allow us to cross over the limit");
if (CMSTraceSweeper) {
gclog_or_tty->print_cr("_limit " PTR_FORMAT " reached or crossed by block "
"[" PTR_FORMAT "," PTR_FORMAT ") in space "
"[" PTR_FORMAT "," PTR_FORMAT ")",
- _limit, fc, eob, _sp->bottom(), _sp->end());
+ p2i(_limit), p2i(fc), p2i(eob), p2i(_sp->bottom()), p2i(_sp->end()));
}
// Return the storage we are tracking back into the free lists.
if (CMSTraceSweeper) {
@@ -7937,7 +7935,7 @@
}
if (CMSTraceSweeper) {
gclog_or_tty->print_cr(" -- add free block " PTR_FORMAT " (" SIZE_FORMAT ") to free lists",
- chunk, size);
+ p2i(chunk), size);
}
// A new free range is going to be starting. The current
// free range has not been added to the free lists yet or
@@ -8010,7 +8008,7 @@
void SweepClosure::print_free_block_coalesced(FreeChunk* fc) const {
if (CMSTraceSweeper) {
gclog_or_tty->print_cr("Sweep:coal_free_blk " PTR_FORMAT " (" SIZE_FORMAT ")",
- fc, fc->size());
+ p2i(fc), fc->size());
}
}
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/freeChunk.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/freeChunk.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -27,8 +27,6 @@
#include "memory/freeBlockDictionary.hpp"
#include "utilities/copy.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
#ifndef PRODUCT
#define baadbabeHeapWord badHeapWordVal
@@ -74,5 +72,5 @@
void FreeChunk::print_on(outputStream* st) {
st->print_cr("Next: " PTR_FORMAT " Prev: " PTR_FORMAT " %s",
- next(), prev(), cantCoalesce() ? "[can't coalesce]" : "");
+ p2i(next()), p2i(prev()), cantCoalesce() ? "[can't coalesce]" : "");
}
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/promotionInfo.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/promotionInfo.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -28,8 +28,6 @@
#include "oops/markOop.inline.hpp"
#include "oops/oop.inline.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
/////////////////////////////////////////////////////////////////////////
//// PromotionInfo
/////////////////////////////////////////////////////////////////////////
@@ -360,6 +358,6 @@
void SpoolBlock::print_on(outputStream* st) const {
st->print("[" PTR_FORMAT "," PTR_FORMAT "), " SIZE_FORMAT " HeapWords -> " PTR_FORMAT,
- this, (HeapWord*)displacedHdr + bufferSize,
- bufferSize, nextSpoolBlock);
+ p2i(this), p2i((HeapWord*)displacedHdr + bufferSize),
+ bufferSize, p2i(nextSpoolBlock));
}
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/vmCMSOperations.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/vmCMSOperations.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -34,8 +34,6 @@
#include "runtime/os.hpp"
#include "utilities/dtrace.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
//////////////////////////////////////////////////////////
// Methods in abstract class VM_CMS_Operation
//////////////////////////////////////////////////////////
--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -2088,10 +2088,7 @@
_cleanup_times.add((end - start) * 1000.0);
if (G1Log::fine()) {
- g1h->print_size_transition(gclog_or_tty,
- start_used_bytes,
- g1h->used(),
- g1h->capacity());
+ g1h->g1_policy()->print_heap_transition(start_used_bytes);
}
// Clean up will have freed any regions completely full of garbage.
@@ -2584,7 +2581,7 @@
public:
G1RemarkThreadsClosure(G1CollectedHeap* g1h, CMTask* task) :
_cm_obj(task), _cm_cl(g1h, g1h->concurrent_mark(), task), _code_cl(&_cm_cl, !CodeBlobToOopClosure::FixRelocations),
- _thread_parity(SharedHeap::heap()->strong_roots_parity()) {}
+ _thread_parity(Threads::thread_claim_parity()) {}
void do_thread(Thread* thread) {
if (thread->is_Java_thread()) {
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CardCounts.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CardCounts.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -31,8 +31,6 @@
#include "services/memTracker.hpp"
#include "utilities/copy.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
void G1CardCountsMappingChangedListener::on_commit(uint start_idx, size_t num_regions, bool zero_filled) {
if (zero_filled) {
return;
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CodeCacheRemSet.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CodeCacheRemSet.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -33,8 +33,6 @@
#include "utilities/hashtable.inline.hpp"
#include "utilities/stack.inline.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
class CodeRootSetTable : public Hashtable<nmethod*, mtGC> {
friend class G1CodeRootSetTest;
typedef HashtableEntry<nmethod*, mtGC> Entry;
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -66,7 +66,6 @@
#include "memory/iterator.hpp"
#include "memory/referenceProcessor.hpp"
#include "oops/oop.inline.hpp"
-#include "oops/oop.pcgc.inline.hpp"
#include "runtime/atomic.inline.hpp"
#include "runtime/orderAccess.inline.hpp"
#include "runtime/vmThread.hpp"
@@ -403,25 +402,6 @@
return hr;
}
-#ifdef ASSERT
-// A region is added to the collection set as it is retired
-// so an address p can point to a region which will be in the
-// collection set but has not yet been retired. This method
-// therefore is only accurate during a GC pause after all
-// regions have been retired. It is used for debugging
-// to check if an nmethod has references to objects that can
-// be move during a partial collection. Though it can be
-// inaccurate, it is sufficient for G1 because the conservative
-// implementation of is_scavengable() for G1 will indicate that
-// all nmethods must be scanned during a partial collection.
-bool G1CollectedHeap::is_in_partial_collection(const void* p) {
- if (p == NULL) {
- return false;
- }
- return heap_region_containing(p)->in_collection_set();
-}
-#endif
-
// Returns true if the reference points to an object that
// can move in an incremental collection.
bool G1CollectedHeap::is_scavengable(const void* p) {
@@ -1748,7 +1728,7 @@
G1CollectedHeap::G1CollectedHeap(G1CollectorPolicy* policy_) :
- SharedHeap(policy_),
+ SharedHeap(),
_g1_policy(policy_),
_dirty_card_queue_set(false),
_into_cset_dirty_card_queue_set(false),
@@ -3732,7 +3712,14 @@
TraceCPUTime tcpu(G1Log::finer(), true, gclog_or_tty);
- uint active_workers = workers()->active_workers();
+ uint active_workers = AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(),
+ workers()->active_workers(),
+ Threads::number_of_non_daemon_threads());
+ assert(UseDynamicNumberOfGCThreads ||
+ active_workers == workers()->total_workers(),
+ "If not dynamic should be using all the workers");
+ workers()->set_active_workers(active_workers);
+
double pause_start_sec = os::elapsedTime();
g1_policy()->phase_times()->note_gc_start(active_workers, mark_in_progress());
log_gc_header();
@@ -5430,15 +5417,10 @@
hot_card_cache->reset_hot_cache_claimed_index();
hot_card_cache->set_use_cache(false);
- uint n_workers;
- n_workers =
- AdaptiveSizePolicy::calc_active_workers(workers()->total_workers(),
- workers()->active_workers(),
- Threads::number_of_non_daemon_threads());
+ const uint n_workers = workers()->active_workers();
assert(UseDynamicNumberOfGCThreads ||
n_workers == workers()->total_workers(),
"If not dynamic should be using all the workers");
- workers()->set_active_workers(n_workers);
set_par_threads(n_workers);
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -1008,7 +1008,7 @@
// Set _n_par_threads according to a policy TBD.
void set_par_threads();
- virtual CollectedHeap::Name kind() const {
+ virtual Name kind() const {
return CollectedHeap::G1CollectedHeap;
}
@@ -1379,10 +1379,6 @@
inline bool is_in_young(const oop obj);
-#ifdef ASSERT
- virtual bool is_in_partial_collection(const void* p);
-#endif
-
virtual bool is_scavengable(const void* addr);
// We don't need barriers for initializing stores to objects
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -1201,11 +1201,21 @@
}
}
+void G1CollectorPolicy::print_heap_transition(size_t bytes_before) {
+ size_t bytes_after = _g1->used();
+ size_t capacity = _g1->capacity();
+
+ gclog_or_tty->print(" " SIZE_FORMAT "%s->" SIZE_FORMAT "%s(" SIZE_FORMAT "%s)",
+ byte_size_in_proper_unit(bytes_before),
+ proper_unit_for_byte_size(bytes_before),
+ byte_size_in_proper_unit(bytes_after),
+ proper_unit_for_byte_size(bytes_after),
+ byte_size_in_proper_unit(capacity),
+ proper_unit_for_byte_size(capacity));
+}
+
void G1CollectorPolicy::print_heap_transition() {
- _g1->print_size_transition(gclog_or_tty,
- _heap_used_bytes_before_gc,
- _g1->used(),
- _g1->capacity());
+ print_heap_transition(_heap_used_bytes_before_gc);
}
void G1CollectorPolicy::print_detailed_heap_transition(bool full) {
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -700,6 +700,8 @@
void record_heap_size_info_at_start(bool full);
// Print heap sizing transition (with less and more detail).
+
+ void print_heap_transition(size_t bytes_before);
void print_heap_transition();
void print_detailed_heap_transition(bool full = false);
--- a/hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -154,28 +154,28 @@
_has_new_data = true;
}
- double average(){
- calculate_totals();
+ double average(uint active_threads){
+ calculate_totals(active_threads);
return _average;
}
- T sum() {
- calculate_totals();
+ T sum(uint active_threads) {
+ calculate_totals(active_threads);
return _sum;
}
- T minimum() {
- calculate_totals();
+ T minimum(uint active_threads) {
+ calculate_totals(active_threads);
return _min;
}
- T maximum() {
- calculate_totals();
+ T maximum(uint active_threads) {
+ calculate_totals(active_threads);
return _max;
}
void reset() PRODUCT_RETURN;
- void verify() PRODUCT_RETURN;
+ void verify(uint active_threads) PRODUCT_RETURN;
void set_enabled(bool enabled) { _enabled = enabled; }
@@ -183,7 +183,7 @@
private:
- void calculate_totals(){
+ void calculate_totals(uint active_threads){
if (!_has_new_data) {
return;
}
@@ -191,13 +191,14 @@
_sum = (T)0;
_min = _data[0];
_max = _min;
- for (uint i = 0; i < _length; ++i) {
+ assert(active_threads <= _length, "Wrong number of active threads");
+ for (uint i = 0; i < active_threads; ++i) {
T val = _data[i];
_sum += val;
_min = MIN2(_min, val);
_max = MAX2(_max, val);
}
- _average = (double)_sum / (double)_length;
+ _average = (double)_sum / (double)active_threads;
_has_new_data = false;
}
};
@@ -226,17 +227,18 @@
}
template <class T>
-void WorkerDataArray<T>::verify() {
+void WorkerDataArray<T>::verify(uint active_threads) {
if (!_enabled) {
return;
}
- for (uint i = 0; i < _length; i++) {
+ assert(active_threads <= _length, "Wrong number of active threads");
+ for (uint i = 0; i < active_threads; i++) {
assert(_data[i] != WorkerDataArray<T>::uninitialized(),
err_msg("Invalid data for worker %u in '%s'", i, _title));
}
if (_thread_work_items != NULL) {
- _thread_work_items->verify();
+ _thread_work_items->verify(active_threads);
}
}
@@ -321,7 +323,7 @@
}
for (int i = 0; i < GCParPhasesSentinel; i++) {
- _gc_par_phases[i]->verify();
+ _gc_par_phases[i]->verify(_active_gc_threads);
}
}
@@ -378,7 +380,7 @@
// return the average time for a phase in milliseconds
double G1GCPhaseTimes::average_time_ms(GCParPhases phase) {
- return _gc_par_phases[phase]->average() * 1000.0;
+ return _gc_par_phases[phase]->average(_active_gc_threads) * 1000.0;
}
double G1GCPhaseTimes::get_time_ms(GCParPhases phase, uint worker_i) {
@@ -386,15 +388,15 @@
}
double G1GCPhaseTimes::sum_time_ms(GCParPhases phase) {
- return _gc_par_phases[phase]->sum() * 1000.0;
+ return _gc_par_phases[phase]->sum(_active_gc_threads) * 1000.0;
}
double G1GCPhaseTimes::min_time_ms(GCParPhases phase) {
- return _gc_par_phases[phase]->minimum() * 1000.0;
+ return _gc_par_phases[phase]->minimum(_active_gc_threads) * 1000.0;
}
double G1GCPhaseTimes::max_time_ms(GCParPhases phase) {
- return _gc_par_phases[phase]->maximum() * 1000.0;
+ return _gc_par_phases[phase]->maximum(_active_gc_threads) * 1000.0;
}
size_t G1GCPhaseTimes::get_thread_work_item(GCParPhases phase, uint worker_i) {
@@ -404,22 +406,22 @@
size_t G1GCPhaseTimes::sum_thread_work_items(GCParPhases phase) {
assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
- return _gc_par_phases[phase]->thread_work_items()->sum();
+ return _gc_par_phases[phase]->thread_work_items()->sum(_active_gc_threads);
}
double G1GCPhaseTimes::average_thread_work_items(GCParPhases phase) {
assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
- return _gc_par_phases[phase]->thread_work_items()->average();
+ return _gc_par_phases[phase]->thread_work_items()->average(_active_gc_threads);
}
size_t G1GCPhaseTimes::min_thread_work_items(GCParPhases phase) {
assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
- return _gc_par_phases[phase]->thread_work_items()->minimum();
+ return _gc_par_phases[phase]->thread_work_items()->minimum(_active_gc_threads);
}
size_t G1GCPhaseTimes::max_thread_work_items(GCParPhases phase) {
assert(_gc_par_phases[phase]->thread_work_items() != NULL, "No sub count");
- return _gc_par_phases[phase]->thread_work_items()->maximum();
+ return _gc_par_phases[phase]->thread_work_items()->maximum(_active_gc_threads);
}
class G1GCParPhasePrinter : public StackObj {
@@ -455,14 +457,16 @@
}
void print_time_values(LineBuffer& buf, G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray<double>* phase) {
- for (uint i = 0; i < phase->_length; ++i) {
+ uint active_length = _phase_times->_active_gc_threads;
+ for (uint i = 0; i < active_length; ++i) {
buf.append(" %.1lf", _phase_times->get_time_ms(phase_id, i));
}
buf.print_cr();
}
void print_count_values(LineBuffer& buf, G1GCPhaseTimes::GCParPhases phase_id, WorkerDataArray<size_t>* thread_work_items) {
- for (uint i = 0; i < thread_work_items->_length; ++i) {
+ uint active_length = _phase_times->_active_gc_threads;
+ for (uint i = 0; i < active_length; ++i) {
buf.append(" " SIZE_FORMAT, _phase_times->get_thread_work_item(phase_id, i));
}
buf.print_cr();
--- a/hotspot/src/share/vm/gc_implementation/g1/g1HRPrinter.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1HRPrinter.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -27,8 +27,6 @@
#include "gc_implementation/g1/heapRegion.hpp"
#include "utilities/ostream.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
const char* G1HRPrinter::action_name(ActionType action) {
switch(action) {
case Alloc: return "ALLOC";
@@ -85,18 +83,18 @@
if (type_str != NULL) {
if (top != NULL) {
gclog_or_tty->print_cr(G1HR_PREFIX" %s(%s) "PTR_FORMAT" "PTR_FORMAT,
- action_str, type_str, bottom, top);
+ action_str, type_str, p2i(bottom), p2i(top));
} else {
gclog_or_tty->print_cr(G1HR_PREFIX" %s(%s) "PTR_FORMAT,
- action_str, type_str, bottom);
+ action_str, type_str, p2i(bottom));
}
} else {
if (top != NULL) {
gclog_or_tty->print_cr(G1HR_PREFIX" %s "PTR_FORMAT" "PTR_FORMAT,
- action_str, bottom, top);
+ action_str, p2i(bottom), p2i(top));
} else {
gclog_or_tty->print_cr(G1HR_PREFIX" %s "PTR_FORMAT,
- action_str, bottom);
+ action_str, p2i(bottom));
}
}
}
@@ -105,7 +103,7 @@
const char* action_str = action_name(action);
gclog_or_tty->print_cr(G1HR_PREFIX" %s ["PTR_FORMAT","PTR_FORMAT"]",
- action_str, bottom, end);
+ action_str, p2i(bottom), p2i(end));
}
void G1HRPrinter::print(PhaseType phase, size_t phase_num) {
--- a/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * 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
@@ -33,6 +33,7 @@
#include "gc_implementation/g1/g1MarkSweep.hpp"
#include "gc_implementation/g1/g1RootProcessor.hpp"
#include "gc_implementation/g1/g1StringDedup.hpp"
+#include "gc_implementation/shared/markSweep.inline.hpp"
#include "gc_implementation/shared/gcHeapSummary.hpp"
#include "gc_implementation/shared/gcTimer.hpp"
#include "gc_implementation/shared/gcTrace.hpp"
@@ -217,7 +218,7 @@
// We must adjust the pointers on the single H object.
oop obj = oop(r->bottom());
// point all the oops to the new location
- obj->adjust_pointers();
+ MarkSweep::adjust_pointers(obj);
}
} else {
// This really ought to be "as_CompactibleSpace"...
--- a/hotspot/src/share/vm/gc_implementation/g1/g1ParScanThreadState.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1ParScanThreadState.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -27,7 +27,6 @@
#include "gc_implementation/g1/g1OopClosures.inline.hpp"
#include "gc_implementation/g1/g1ParScanThreadState.inline.hpp"
#include "oops/oop.inline.hpp"
-#include "oops/oop.pcgc.inline.hpp"
#include "runtime/prefetch.inline.hpp"
G1ParScanThreadState::G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num, ReferenceProcessor* rp)
--- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -39,8 +39,6 @@
#include "utilities/globalDefinitions.hpp"
#include "utilities/intHisto.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
#define CARD_REPEAT_HISTO 0
#if CARD_REPEAT_HISTO
@@ -156,9 +154,9 @@
"RS names card " SIZE_FORMAT_HEX ": "
"[" PTR_FORMAT ", " PTR_FORMAT ")",
_worker_i,
- card_region->bottom(), card_region->end(),
+ p2i(card_region->bottom()), p2i(card_region->end()),
card_index,
- card_start, card_start + G1BlockOffsetSharedArray::N_words);
+ p2i(card_start), p2i(card_start + G1BlockOffsetSharedArray::N_words));
}
void scan_strong_code_roots(HeapRegion* r) {
@@ -428,7 +426,7 @@
err_msg("Card at "PTR_FORMAT" index "SIZE_FORMAT" representing heap at "PTR_FORMAT" (%u) must be in committed heap",
p2i(card_ptr),
_ct_bs->index_for(_ct_bs->addr_for(card_ptr)),
- _ct_bs->addr_for(card_ptr),
+ p2i(_ct_bs->addr_for(card_ptr)),
_g1->addr_to_region(_ct_bs->addr_for(card_ptr))));
// If the card is no longer dirty, nothing to do.
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -39,8 +39,6 @@
#include "runtime/atomic.inline.hpp"
#include "runtime/orderAccess.inline.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
int HeapRegion::LogOfHRGrainBytes = 0;
int HeapRegion::LogOfHRGrainWords = 0;
size_t HeapRegion::GrainBytes = 0;
@@ -505,7 +503,7 @@
gclog_or_tty->print_cr("Object "PTR_FORMAT" in region "
"["PTR_FORMAT", "PTR_FORMAT") is above "
"top "PTR_FORMAT,
- (void *)obj, _hr->bottom(), _hr->end(), _hr->top());
+ p2i(obj), p2i(_hr->bottom()), p2i(_hr->end()), p2i(_hr->top()));
_failures = true;
return;
}
@@ -540,7 +538,7 @@
if (!nm->is_alive()) {
gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] has dead nmethod "
PTR_FORMAT" in its strong code roots",
- _hr->bottom(), _hr->end(), nm);
+ p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm));
_failures = true;
} else {
VerifyStrongCodeRootOopClosure oop_cl(_hr, nm);
@@ -549,12 +547,12 @@
gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] has nmethod "
PTR_FORMAT" in its strong code roots "
"with no pointers into region",
- _hr->bottom(), _hr->end(), nm);
+ p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm));
_failures = true;
} else if (oop_cl.failures()) {
gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] has other "
"failures for nmethod "PTR_FORMAT,
- _hr->bottom(), _hr->end(), nm);
+ p2i(_hr->bottom()), p2i(_hr->end()), p2i(nm));
_failures = true;
}
}
@@ -589,7 +587,7 @@
if (strong_code_roots_length > 0) {
gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] is empty "
"but has "SIZE_FORMAT" code root entries",
- bottom(), end(), strong_code_roots_length);
+ p2i(bottom()), p2i(end()), strong_code_roots_length);
*failures = true;
}
return;
@@ -624,7 +622,7 @@
st->print(" ");
st->print(" TS %5d", _gc_time_stamp);
st->print(" PTAMS "PTR_FORMAT" NTAMS "PTR_FORMAT,
- prev_top_at_mark_start(), next_top_at_mark_start());
+ p2i(prev_top_at_mark_start()), p2i(next_top_at_mark_start()));
G1OffsetTableContigSpace::print_on(st);
}
@@ -687,23 +685,23 @@
gclog_or_tty->print_cr("Field "PTR_FORMAT
" of live obj "PTR_FORMAT" in region "
"["PTR_FORMAT", "PTR_FORMAT")",
- p, (void*) _containing_obj,
- from->bottom(), from->end());
+ p2i(p), p2i(_containing_obj),
+ p2i(from->bottom()), p2i(from->end()));
print_object(gclog_or_tty, _containing_obj);
gclog_or_tty->print_cr("points to obj "PTR_FORMAT" not in the heap",
- (void*) obj);
+ p2i(obj));
} else {
HeapRegion* from = _g1h->heap_region_containing((HeapWord*)p);
HeapRegion* to = _g1h->heap_region_containing((HeapWord*)obj);
gclog_or_tty->print_cr("Field "PTR_FORMAT
" of live obj "PTR_FORMAT" in region "
"["PTR_FORMAT", "PTR_FORMAT")",
- p, (void*) _containing_obj,
- from->bottom(), from->end());
+ p2i(p), p2i(_containing_obj),
+ p2i(from->bottom()), p2i(from->end()));
print_object(gclog_or_tty, _containing_obj);
gclog_or_tty->print_cr("points to dead obj "PTR_FORMAT" in region "
"["PTR_FORMAT", "PTR_FORMAT")",
- (void*) obj, to->bottom(), to->end());
+ p2i(obj), p2i(to->bottom()), p2i(to->end()));
print_object(gclog_or_tty, obj);
}
gclog_or_tty->print_cr("----------");
@@ -741,12 +739,12 @@
gclog_or_tty->print_cr("Field "PTR_FORMAT" "
"of obj "PTR_FORMAT", "
"in region "HR_FORMAT,
- p, (void*) _containing_obj,
+ p2i(p), p2i(_containing_obj),
HR_FORMAT_PARAMS(from));
_containing_obj->print_on(gclog_or_tty);
gclog_or_tty->print_cr("points to obj "PTR_FORMAT" "
"in region "HR_FORMAT,
- (void*) obj,
+ p2i(obj),
HR_FORMAT_PARAMS(to));
obj->print_on(gclog_or_tty);
gclog_or_tty->print_cr("Obj head CTE = %d, field CTE = %d.",
@@ -783,7 +781,7 @@
!g1->is_obj_dead(obj, this)) { // Dead objects may have bigger block_size since they span several objects.
gclog_or_tty->print_cr("obj "PTR_FORMAT" is of %shumongous size ("
SIZE_FORMAT" words) in a %shumongous region",
- p, g1->is_humongous(obj_size) ? "" : "non-",
+ p2i(p), g1->is_humongous(obj_size) ? "" : "non-",
obj_size, is_region_humongous ? "" : "non-");
*failures = true;
return;
@@ -797,12 +795,12 @@
ClassLoaderDataGraph::unload_list_contains(klass));
if (!is_metaspace_object) {
gclog_or_tty->print_cr("klass "PTR_FORMAT" of object "PTR_FORMAT" "
- "not metadata", klass, (void *)obj);
+ "not metadata", p2i(klass), p2i(obj));
*failures = true;
return;
} else if (!klass->is_klass()) {
gclog_or_tty->print_cr("klass "PTR_FORMAT" of object "PTR_FORMAT" "
- "not a klass", klass, (void *)obj);
+ "not a klass", p2i(klass), p2i(obj));
*failures = true;
return;
} else {
@@ -817,7 +815,7 @@
}
}
} else {
- gclog_or_tty->print_cr(PTR_FORMAT" no an oop", (void *)obj);
+ gclog_or_tty->print_cr(PTR_FORMAT" no an oop", p2i(obj));
*failures = true;
return;
}
@@ -832,7 +830,7 @@
if (p != top()) {
gclog_or_tty->print_cr("end of last object "PTR_FORMAT" "
- "does not match top "PTR_FORMAT, p, top());
+ "does not match top "PTR_FORMAT, p2i(p), p2i(top()));
*failures = true;
return;
}
@@ -849,7 +847,7 @@
if (b_start_1 != p) {
gclog_or_tty->print_cr("BOT look up for top: "PTR_FORMAT" "
" yielded "PTR_FORMAT", expecting "PTR_FORMAT,
- addr_1, b_start_1, p);
+ p2i(addr_1), p2i(b_start_1), p2i(p));
*failures = true;
return;
}
@@ -861,7 +859,7 @@
if (b_start_2 != p) {
gclog_or_tty->print_cr("BOT look up for top + 1: "PTR_FORMAT" "
" yielded "PTR_FORMAT", expecting "PTR_FORMAT,
- addr_2, b_start_2, p);
+ p2i(addr_2), p2i(b_start_2), p2i(p));
*failures = true;
return;
}
@@ -875,7 +873,7 @@
if (b_start_3 != p) {
gclog_or_tty->print_cr("BOT look up for top + diff: "PTR_FORMAT" "
" yielded "PTR_FORMAT", expecting "PTR_FORMAT,
- addr_3, b_start_3, p);
+ p2i(addr_3), p2i(b_start_3), p2i(p));
*failures = true;
return;
}
@@ -887,7 +885,7 @@
if (b_start_4 != p) {
gclog_or_tty->print_cr("BOT look up for end - 1: "PTR_FORMAT" "
" yielded "PTR_FORMAT", expecting "PTR_FORMAT,
- addr_4, b_start_4, p);
+ p2i(addr_4), p2i(b_start_4), p2i(p));
*failures = true;
return;
}
@@ -896,7 +894,7 @@
if (is_region_humongous && object_num > 1) {
gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] is humongous "
"but has "SIZE_FORMAT", objects",
- bottom(), end(), object_num);
+ p2i(bottom()), p2i(end()), object_num);
*failures = true;
return;
}
@@ -947,7 +945,7 @@
print_short();
gclog_or_tty->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", "
INTPTR_FORMAT ", " INTPTR_FORMAT ")",
- bottom(), top(), _offsets.threshold(), end());
+ p2i(bottom()), p2i(top()), p2i(_offsets.threshold()), p2i(end()));
}
HeapWord* G1OffsetTableContigSpace::initialize_threshold() {
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -37,8 +37,6 @@
#include "utilities/globalDefinitions.hpp"
#include "utilities/growableArray.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
class PerRegionTable: public CHeapObj<mtGC> {
friend class OtherRegionsTable;
friend class HeapRegionRemSetIterator;
@@ -93,10 +91,10 @@
if (G1TraceHeapRegionRememberedSet) {
gclog_or_tty->print_cr(" PRT::Add_reference_work(" PTR_FORMAT "->" PTR_FORMAT").",
- from,
+ p2i(from),
UseCompressedOops
- ? (void *)oopDesc::load_decode_heap_oop((narrowOop*)from)
- : (void *)oopDesc::load_decode_heap_oop((oop*)from));
+ ? p2i(oopDesc::load_decode_heap_oop((narrowOop*)from))
+ : p2i(oopDesc::load_decode_heap_oop((oop*)from)));
}
HeapRegion* loc_hr = hr();
@@ -412,17 +410,17 @@
if (G1TraceHeapRegionRememberedSet) {
gclog_or_tty->print_cr("ORT::add_reference_work(" PTR_FORMAT "->" PTR_FORMAT ").",
- from,
+ p2i(from),
UseCompressedOops
- ? (void *)oopDesc::load_decode_heap_oop((narrowOop*)from)
- : (void *)oopDesc::load_decode_heap_oop((oop*)from));
+ ? p2i(oopDesc::load_decode_heap_oop((narrowOop*)from))
+ : p2i(oopDesc::load_decode_heap_oop((oop*)from)));
}
int from_card = (int)(uintptr_t(from) >> CardTableModRefBS::card_shift);
if (G1TraceHeapRegionRememberedSet) {
gclog_or_tty->print_cr("Table for [" PTR_FORMAT "...): card %d (cache = %d)",
- _hr->bottom(), from_card,
+ p2i(_hr->bottom()), from_card,
FromCardCache::at(tid, cur_hrm_ind));
}
@@ -471,7 +469,7 @@
"[" PTR_FORMAT "...) for ref " PTR_FORMAT ".\n",
align_size_down(uintptr_t(from),
CardTableModRefBS::card_size),
- _hr->bottom(), from);
+ p2i(_hr->bottom()), p2i(from));
}
}
if (G1TraceHeapRegionRememberedSet) {
@@ -533,7 +531,7 @@
"[" PTR_FORMAT "...) for ref " PTR_FORMAT ".\n",
align_size_down(uintptr_t(from),
CardTableModRefBS::card_size),
- _hr->bottom(), from);
+ p2i(_hr->bottom()), p2i(from));
}
}
assert(contains_reference(from), "We just added it!");
@@ -602,8 +600,8 @@
if (G1TraceHeapRegionRememberedSet) {
gclog_or_tty->print("Coarsened entry in region [" PTR_FORMAT "...] "
"for region [" PTR_FORMAT "...] (" SIZE_FORMAT " coarse entries).\n",
- _hr->bottom(),
- max->hr()->bottom(),
+ p2i(_hr->bottom()),
+ p2i(max->hr()->bottom()),
_n_coarse_entries);
}
}
@@ -857,7 +855,7 @@
while (iter.has_next(card_index)) {
HeapWord* card_start =
G1CollectedHeap::heap()->bot_shared()->address_for_index(card_index);
- gclog_or_tty->print_cr(" Card " PTR_FORMAT, card_start);
+ gclog_or_tty->print_cr(" Card " PTR_FORMAT, p2i(card_start));
}
if (iter.n_yielded() != occupied()) {
gclog_or_tty->print_cr("Yielded disagrees with occupied:");
@@ -1152,8 +1150,8 @@
}
gclog_or_tty->print("Added card " PTR_FORMAT " to region [" PTR_FORMAT "...]"
" for ref " PTR_FORMAT ".\n",
- _recorded_cards[i], _recorded_regions[i]->bottom(),
- _recorded_oops[i]);
+ p2i(_recorded_cards[i]), p2i(_recorded_regions[i]->bottom()),
+ p2i(_recorded_oops[i]));
}
}
@@ -1240,7 +1238,7 @@
while (iter.has_next(card_index)) {
HeapWord* card_start =
G1CollectedHeap::heap()->bot_shared()->address_for_index(card_index);
- gclog_or_tty->print_cr(" Card " PTR_FORMAT ".", card_start);
+ gclog_or_tty->print_cr(" Card " PTR_FORMAT ".", p2i(card_start));
sum++;
}
guarantee(sum == 11 - 3 + 2048, "Failure");
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -27,8 +27,6 @@
#include "gc_implementation/g1/heapRegionRemSet.hpp"
#include "gc_implementation/g1/heapRegionSet.inline.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
uint FreeRegionList::_unrealistically_long_length = 0;
void HeapRegionSetBase::fill_in_ext_msg(hrs_ext_msg* msg, const char* message) {
@@ -84,7 +82,7 @@
void HeapRegionSetBase::print_on(outputStream* out, bool print_contents) {
out->cr();
- out->print_cr("Set: %s ("PTR_FORMAT")", name(), this);
+ out->print_cr("Set: %s ("PTR_FORMAT")", name(), p2i(this));
out->print_cr(" Region Assumptions");
out->print_cr(" humongous : %s", BOOL_TO_STR(regions_humongous()));
out->print_cr(" free : %s", BOOL_TO_STR(regions_free()));
@@ -106,7 +104,7 @@
}
void FreeRegionList::fill_in_ext_msg_extra(hrs_ext_msg* msg) {
- msg->append(" hd: "PTR_FORMAT" tl: "PTR_FORMAT, _head, _tail);
+ msg->append(" hd: "PTR_FORMAT" tl: "PTR_FORMAT, p2i(_head), p2i(_tail));
}
void FreeRegionList::remove_all() {
@@ -277,8 +275,8 @@
void FreeRegionList::print_on(outputStream* out, bool print_contents) {
HeapRegionSetBase::print_on(out, print_contents);
out->print_cr(" Linking");
- out->print_cr(" head : "PTR_FORMAT, _head);
- out->print_cr(" tail : "PTR_FORMAT, _tail);
+ out->print_cr(" head : "PTR_FORMAT, p2i(_head));
+ out->print_cr(" tail : "PTR_FORMAT, p2i(_tail));
if (print_contents) {
out->print_cr(" Contents");
@@ -306,7 +304,8 @@
count++;
guarantee(count < _unrealistically_long_length,
- hrs_err_msg("[%s] the calculated length: %u seems very long, is there maybe a cycle? curr: "PTR_FORMAT" prev0: "PTR_FORMAT" " "prev1: "PTR_FORMAT" length: %u", name(), count, curr, prev0, prev1, length()));
+ hrs_err_msg("[%s] the calculated length: %u seems very long, is there maybe a cycle? curr: "PTR_FORMAT" prev0: "PTR_FORMAT" " "prev1: "PTR_FORMAT" length: %u",
+ name(), count, p2i(curr), p2i(prev0), p2i(prev1), length()));
if (curr->next() != NULL) {
guarantee(curr->next()->prev() == curr, "Next or prev pointers messed up");
--- a/hotspot/src/share/vm/gc_implementation/g1/satbQueue.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/satbQueue.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -32,8 +32,6 @@
#include "runtime/thread.hpp"
#include "runtime/vmThread.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
void ObjPtrQueue::flush() {
// The buffer might contain refs into the CSet. We have to filter it
// first before we flush it, otherwise we might end up with an
@@ -182,7 +180,7 @@
void** buf, size_t index, size_t sz) {
gclog_or_tty->print_cr(" SATB BUFFER [%s] buf: "PTR_FORMAT" "
"index: "SIZE_FORMAT" sz: "SIZE_FORMAT,
- name, buf, index, sz);
+ name, p2i(buf), index, sz);
}
#endif // PRODUCT
--- a/hotspot/src/share/vm/gc_implementation/g1/survRateGroup.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/survRateGroup.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -29,8 +29,6 @@
#include "gc_implementation/g1/survRateGroup.hpp"
#include "memory/allocation.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
SurvRateGroup::SurvRateGroup(G1CollectorPolicy* g1p,
const char* name,
size_t summary_surv_rates_len) :
--- a/hotspot/src/share/vm/gc_implementation/parNew/parCardTableModRefBS.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parNew/parCardTableModRefBS.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -36,8 +36,6 @@
#include "runtime/virtualspace.hpp"
#include "runtime/vmThread.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
void CardTableModRefBS::non_clean_card_iterate_parallel_work(Space* sp, MemRegion mr,
OopsInGenClosure* cl,
CardTableRS* ct,
@@ -153,8 +151,7 @@
// result of the dirty card iteration below.
OrderAccess::storestore();
- // We do not call the non_clean_card_iterate_serial() version because
- // we want to clear the cards: clear_cl here does the work of finding
+ // We want to clear the cards: clear_cl here does the work of finding
// contiguous dirty ranges of cards to process and clear.
clear_cl.do_MemRegion(chunk_mr);
@@ -376,13 +373,14 @@
" does not exceed used.end() = " PTR_FORMAT ","
" yet last_chunk_index_to_check " INTPTR_FORMAT
" exceeds last_chunk_index " INTPTR_FORMAT,
- last_block, last_block + last_block_size,
- used.end(),
+ p2i(last_block), p2i(last_block + last_block_size),
+ p2i(used.end()),
last_chunk_index_to_check, last_chunk_index));
assert(sp->used_region().end() > used.end(),
err_msg("Expansion did not happen: "
"[" PTR_FORMAT "," PTR_FORMAT ") -> [" PTR_FORMAT "," PTR_FORMAT ")",
- sp->used_region().start(), sp->used_region().end(), used.start(), used.end()));
+ p2i(sp->used_region().start()), p2i(sp->used_region().end()),
+ p2i(used.start()), p2i(used.end())));
NOISY(tty->print_cr(" process_chunk_boundary: heap expanded; explicitly bounding last_chunk");)
last_chunk_index_to_check = last_chunk_index;
}
--- a/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -46,7 +46,6 @@
#include "memory/space.hpp"
#include "oops/objArrayOop.hpp"
#include "oops/oop.inline.hpp"
-#include "oops/oop.pcgc.inline.hpp"
#include "runtime/atomic.inline.hpp"
#include "runtime/handles.hpp"
#include "runtime/handles.inline.hpp"
@@ -56,8 +55,6 @@
#include "utilities/globalDefinitions.hpp"
#include "utilities/workgroup.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
#ifdef _MSC_VER
#pragma warning( push )
#pragma warning( disable:4355 ) // 'this' : used in base member initializer list
@@ -1213,7 +1210,7 @@
if (TraceScavenge) {
gclog_or_tty->print_cr("{%s %s " PTR_FORMAT " -> " PTR_FORMAT " (%d)}",
is_in_reserved(new_obj) ? "copying" : "tenuring",
- new_obj->klass()->internal_name(), (void *)old, (void *)new_obj, new_obj->size());
+ new_obj->klass()->internal_name(), p2i(old), p2i(new_obj), new_obj->size());
}
#endif
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -26,12 +26,11 @@
#include "gc_implementation/parallelScavenge/cardTableExtension.hpp"
#include "gc_implementation/parallelScavenge/gcTaskManager.hpp"
#include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
-#include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
+#include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
#include "gc_implementation/parallelScavenge/psScavenge.hpp"
#include "gc_implementation/parallelScavenge/psTasks.hpp"
#include "gc_implementation/parallelScavenge/psYoungGen.hpp"
#include "oops/oop.inline.hpp"
-#include "oops/oop.psgc.inline.hpp"
#include "runtime/prefetch.inline.hpp"
// Checks an individual oop for missing precise marks. Mark
@@ -291,7 +290,7 @@
Prefetch::write(p, interval);
oop m = oop(p);
assert(m->is_oop_or_null(), err_msg("Expected an oop or NULL for header field at " PTR_FORMAT, p2i(m)));
- m->push_contents(pm);
+ pm->push_contents(m);
p += m->size();
}
pm->drain_stacks_cond_depth();
@@ -299,7 +298,7 @@
while (p < to) {
oop m = oop(p);
assert(m->is_oop_or_null(), err_msg("Expected an oop or NULL for header field at " PTR_FORMAT, p2i(m)));
- m->push_contents(pm);
+ pm->push_contents(m);
p += m->size();
}
pm->drain_stacks_cond_depth();
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskManager.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskManager.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -32,8 +32,6 @@
#include "runtime/mutexLocker.hpp"
#include "runtime/orderAccess.inline.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
//
// GCTask
//
@@ -101,7 +99,7 @@
NOT_PRODUCT(
void GCTask::print(const char* message) const {
tty->print(INTPTR_FORMAT " <- " INTPTR_FORMAT "(%u) -> " INTPTR_FORMAT,
- newer(), this, affinity(), older());
+ p2i(newer()), p2i(this), affinity(), p2i(older()));
}
)
@@ -113,7 +111,7 @@
GCTaskQueue* result = new GCTaskQueue(false);
if (TraceGCTaskQueue) {
tty->print_cr("GCTaskQueue::create()"
- " returns " INTPTR_FORMAT, result);
+ " returns " INTPTR_FORMAT, p2i(result));
}
return result;
}
@@ -123,7 +121,7 @@
if (TraceGCTaskQueue) {
tty->print_cr("GCTaskQueue::create_on_c_heap()"
" returns " INTPTR_FORMAT,
- result);
+ p2i(result));
}
return result;
}
@@ -134,7 +132,7 @@
if (TraceGCTaskQueue) {
tty->print_cr("[" INTPTR_FORMAT "]"
" GCTaskQueue::GCTaskQueue() constructor",
- this);
+ p2i(this));
}
}
@@ -147,7 +145,7 @@
tty->print_cr("[" INTPTR_FORMAT "]"
" GCTaskQueue::destroy()"
" is_c_heap_obj: %s",
- that,
+ p2i(that),
that->is_c_heap_obj() ? "true" : "false");
}
// That instance may have been allocated as a CHeapObj,
@@ -173,7 +171,7 @@
tty->print_cr("[" INTPTR_FORMAT "]"
" GCTaskQueue::enqueue(task: "
INTPTR_FORMAT ")",
- this, task);
+ p2i(this), p2i(task));
print("before:");
}
assert(task != NULL, "shouldn't have null task");
@@ -200,7 +198,7 @@
tty->print_cr("[" INTPTR_FORMAT "]"
" GCTaskQueue::enqueue(list: "
INTPTR_FORMAT ")",
- this, list);
+ p2i(this), p2i(list));
print("before:");
list->print("list:");
}
@@ -234,14 +232,14 @@
GCTask* GCTaskQueue::dequeue() {
if (TraceGCTaskQueue) {
tty->print_cr("[" INTPTR_FORMAT "]"
- " GCTaskQueue::dequeue()", this);
+ " GCTaskQueue::dequeue()", p2i(this));
print("before:");
}
assert(!is_empty(), "shouldn't dequeue from empty list");
GCTask* result = remove();
assert(result != NULL, "shouldn't have NULL task");
if (TraceGCTaskQueue) {
- tty->print_cr(" return: " INTPTR_FORMAT, result);
+ tty->print_cr(" return: " INTPTR_FORMAT, p2i(result));
print("after:");
}
return result;
@@ -251,7 +249,7 @@
GCTask* GCTaskQueue::dequeue(uint affinity) {
if (TraceGCTaskQueue) {
tty->print_cr("[" INTPTR_FORMAT "]"
- " GCTaskQueue::dequeue(%u)", this, affinity);
+ " GCTaskQueue::dequeue(%u)", p2i(this), affinity);
print("before:");
}
assert(!is_empty(), "shouldn't dequeue from empty list");
@@ -275,7 +273,7 @@
result = remove();
}
if (TraceGCTaskQueue) {
- tty->print_cr(" return: " INTPTR_FORMAT, result);
+ tty->print_cr(" return: " INTPTR_FORMAT, p2i(result));
print("after:");
}
return result;
@@ -345,7 +343,7 @@
" remove_end: " INTPTR_FORMAT
" length: %d"
" %s",
- this, insert_end(), remove_end(), length(), message);
+ p2i(this), p2i(insert_end()), p2i(remove_end()), length(), message);
uint count = 0;
for (GCTask* element = insert_end();
element != NULL;
@@ -486,7 +484,7 @@
assert(!all_workers_active() || active_workers() == ParallelGCThreads,
err_msg("all_workers_active() is incorrect: "
- "active %d ParallelGCThreads %d", active_workers(),
+ "active %d ParallelGCThreads " UINTX_FORMAT, active_workers(),
ParallelGCThreads));
if (TraceDynamicGCThreads) {
gclog_or_tty->print_cr("GCTaskManager::set_active_gang(): "
@@ -598,7 +596,7 @@
MutexLockerEx ml(monitor(), Mutex::_no_safepoint_check_flag);
if (TraceGCTaskManager) {
tty->print_cr("GCTaskManager::add_task(" INTPTR_FORMAT " [%s])",
- task, GCTask::Kind::to_string(task->kind()));
+ p2i(task), GCTask::Kind::to_string(task->kind()));
}
queue()->enqueue(task);
// Notify with the lock held to avoid missed notifies.
@@ -678,7 +676,7 @@
assert(result != NULL, "shouldn't have null task");
if (TraceGCTaskManager) {
tty->print_cr("GCTaskManager::get_task(%u) => " INTPTR_FORMAT " [%s]",
- which, result, GCTask::Kind::to_string(result->kind()));
+ which, p2i(result), GCTask::Kind::to_string(result->kind()));
tty->print_cr(" %s", result->name());
}
if (!result->is_idle_task()) {
@@ -864,7 +862,7 @@
tty->print_cr("[" INTPTR_FORMAT "]"
" IdleGCTask:::do_it()"
" should_wait: %s",
- this, wait_for_task->should_wait() ? "true" : "false");
+ p2i(this), wait_for_task->should_wait() ? "true" : "false");
}
MutexLockerEx ml(manager->monitor(), Mutex::_no_safepoint_check_flag);
if (TraceDynamicGCThreads) {
@@ -878,7 +876,7 @@
tty->print_cr("[" INTPTR_FORMAT "]"
" IdleGCTask::do_it()"
" [" INTPTR_FORMAT "] (%s)->wait()",
- this, manager->monitor(), manager->monitor()->name());
+ p2i(this), p2i(manager->monitor()), manager->monitor()->name());
}
manager->monitor()->wait(Mutex::_no_safepoint_check_flag, 0);
}
@@ -890,7 +888,7 @@
tty->print_cr("[" INTPTR_FORMAT "]"
" IdleGCTask::do_it() returns"
" should_wait: %s",
- this, wait_for_task->should_wait() ? "true" : "false");
+ p2i(this), wait_for_task->should_wait() ? "true" : "false");
}
// Release monitor().
}
@@ -1000,7 +998,7 @@
tty->print_cr("[" INTPTR_FORMAT "]"
" WaitForBarrierGCTask::WaitForBarrierGCTask()"
" monitor: " INTPTR_FORMAT,
- this, monitor());
+ p2i(this), p2i(monitor()));
}
}
@@ -1011,9 +1009,9 @@
" WaitForBarrierGCTask::destroy()"
" is_c_heap_obj: %s"
" monitor: " INTPTR_FORMAT,
- that,
+ p2i(that),
that->is_c_heap_obj() ? "true" : "false",
- that->monitor());
+ p2i(that->monitor()));
}
that->destruct();
if (that->is_c_heap_obj()) {
@@ -1028,7 +1026,7 @@
tty->print_cr("[" INTPTR_FORMAT "]"
" WaitForBarrierGCTask::destruct()"
" monitor: " INTPTR_FORMAT,
- this, monitor());
+ p2i(this), p2i(monitor()));
}
this->BarrierGCTask::destruct();
// Clean up that should be in the destructor,
@@ -1044,7 +1042,7 @@
tty->print_cr("[" INTPTR_FORMAT "]"
" WaitForBarrierGCTask::do_it() waiting for idle"
" monitor: " INTPTR_FORMAT,
- this, monitor());
+ p2i(this), p2i(monitor()));
}
{
// First, wait for the barrier to arrive.
@@ -1062,7 +1060,7 @@
tty->print_cr("[" INTPTR_FORMAT "]"
" WaitForBarrierGCTask::do_it()"
" [" INTPTR_FORMAT "] (%s)->notify_all()",
- this, monitor(), monitor()->name());
+ p2i(this), p2i(monitor()), monitor()->name());
}
monitor()->notify_all();
// Release monitor().
@@ -1074,7 +1072,7 @@
tty->print_cr("[" INTPTR_FORMAT "]"
" WaitForBarrierGCTask::wait_for()"
" should_wait: %s",
- this, should_wait() ? "true" : "false");
+ p2i(this), should_wait() ? "true" : "false");
}
{
// Grab the lock and check again.
@@ -1084,7 +1082,7 @@
tty->print_cr("[" INTPTR_FORMAT "]"
" WaitForBarrierGCTask::wait_for()"
" [" INTPTR_FORMAT "] (%s)->wait()",
- this, monitor(), monitor()->name());
+ p2i(this), p2i(monitor()), monitor()->name());
}
monitor()->wait(Mutex::_no_safepoint_check_flag, 0);
}
@@ -1096,7 +1094,7 @@
tty->print_cr("[" INTPTR_FORMAT "]"
" WaitForBarrierGCTask::wait_for() returns"
" should_wait: %s",
- this, should_wait() ? "true" : "false");
+ p2i(this), should_wait() ? "true" : "false");
}
// Release monitor().
}
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskThread.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/gcTaskThread.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -34,8 +34,6 @@
#include "runtime/os.hpp"
#include "runtime/thread.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
GCTaskThread::GCTaskThread(GCTaskManager* manager,
uint which,
uint processor_id) :
@@ -79,7 +77,7 @@
tty->print_cr("GC-Thread %u entries: %d", id(), _time_stamp_index);
for(uint i=0; i<_time_stamp_index; i++) {
GCTaskTimeStamp* time_stamp = time_stamp_at(i);
- tty->print_cr("\t[ %s " INT64_FORMAT " " INT64_FORMAT " ]",
+ tty->print_cr("\t[ %s " JLONG_FORMAT " " JLONG_FORMAT " ]",
time_stamp->name(),
time_stamp->entry_time(),
time_stamp->exit_time());
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -203,17 +203,6 @@
return is_in_young((oop)addr);
}
-#ifdef ASSERT
-// Don't implement this by using is_in_young(). This method is used
-// in some cases to check that is_in_young() is correct.
-bool ParallelScavengeHeap::is_in_partial_collection(const void *p) {
- assert(is_in_reserved(p) || p == NULL,
- "Does not work if address is non-null and outside of the heap");
- // The order of the generations is old (low addr), young (high addr)
- return p >= old_gen()->reserved().end();
-}
-#endif
-
// There are two levels of allocation policy here.
//
// When an allocation request fails, the requesting thread must invoke a VM
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2013, 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
@@ -83,7 +83,7 @@
MarkSweep
};
- ParallelScavengeHeap::Name kind() const {
+ virtual Name kind() const {
return CollectedHeap::ParallelScavengeHeap;
}
@@ -141,10 +141,6 @@
bool is_in_reserved(const void* p) const;
-#ifdef ASSERT
- virtual bool is_in_partial_collection(const void *p);
-#endif
-
bool is_in_young(oop p); // reserved part
bool is_in_old(oop p); // reserved part
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -27,6 +27,7 @@
#include "code/codeCache.hpp"
#include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
#include "gc_implementation/parallelScavenge/pcTasks.hpp"
+#include "gc_implementation/parallelScavenge/psCompactionManager.inline.hpp"
#include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
#include "gc_implementation/shared/gcTimer.hpp"
#include "gc_implementation/shared/gcTraceTime.hpp"
@@ -34,7 +35,6 @@
#include "memory/universe.hpp"
#include "oops/objArrayKlass.inline.hpp"
#include "oops/oop.inline.hpp"
-#include "oops/oop.pcgc.inline.hpp"
#include "prims/jvmtiExport.hpp"
#include "runtime/fprofiler.hpp"
#include "runtime/jniHandles.hpp"
@@ -42,8 +42,6 @@
#include "runtime/vmThread.hpp"
#include "services/management.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
//
// ThreadRootsMarkingTask
//
@@ -221,12 +219,11 @@
int random_seed = 17;
do {
while (ParCompactionManager::steal_objarray(which, &random_seed, task)) {
- ObjArrayKlass* k = (ObjArrayKlass*)task.obj()->klass();
- k->oop_follow_contents(cm, task.obj(), task.index());
+ cm->follow_contents((objArrayOop)task.obj(), task.index());
cm->follow_marking_stacks();
}
while (ParCompactionManager::steal(which, &random_seed, obj)) {
- obj->follow_contents(cm);
+ cm->follow_contents(obj);
cm->follow_marking_stacks();
}
} while (!terminator()->offer_termination());
@@ -257,7 +254,7 @@
which_stack_index = which;
assert(manager->active_workers() == ParallelGCThreads,
err_msg("all_workers_active has been incorrectly set: "
- " active %d ParallelGCThreads %d", manager->active_workers(),
+ " active %d ParallelGCThreads " UINTX_FORMAT, manager->active_workers(),
ParallelGCThreads));
} else {
which_stack_index = ParCompactionManager::pop_recycled_stack_index();
@@ -269,7 +266,7 @@
gclog_or_tty->print_cr("StealRegionCompactionTask::do_it "
"region_stack_index %d region_stack = " PTR_FORMAT " "
" empty (%d) use all workers %d",
- which_stack_index, ParCompactionManager::region_list(which_stack_index),
+ which_stack_index, p2i(ParCompactionManager::region_list(which_stack_index)),
cm->region_stack()->is_empty(),
use_all_workers);
}
@@ -336,7 +333,7 @@
which_stack_index = which;
assert(manager->active_workers() == ParallelGCThreads,
err_msg("all_workers_active has been incorrectly set: "
- " active %d ParallelGCThreads %d", manager->active_workers(),
+ " active %d ParallelGCThreads " UINTX_FORMAT, manager->active_workers(),
ParallelGCThreads));
} else {
which_stack_index = stack_index();
@@ -370,7 +367,7 @@
void* old_region_stack = (void*) cm->region_stack();
int old_region_stack_index = cm->region_stack_index();
gclog_or_tty->print_cr("Pushing region stack " PTR_FORMAT "/%d",
- old_region_stack, old_region_stack_index);
+ p2i(old_region_stack), old_region_stack_index);
}
cm->set_region_stack(NULL);
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -35,8 +35,6 @@
#include <math.h>
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
PSAdaptiveSizePolicy::PSAdaptiveSizePolicy(size_t init_eden_size,
size_t init_promo_size,
size_t init_survivor_size,
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 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
@@ -28,12 +28,11 @@
#include "gc_implementation/parallelScavenge/objectStartArray.hpp"
#include "gc_implementation/parallelScavenge/parMarkBitMap.hpp"
#include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
-#include "gc_implementation/parallelScavenge/psCompactionManager.hpp"
+#include "gc_implementation/parallelScavenge/psCompactionManager.inline.hpp"
#include "gc_implementation/parallelScavenge/psOldGen.hpp"
#include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
#include "oops/objArrayKlass.inline.hpp"
#include "oops/oop.inline.hpp"
-#include "oops/oop.pcgc.inline.hpp"
#include "runtime/atomic.inline.hpp"
#include "utilities/stack.inline.hpp"
@@ -180,17 +179,16 @@
// Drain the overflow stack first, to allow stealing from the marking stack.
oop obj;
while (marking_stack()->pop_overflow(obj)) {
- obj->follow_contents(this);
+ follow_contents(obj);
}
while (marking_stack()->pop_local(obj)) {
- obj->follow_contents(this);
+ follow_contents(obj);
}
// Process ObjArrays one at a time to avoid marking stack bloat.
ObjArrayTask task;
if (_objarray_stack.pop_overflow(task) || _objarray_stack.pop_local(task)) {
- ObjArrayKlass* k = (ObjArrayKlass*)task.obj()->klass();
- k->oop_follow_contents(this, task.obj(), task.index());
+ follow_contents((objArrayOop)task.obj(), task.index());
}
} while (!marking_stacks_empty());
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 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
@@ -196,6 +196,10 @@
// Process tasks remaining on any stack
void drain_region_stacks();
+ void follow_contents(oop obj);
+ void follow_contents(objArrayOop array, int index);
+
+ void update_contents(oop obj);
};
inline ParCompactionManager* ParCompactionManager::manager_array(int index) {
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.inline.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.inline.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 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
@@ -27,6 +27,8 @@
#include "gc_implementation/parallelScavenge/psCompactionManager.hpp"
#include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
+#include "oops/objArrayKlass.inline.hpp"
+#include "oops/oop.pcgc.inline.hpp"
void ParCompactionManager::push_objarray(oop obj, size_t index)
{
@@ -46,4 +48,17 @@
region_stack()->push(index);
}
+inline void ParCompactionManager::follow_contents(oop obj) {
+ obj->follow_contents(this);
+}
+
+inline void ParCompactionManager::follow_contents(objArrayOop obj, int index) {
+ ObjArrayKlass* k = (ObjArrayKlass*)obj->klass();
+ k->oop_follow_contents(this, obj, index);
+}
+
+inline void ParCompactionManager::update_contents(oop obj) {
+ obj->update_contents(this);
+}
+
#endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSCOMPACTIONMANAGER_INLINE_HPP
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -54,8 +54,6 @@
#include "utilities/events.hpp"
#include "utilities/stack.inline.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
elapsedTimer PSMarkSweep::_accumulated_time;
jlong PSMarkSweep::_time_of_last_gc = 0;
CollectorCounters* PSMarkSweep::_counters = NULL;
@@ -670,7 +668,7 @@
jlong ret_val = now - _time_of_last_gc;
// XXX See note in genCollectedHeap::millis_since_last_gc().
if (ret_val < 0) {
- NOT_PRODUCT(warning("time warp: "INT64_FORMAT, ret_val);)
+ NOT_PRODUCT(warning("time warp: " JLONG_FORMAT, ret_val);)
return 0;
}
return ret_val;
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweepDecorator.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psMarkSweepDecorator.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2013, 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
@@ -303,7 +303,7 @@
while (q < end) {
// point all the oops to the new location
- size_t size = oop(q)->adjust_pointers();
+ size_t size = MarkSweep::adjust_pointers(oop(q));
q += size;
}
@@ -324,7 +324,7 @@
if (oop(q)->is_gc_marked()) {
// q is alive
// point all the oops to the new location
- size_t size = oop(q)->adjust_pointers();
+ size_t size = MarkSweep::adjust_pointers(oop(q));
debug_only(prev_q = q);
q += size;
} else {
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psOldGen.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psOldGen.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -33,8 +33,6 @@
#include "oops/oop.inline.hpp"
#include "runtime/java.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
inline const char* PSOldGen::select_name() {
return UseParallelOldGC ? "ParOldGen" : "PSOldGen";
}
@@ -440,9 +438,9 @@
capacity_in_bytes()/K, used_in_bytes()/K);
}
st->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")",
- virtual_space()->low_boundary(),
- virtual_space()->high(),
- virtual_space()->high_boundary());
+ p2i(virtual_space()->low_boundary()),
+ p2i(virtual_space()->high()),
+ p2i(virtual_space()->high_boundary()));
st->print(" object"); object_space()->print_on(st);
}
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -50,7 +50,6 @@
#include "memory/referenceProcessor.hpp"
#include "oops/methodData.hpp"
#include "oops/oop.inline.hpp"
-#include "oops/oop.pcgc.inline.hpp"
#include "runtime/atomic.inline.hpp"
#include "runtime/fprofiler.hpp"
#include "runtime/safepoint.hpp"
@@ -63,8 +62,6 @@
#include <math.h>
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
// All sizes are in HeapWords.
const size_t ParallelCompactData::Log2RegionSize = 16; // 64K words
const size_t ParallelCompactData::RegionSize = (size_t)1 << Log2RegionSize;
@@ -223,7 +220,7 @@
REGION_IDX_FORMAT " " PTR_FORMAT " "
REGION_DATA_FORMAT " " REGION_DATA_FORMAT " "
REGION_DATA_FORMAT " " REGION_IDX_FORMAT " %d",
- i, c->data_location(), dci, c->destination(),
+ i, p2i(c->data_location()), dci, p2i(c->destination()),
c->partial_obj_size(), c->live_obj_size(),
c->data_size(), c->source_region(), c->destination_count());
@@ -273,7 +270,7 @@
tty->print(SIZE_FORMAT_W(5) " " PTR_FORMAT " "
SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " "
SIZE_FORMAT_W(5) " " SIZE_FORMAT_W(5) " %d",
- i, c->destination(),
+ i, p2i(c->destination()),
c->partial_obj_size(), c->live_obj_size(),
c->data_size(), c->source_region(), c->destination_count());
if (newline) tty->cr();
@@ -634,13 +631,13 @@
const char * split_type = partial_obj_size == 0 ? "easy" : "hard";
gclog_or_tty->print_cr("%s split: src=" PTR_FORMAT " src_c=" SIZE_FORMAT
" pos=" SIZE_FORMAT,
- split_type, source_next, split_region,
+ split_type, p2i(source_next), split_region,
partial_obj_size);
gclog_or_tty->print_cr("%s split: dst=" PTR_FORMAT " dst_c=" SIZE_FORMAT
" tn=" PTR_FORMAT,
- split_type, split_destination,
+ split_type, p2i(split_destination),
addr_to_region_idx(split_destination),
- *target_next);
+ p2i(*target_next));
if (partial_obj_size != 0) {
HeapWord* const po_beg = split_info.destination();
@@ -649,8 +646,8 @@
"po_beg=" PTR_FORMAT " " SIZE_FORMAT " "
"po_end=" PTR_FORMAT " " SIZE_FORMAT,
split_type,
- po_beg, addr_to_region_idx(po_beg),
- po_end, addr_to_region_idx(po_end));
+ p2i(po_beg), addr_to_region_idx(po_beg),
+ p2i(po_end), addr_to_region_idx(po_end));
}
}
@@ -667,8 +664,8 @@
HeapWord* const source_next_val = source_next == NULL ? NULL : *source_next;
tty->print_cr("sb=" PTR_FORMAT " se=" PTR_FORMAT " sn=" PTR_FORMAT
"tb=" PTR_FORMAT " te=" PTR_FORMAT " tn=" PTR_FORMAT,
- source_beg, source_end, source_next_val,
- target_beg, target_end, *target_next);
+ p2i(source_beg), p2i(source_end), p2i(source_next_val),
+ p2i(target_beg), p2i(target_end), p2i(*target_next));
}
size_t cur_region = addr_to_region_idx(source_beg);
@@ -1133,9 +1130,9 @@
const size_t cur_deadwood = pointer_delta(dense_prefix, region_destination);
if (TraceParallelOldGCDensePrefix && Verbose) {
tty->print_cr("c#=" SIZE_FORMAT_W(4) " dst=" PTR_FORMAT " "
- "dp=" SIZE_FORMAT_W(8) " " "cdw=" SIZE_FORMAT_W(8),
- sd.region(cp), region_destination,
- dense_prefix, cur_deadwood);
+ "dp=" PTR_FORMAT " " "cdw=" SIZE_FORMAT_W(8),
+ sd.region(cp), p2i(region_destination),
+ p2i(dense_prefix), cur_deadwood);
}
if (cur_deadwood >= deadwood_goal) {
@@ -1201,7 +1198,7 @@
"d2l=" SIZE_FORMAT " d2l%%=%6.4f "
"d2r=" SIZE_FORMAT " l2r=" SIZE_FORMAT
" ratio=%10.8f",
- algorithm, addr, region_idx,
+ algorithm, p2i(addr), region_idx,
space_live,
dead_to_left, dead_to_left_pct,
dead_to_right, live_to_right,
@@ -1469,7 +1466,7 @@
{
if (TraceParallelOldGCSummaryPhase) {
tty->print_cr("fill_with_live_objects [" PTR_FORMAT " " PTR_FORMAT ") "
- SIZE_FORMAT, start, start + words, words);
+ SIZE_FORMAT, p2i(start), p2i(start + words), words);
}
ObjectStartArray* const start_array = _space_info[id].start_array();
@@ -1811,9 +1808,9 @@
tty->print_cr("id=%d cap=" SIZE_FORMAT " dp=" PTR_FORMAT " "
"dp_region=" SIZE_FORMAT " " "dp_count=" SIZE_FORMAT " "
"cr_count=" SIZE_FORMAT " " "nt=" PTR_FORMAT,
- id, space->capacity_in_words(), dense_prefix_end,
+ id, space->capacity_in_words(), p2i(dense_prefix_end),
dp_region, dp_words / region_size,
- cr_words / region_size, new_top);
+ cr_words / region_size, p2i(new_top));
}
}
@@ -1831,10 +1828,10 @@
SIZE_FORMAT "-" SIZE_FORMAT,
src_space_id, space_names[src_space_id],
dst_space_id, space_names[dst_space_id],
- src_beg, src_end,
+ p2i(src_beg), p2i(src_end),
_summary_data.addr_to_region_idx(src_beg),
_summary_data.addr_to_region_idx(src_end),
- dst_beg, dst_end,
+ p2i(dst_beg), p2i(dst_end),
_summary_data.addr_to_region_idx(dst_beg),
_summary_data.addr_to_region_idx(dst_end));
}
@@ -2234,8 +2231,8 @@
heap->trace_heap_after_gc(&_gc_tracer);
if (PrintGCTaskTimeStamps) {
- gclog_or_tty->print_cr("VM-Thread " INT64_FORMAT " " INT64_FORMAT " "
- INT64_FORMAT,
+ gclog_or_tty->print_cr("VM-Thread " JLONG_FORMAT " " JLONG_FORMAT " "
+ JLONG_FORMAT,
marking_start.ticks(), compaction_start.ticks(),
collection_exit.ticks());
gc_task_manager()->print_task_time_stamps();
@@ -2754,7 +2751,7 @@
const RegionData* const c = sd.region(cur_region);
if (!c->completed()) {
warning("region " SIZE_FORMAT " not filled: "
- "destination_count=" SIZE_FORMAT,
+ "destination_count=%u",
cur_region, c->destination_count());
issued_a_warning = true;
}
@@ -2764,7 +2761,7 @@
const RegionData* const c = sd.region(cur_region);
if (!c->available()) {
warning("region " SIZE_FORMAT " not empty: "
- "destination_count=" SIZE_FORMAT,
+ "destination_count=%u",
cur_region, c->destination_count());
issued_a_warning = true;
}
@@ -2776,6 +2773,11 @@
}
#endif // #ifdef ASSERT
+inline void UpdateOnlyClosure::do_addr(HeapWord* addr) {
+ _start_array->allocate_block(addr);
+ compaction_manager()->update_contents(oop(addr));
+}
+
// Update interior oops in the ranges of regions [beg_region, end_region).
void
PSParallelCompact::update_and_deadwood_in_dense_prefix(ParCompactionManager* cm,
@@ -2876,7 +2878,7 @@
if (start_array != NULL) {
start_array->allocate_block(addr);
}
- oop(addr)->update_contents(cm);
+ cm->update_contents(oop(addr));
assert(oop(addr)->is_oop_or_null(), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(oop(addr))));
}
}
@@ -3294,7 +3296,7 @@
jlong ret_val = now - _time_of_last_gc;
// XXX See note in genCollectedHeap::millis_since_last_gc().
if (ret_val < 0) {
- NOT_PRODUCT(warning("time warp: "INT64_FORMAT, ret_val);)
+ NOT_PRODUCT(warning("time warp: " JLONG_FORMAT, ret_val);)
return 0;
}
return ret_val;
@@ -3360,7 +3362,7 @@
}
oop moved_oop = (oop) destination();
- moved_oop->update_contents(compaction_manager());
+ compaction_manager()->update_contents(moved_oop);
assert(moved_oop->is_oop_or_null(), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(moved_oop)));
update_state(words);
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -1025,9 +1025,6 @@
bool maximum_heap_compaction,
ParallelOldTracer *gc_tracer);
- template <class T>
- static inline void follow_root(ParCompactionManager* cm, T* p);
-
// Compute the dense prefix for the designated space. This is an experimental
// implementation currently not used in production.
static HeapWord* compute_dense_prefix_via_density(const SpaceId id,
@@ -1336,23 +1333,6 @@
}
template <class T>
-inline void PSParallelCompact::follow_root(ParCompactionManager* cm, T* p) {
- assert(!Universe::heap()->is_in_reserved(p),
- "roots shouldn't be things within the heap");
-
- T heap_oop = oopDesc::load_heap_oop(p);
- if (!oopDesc::is_null(heap_oop)) {
- oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
- if (mark_bitmap()->is_unmarked(obj)) {
- if (mark_obj(obj)) {
- obj->follow_contents(cm);
- }
- }
- }
- cm->follow_marking_stacks();
-}
-
-template <class T>
inline void PSParallelCompact::mark_and_push(ParCompactionManager* cm, T* p) {
T heap_oop = oopDesc::load_heap_oop(p);
if (!oopDesc::is_null(heap_oop)) {
@@ -1524,12 +1504,6 @@
inline void do_addr(HeapWord* addr);
};
-inline void UpdateOnlyClosure::do_addr(HeapWord* addr)
-{
- _start_array->allocate_block(addr);
- oop(addr)->update_contents(compaction_manager());
-}
-
class FillClosure: public ParMarkBitMapClosure
{
public:
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -33,11 +33,8 @@
#include "memory/memRegion.hpp"
#include "memory/padded.inline.hpp"
#include "oops/oop.inline.hpp"
-#include "oops/oop.psgc.inline.hpp"
#include "utilities/stack.inline.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
PaddedEnd<PSPromotionManager>* PSPromotionManager::_manager_array = NULL;
OopStarTaskQueueSet* PSPromotionManager::_stack_array_depth = NULL;
PSOldGen* PSPromotionManager::_old_gen = NULL;
@@ -325,7 +322,7 @@
_promotion_failed_info.register_copy_failure(obj->size());
- obj->push_contents(this);
+ push_contents(obj);
// Save the mark if needed
PSScavenge::oop_promotion_failed(obj, obj_mark);
@@ -342,7 +339,7 @@
gclog_or_tty->print_cr("{%s %s " PTR_FORMAT " (%d)}",
"promotion-failure",
obj->klass()->internal_name(),
- (void *)obj, obj->size());
+ p2i(obj), obj->size());
}
#endif
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 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
@@ -212,6 +212,8 @@
template <class T> inline void claim_or_forward_depth(T* p);
TASKQUEUE_STATS_ONLY(inline void record_steal(StarTask& p);)
+
+ void push_contents(oop obj);
};
#endif // SHARE_VM_GC_IMPLEMENTATION_PARALLELSCAVENGE_PSPROMOTIONMANAGER_HPP
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.inline.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.inline.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2002, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 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
@@ -91,6 +91,9 @@
}
}
+inline void PSPromotionManager::push_contents(oop obj) {
+ obj->push_contents(this);
+}
//
// This method is pretty bulky. It would be nice to split it up
// into smaller submethods, but we need to be careful not to hurt
@@ -227,7 +230,7 @@
TASKQUEUE_STATS_ONLY(++_arrays_chunked; ++_masked_pushes);
} else {
// we'll just push its contents
- new_obj->push_contents(this);
+ push_contents(new_obj);
}
} else {
// We lost, someone else "owns" this object
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -46,7 +46,6 @@
#include "memory/referenceProcessor.hpp"
#include "memory/resourceArea.hpp"
#include "oops/oop.inline.hpp"
-#include "oops/oop.psgc.inline.hpp"
#include "runtime/biasedLocking.hpp"
#include "runtime/fprofiler.hpp"
#include "runtime/handles.inline.hpp"
@@ -56,8 +55,6 @@
#include "services/memoryService.hpp"
#include "utilities/stack.inline.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
HeapWord* PSScavenge::_to_space_top_before_gc = NULL;
int PSScavenge::_consecutive_skipped_scavenges = 0;
ReferenceProcessor* PSScavenge::_ref_processor = NULL;
@@ -551,8 +548,8 @@
if (PrintTenuringDistribution) {
gclog_or_tty->cr();
- gclog_or_tty->print_cr("Desired survivor size " SIZE_FORMAT " bytes, new threshold "
- UINTX_FORMAT " (max threshold " UINTX_FORMAT ")",
+ gclog_or_tty->print_cr("Desired survivor size " SIZE_FORMAT " bytes, new threshold %u"
+ " (max threshold " UINTX_FORMAT ")",
size_policy->calculated_survivor_size_in_bytes(),
_tenuring_threshold, MaxTenuringThreshold);
}
@@ -694,7 +691,7 @@
scavenge_exit.update();
if (PrintGCTaskTimeStamps) {
- tty->print_cr("VM-Thread " INT64_FORMAT " " INT64_FORMAT " " INT64_FORMAT,
+ tty->print_cr("VM-Thread " JLONG_FORMAT " " JLONG_FORMAT " " JLONG_FORMAT,
scavenge_entry.ticks(), scavenge_midpoint.ticks(),
scavenge_exit.ticks());
gc_task_manager()->print_task_time_stamps();
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psTasks.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psTasks.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -35,7 +35,6 @@
#include "memory/iterator.hpp"
#include "memory/universe.hpp"
#include "oops/oop.inline.hpp"
-#include "oops/oop.psgc.inline.hpp"
#include "runtime/fprofiler.hpp"
#include "runtime/thread.hpp"
#include "runtime/vmThread.hpp"
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psVirtualspace.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psVirtualspace.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -27,8 +27,6 @@
#include "runtime/os.hpp"
#include "runtime/virtualspace.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
// PSVirtualSpace
PSVirtualSpace::PSVirtualSpace(ReservedSpace rs, size_t alignment) :
@@ -218,22 +216,22 @@
void PSVirtualSpace::print() const {
gclog_or_tty->print_cr("virtual space [" PTR_FORMAT "]: alignment="
SIZE_FORMAT "K grows %s%s",
- this, alignment() / K, grows_up() ? "up" : "down",
+ p2i(this), alignment() / K, grows_up() ? "up" : "down",
special() ? " (pinned in memory)" : "");
gclog_or_tty->print_cr(" reserved=" SIZE_FORMAT "K"
" [" PTR_FORMAT "," PTR_FORMAT "]"
" committed=" SIZE_FORMAT "K"
" [" PTR_FORMAT "," PTR_FORMAT "]",
reserved_size() / K,
- reserved_low_addr(), reserved_high_addr(),
+ p2i(reserved_low_addr()), p2i(reserved_high_addr()),
committed_size() / K,
- committed_low_addr(), committed_high_addr());
+ p2i(committed_low_addr()), p2i(committed_high_addr()));
}
#endif // #ifndef PRODUCT
void PSVirtualSpace::print_space_boundaries_on(outputStream* st) const {
st->print_cr(" [" PTR_FORMAT ", " PTR_FORMAT ", " PTR_FORMAT ")",
- low_boundary(), high(), high_boundary());
+ p2i(low_boundary()), p2i(high()), p2i(high_boundary()));
}
PSVirtualSpaceHighToLow::PSVirtualSpaceHighToLow(ReservedSpace rs,
@@ -350,5 +348,5 @@
void
PSVirtualSpaceHighToLow::print_space_boundaries_on(outputStream* st) const {
st->print_cr(" (" PTR_FORMAT ", " PTR_FORMAT ", " PTR_FORMAT "]",
- high_boundary(), low(), low_boundary());
+ p2i(high_boundary()), p2i(low()), p2i(low_boundary()));
}
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psYoungGen.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psYoungGen.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -33,8 +33,6 @@
#include "oops/oop.inline.hpp"
#include "runtime/java.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
PSYoungGen::PSYoungGen(size_t initial_size,
size_t min_size,
size_t max_size) :
@@ -419,20 +417,22 @@
// s1
gclog_or_tty->print_cr("Current region: [" PTR_FORMAT ", " PTR_FORMAT ") "
"New region: [" PTR_FORMAT ", " PTR_FORMAT ")",
- s1->bottom(), s1->end(), s1MR.start(), s1MR.end());
+ p2i(s1->bottom()), p2i(s1->end()),
+ p2i(s1MR.start()), p2i(s1MR.end()));
gclog_or_tty->print_cr(" Mangle before: [" PTR_FORMAT ", "
PTR_FORMAT ") Mangle after: [" PTR_FORMAT ", " PTR_FORMAT ")",
- delta1_left.start(), delta1_left.end(), delta1_right.start(),
- delta1_right.end());
+ p2i(delta1_left.start()), p2i(delta1_left.end()),
+ p2i(delta1_right.start()), p2i(delta1_right.end()));
// s2
gclog_or_tty->print_cr("Current region: [" PTR_FORMAT ", " PTR_FORMAT ") "
"New region: [" PTR_FORMAT ", " PTR_FORMAT ")",
- s2->bottom(), s2->end(), s2MR.start(), s2MR.end());
+ p2i(s2->bottom()), p2i(s2->end()),
+ p2i(s2MR.start()), p2i(s2MR.end()));
gclog_or_tty->print_cr(" Mangle before: [" PTR_FORMAT ", "
PTR_FORMAT ") Mangle after: [" PTR_FORMAT ", " PTR_FORMAT ")",
- delta2_left.start(), delta2_left.end(), delta2_right.start(),
- delta2_right.end());
+ p2i(delta2_left.start()), p2i(delta2_left.end()),
+ p2i(delta2_right.start()), p2i(delta2_right.end()));
}
}
@@ -456,22 +456,22 @@
requested_eden_size, requested_survivor_size);
gclog_or_tty->print_cr(" eden: [" PTR_FORMAT ".." PTR_FORMAT ") "
SIZE_FORMAT,
- eden_space()->bottom(),
- eden_space()->end(),
+ p2i(eden_space()->bottom()),
+ p2i(eden_space()->end()),
pointer_delta(eden_space()->end(),
eden_space()->bottom(),
sizeof(char)));
gclog_or_tty->print_cr(" from: [" PTR_FORMAT ".." PTR_FORMAT ") "
SIZE_FORMAT,
- from_space()->bottom(),
- from_space()->end(),
+ p2i(from_space()->bottom()),
+ p2i(from_space()->end()),
pointer_delta(from_space()->end(),
from_space()->bottom(),
sizeof(char)));
gclog_or_tty->print_cr(" to: [" PTR_FORMAT ".." PTR_FORMAT ") "
SIZE_FORMAT,
- to_space()->bottom(),
- to_space()->end(),
+ p2i(to_space()->bottom()),
+ p2i(to_space()->end()),
pointer_delta( to_space()->end(),
to_space()->bottom(),
sizeof(char)));
@@ -572,18 +572,18 @@
if (PrintAdaptiveSizePolicy && Verbose) {
gclog_or_tty->print_cr(" [eden_start .. eden_end): "
"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
- eden_start,
- eden_end,
+ p2i(eden_start),
+ p2i(eden_end),
pointer_delta(eden_end, eden_start, sizeof(char)));
gclog_or_tty->print_cr(" [from_start .. from_end): "
"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
- from_start,
- from_end,
+ p2i(from_start),
+ p2i(from_end),
pointer_delta(from_end, from_start, sizeof(char)));
gclog_or_tty->print_cr(" [ to_start .. to_end): "
"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
- to_start,
- to_end,
+ p2i(to_start),
+ p2i(to_end),
pointer_delta( to_end, to_start, sizeof(char)));
}
} else {
@@ -629,18 +629,18 @@
if (PrintAdaptiveSizePolicy && Verbose) {
gclog_or_tty->print_cr(" [eden_start .. eden_end): "
"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
- eden_start,
- eden_end,
+ p2i(eden_start),
+ p2i(eden_end),
pointer_delta(eden_end, eden_start, sizeof(char)));
gclog_or_tty->print_cr(" [ to_start .. to_end): "
"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
- to_start,
- to_end,
+ p2i(to_start),
+ p2i(to_end),
pointer_delta( to_end, to_start, sizeof(char)));
gclog_or_tty->print_cr(" [from_start .. from_end): "
"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
- from_start,
- from_end,
+ p2i(from_start),
+ p2i(from_end),
pointer_delta(from_end, from_start, sizeof(char)));
}
}
--- a/hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -32,8 +32,6 @@
#include "oops/objArrayKlass.inline.hpp"
#include "oops/oop.inline.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
uint MarkSweep::_total_invocations = 0;
Stack<oop, mtGC> MarkSweep::_marking_stack;
@@ -64,18 +62,22 @@
MarkSweep::follow_cld_closure.do_cld(cld);
}
+void MarkSweep::follow_array(objArrayOop array, int index) {
+ ObjArrayKlass* k = (ObjArrayKlass*)array->klass();
+ k->oop_follow_contents(array, index);
+}
+
void MarkSweep::follow_stack() {
do {
while (!_marking_stack.is_empty()) {
oop obj = _marking_stack.pop();
assert (obj->is_gc_marked(), "p must be marked");
- obj->follow_contents();
+ follow_object(obj);
}
// Process ObjArrays one at a time to avoid marking stack bloat.
if (!_objarray_stack.is_empty()) {
ObjArrayTask task = _objarray_stack.pop();
- ObjArrayKlass* k = (ObjArrayKlass*)task.obj()->klass();
- k->oop_follow_contents(task.obj(), task.index());
+ follow_array(objArrayOop(task.obj()), task.index());
}
} while (!_marking_stack.is_empty() || !_objarray_stack.is_empty());
}
--- a/hotspot/src/share/vm/gc_implementation/shared/markSweep.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/shared/markSweep.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -160,10 +160,16 @@
static void follow_stack(); // Empty marking stack.
+ static void follow_object(oop obj);
+
+ static void follow_array(objArrayOop array, int index);
+
static void follow_klass(Klass* klass);
static void follow_class_loader(ClassLoaderData* cld);
+ static int adjust_pointers(oop obj);
+
static void preserve_mark(oop p, markOop mark);
// Save the mark word so it can be restored later
static void adjust_marks(); // Adjust the pointers in the preserved marks table
--- a/hotspot/src/share/vm/gc_implementation/shared/markSweep.inline.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/shared/markSweep.inline.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 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
@@ -58,6 +58,10 @@
MarkSweep::mark_and_push(&op);
}
+inline void MarkSweep::follow_object(oop obj) {
+ obj->follow_contents();
+}
+
template <class T> inline void MarkSweep::follow_root(T* p) {
assert(!Universe::heap()->is_in_reserved(p),
"roots shouldn't be things within the heap");
@@ -66,7 +70,7 @@
oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
if (!obj->mark()->is_marked()) {
mark_object(obj);
- obj->follow_contents();
+ follow_object(obj);
}
}
follow_stack();
@@ -90,6 +94,10 @@
_objarray_stack.push(task);
}
+inline int MarkSweep::adjust_pointers(oop obj) {
+ return obj->adjust_pointers();
+}
+
template <class T> inline void MarkSweep::adjust_pointer(T* p) {
T heap_oop = oopDesc::load_heap_oop(p);
if (!oopDesc::is_null(heap_oop)) {
--- a/hotspot/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -31,8 +31,6 @@
#include "runtime/atomic.inline.hpp"
#include "runtime/thread.inline.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
MutableNUMASpace::MutableNUMASpace(size_t alignment) : MutableSpace(alignment) {
_lgrp_spaces = new (ResourceObj::C_HEAP, mtGC) GrowableArray<LGRPSpace*>(0, true);
_page_size = os::vm_page_size();
@@ -973,7 +971,7 @@
break;
}
if (e != scan_end) {
- assert(e < scan_end, err_msg("e: " PTR_FORMAT " scan_end: " PTR_FORMAT, e, scan_end));
+ assert(e < scan_end, err_msg("e: " PTR_FORMAT " scan_end: " PTR_FORMAT, p2i(e), p2i(scan_end)));
if ((page_expected.size != page_size || page_expected.lgrp_id != lgrp_id())
&& page_expected.size != 0) {
--- a/hotspot/src/share/vm/gc_implementation/shared/mutableSpace.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/shared/mutableSpace.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -33,8 +33,6 @@
#include "runtime/thread.hpp"
#endif // INCLUDE_ALL_GCS
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
MutableSpace::MutableSpace(size_t alignment): ImmutableSpace(), _top(NULL), _alignment(alignment) {
assert(MutableSpace::alignment() % os::vm_page_size() == 0,
"Space should be aligned");
@@ -253,7 +251,7 @@
void MutableSpace::print_on(outputStream* st) const {
MutableSpace::print_short_on(st);
st->print_cr(" [" INTPTR_FORMAT "," INTPTR_FORMAT "," INTPTR_FORMAT ")",
- bottom(), top(), end());
+ p2i(bottom()), p2i(top()), p2i(end()));
}
void MutableSpace::verify() {
--- a/hotspot/src/share/vm/gc_implementation/shared/spaceDecorator.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_implementation/shared/spaceDecorator.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -27,8 +27,6 @@
#include "memory/space.inline.hpp"
#include "utilities/copy.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
// Catch-all file for utility classes
#ifndef PRODUCT
@@ -86,7 +84,7 @@
assert(ZapUnusedHeapArea, "Mangling should not be in use");
#ifdef ASSERT
if(TraceZapUnusedHeapArea) {
- gclog_or_tty->print("Mangling [" PTR_FORMAT " to " PTR_FORMAT ")", mr.start(), mr.end());
+ gclog_or_tty->print("Mangling [" PTR_FORMAT " to " PTR_FORMAT ")", p2i(mr.start()), p2i(mr.end()));
}
Copy::fill_to_words(mr.start(), mr.word_size(), badHeapWord);
if(TraceZapUnusedHeapArea) {
--- a/hotspot/src/share/vm/gc_interface/collectedHeap.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/gc_interface/collectedHeap.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -185,8 +185,6 @@
public:
enum Name {
- Abstract,
- SharedHeap,
GenCollectedHeap,
ParallelScavengeHeap,
G1CollectedHeap
@@ -196,7 +194,7 @@
return _filler_array_max_size;
}
- virtual CollectedHeap::Name kind() const { return CollectedHeap::Abstract; }
+ virtual Name kind() const = 0;
/**
* Returns JNI error code JNI_ENOMEM if memory could not be allocated,
@@ -291,12 +289,6 @@
return p == NULL || is_in_closed_subset(p);
}
-#ifdef ASSERT
- // Returns true if "p" is in the part of the
- // heap being collected.
- virtual bool is_in_partial_collection(const void *p) = 0;
-#endif
-
// An object is scavengable if its location may move during a scavenge.
// (A scavenge is a GC which is not a full GC.)
virtual bool is_scavengable(const void *p) = 0;
--- a/hotspot/src/share/vm/memory/cardTableModRefBS.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/cardTableModRefBS.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -470,13 +470,9 @@
fatal("Parallel gc not supported here.");
#endif // INCLUDE_ALL_GCS
} else {
- // We do not call the non_clean_card_iterate_serial() version below because
- // we want to clear the cards (which non_clean_card_iterate_serial() does not
- // do for us): clear_cl here does the work of finding contiguous dirty ranges
- // of cards to process and clear.
+ // clear_cl finds contiguous dirty ranges of cards to process and clear.
- DirtyCardToOopClosure* dcto_cl = sp->new_dcto_cl(cl, precision(),
- cl->gen_boundary());
+ DirtyCardToOopClosure* dcto_cl = sp->new_dcto_cl(cl, precision(), cl->gen_boundary());
ClearNoncleanCardWrapper clear_cl(dcto_cl, ct);
clear_cl.do_MemRegion(mr);
@@ -484,46 +480,6 @@
}
}
-// The iterator itself is not MT-aware, but
-// MT-aware callers and closures can use this to
-// accomplish dirty card iteration in parallel. The
-// iterator itself does not clear the dirty cards, or
-// change their values in any manner.
-void CardTableModRefBS::non_clean_card_iterate_serial(MemRegion mr,
- MemRegionClosure* cl) {
- bool is_par = (SharedHeap::heap()->n_par_threads() > 0);
- assert(!is_par ||
- (SharedHeap::heap()->n_par_threads() ==
- SharedHeap::heap()->workers()->active_workers()), "Mismatch");
- for (int i = 0; i < _cur_covered_regions; i++) {
- MemRegion mri = mr.intersection(_covered[i]);
- if (mri.word_size() > 0) {
- jbyte* cur_entry = byte_for(mri.last());
- jbyte* limit = byte_for(mri.start());
- while (cur_entry >= limit) {
- jbyte* next_entry = cur_entry - 1;
- if (*cur_entry != clean_card) {
- size_t non_clean_cards = 1;
- // Should the next card be included in this range of dirty cards.
- while (next_entry >= limit && *next_entry != clean_card) {
- non_clean_cards++;
- cur_entry = next_entry;
- next_entry--;
- }
- // The memory region may not be on a card boundary. So that
- // objects beyond the end of the region are not processed, make
- // cur_cards precise with regard to the end of the memory region.
- MemRegion cur_cards(addr_for(cur_entry),
- non_clean_cards * card_size_in_words);
- MemRegion dirty_region = cur_cards.intersection(mri);
- cl->do_MemRegion(dirty_region);
- }
- cur_entry = next_entry;
- }
- }
- }
-}
-
void CardTableModRefBS::dirty_MemRegion(MemRegion mr) {
assert((HeapWord*)align_size_down((uintptr_t)mr.start(), HeapWordSize) == mr.start(), "Unaligned start");
assert((HeapWord*)align_size_up ((uintptr_t)mr.end(), HeapWordSize) == mr.end(), "Unaligned end" );
--- a/hotspot/src/share/vm/memory/cardTableModRefBS.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/cardTableModRefBS.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -37,7 +37,7 @@
// the head of "o" is dirtied, not necessarily the card containing the
// modified field itself. For object arrays, however, the barrier *is*
// precise; only the card containing the modified element is dirtied.
-// Any MemRegionClosures used to scan dirty cards should take these
+// Closures used to scan dirty cards should take these
// considerations into account.
class Generation;
@@ -176,16 +176,7 @@
// Iterate over the portion of the card-table which covers the given
// region mr in the given space and apply cl to any dirty sub-regions
- // of mr. Dirty cards are _not_ cleared by the iterator method itself,
- // but closures may arrange to do so on their own should they so wish.
- void non_clean_card_iterate_serial(MemRegion mr, MemRegionClosure* cl);
-
- // A variant of the above that will operate in a parallel mode if
- // worker threads are available, and clear the dirty cards as it
- // processes them.
- // XXX ??? MemRegionClosure above vs OopsInGenClosure below XXX
- // XXX some new_dcto_cl's take OopClosure's, plus as above there are
- // some MemRegionClosures. Clean this up everywhere. XXX
+ // of mr. Clears the dirty cards as they are processed.
void non_clean_card_iterate_possibly_parallel(Space* sp, MemRegion mr,
OopsInGenClosure* cl, CardTableRS* ct);
@@ -379,24 +370,6 @@
// *** Card-table-RemSet-specific things.
- // Invoke "cl.do_MemRegion" on a set of MemRegions that collectively
- // includes all the modified cards (expressing each card as a
- // MemRegion). Thus, several modified cards may be lumped into one
- // region. The regions are non-overlapping, and are visited in
- // *decreasing* address order. (This order aids with imprecise card
- // marking, where a dirty card may cause scanning, and summarization
- // marking, of objects that extend onto subsequent cards.)
- void mod_card_iterate(MemRegionClosure* cl) {
- non_clean_card_iterate_serial(_whole_heap, cl);
- }
-
- // Like the "mod_cards_iterate" above, except only invokes the closure
- // for cards within the MemRegion "mr" (which is required to be
- // card-aligned and sized.)
- void mod_card_iterate(MemRegion mr, MemRegionClosure* cl) {
- non_clean_card_iterate_serial(mr, cl);
- }
-
static uintx ct_max_alignment_constraint();
// Apply closure "cl" to the dirty cards containing some part of
--- a/hotspot/src/share/vm/memory/collectorPolicy.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/collectorPolicy.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -190,11 +190,12 @@
_min_young_size(0),
_initial_young_size(0),
_max_young_size(0),
- _gen_alignment(0),
_min_old_size(0),
_initial_old_size(0),
_max_old_size(0),
- _generations(NULL)
+ _gen_alignment(0),
+ _young_gen_spec(NULL),
+ _old_gen_spec(NULL)
{}
size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) {
@@ -912,9 +913,8 @@
}
void MarkSweepPolicy::initialize_generations() {
- _generations = NEW_C_HEAP_ARRAY(GenerationSpecPtr, number_of_generations(), mtGC);
- _generations[0] = new GenerationSpec(Generation::DefNew, _initial_young_size, _max_young_size);
- _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_old_size, _max_old_size);
+ _young_gen_spec = new GenerationSpec(Generation::DefNew, _initial_young_size, _max_young_size, _gen_alignment);
+ _old_gen_spec = new GenerationSpec(Generation::MarkSweepCompact, _initial_old_size, _max_old_size, _gen_alignment);
}
void MarkSweepPolicy::initialize_gc_policy_counters() {
--- a/hotspot/src/share/vm/memory/collectorPolicy.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/collectorPolicy.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2013, 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
@@ -208,7 +208,8 @@
};
class GenCollectorPolicy : public CollectorPolicy {
-friend class TestGenCollectorPolicy;
+ friend class TestGenCollectorPolicy;
+ friend class VMStructs;
protected:
size_t _min_young_size;
size_t _initial_young_size;
@@ -221,7 +222,8 @@
// time. When using large pages they can differ.
size_t _gen_alignment;
- GenerationSpec **_generations;
+ GenerationSpec* _young_gen_spec;
+ GenerationSpec* _old_gen_spec;
// Return true if an allocation should be attempted in the older generation
// if it fails in the younger generation. Return false, otherwise.
@@ -261,9 +263,14 @@
int number_of_generations() { return 2; }
- virtual GenerationSpec **generations() {
- assert(_generations != NULL, "Sanity check");
- return _generations;
+ GenerationSpec* young_gen_spec() const {
+ assert(_young_gen_spec != NULL, "_young_gen_spec should have been initialized");
+ return _young_gen_spec;
+ }
+
+ GenerationSpec* old_gen_spec() const {
+ assert(_old_gen_spec != NULL, "_old_gen_spec should have been initialized");
+ return _old_gen_spec;
}
virtual GenCollectorPolicy* as_generation_policy() { return this; }
--- a/hotspot/src/share/vm/memory/defNewGeneration.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/defNewGeneration.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -49,8 +49,6 @@
#include "utilities/globalDefinitions.hpp"
#include "utilities/stack.inline.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
//
// DefNewGeneration functions.
@@ -137,7 +135,7 @@
if (TraceScavenge) {
ResourceMark rm;
gclog_or_tty->print_cr("KlassScanClosure::do_klass " PTR_FORMAT ", %s, dirty: %s",
- klass,
+ p2i(klass),
klass->external_name(),
klass->has_modified_oops() ? "true" : "false");
}
@@ -380,7 +378,7 @@
int next_level = level() + 1;
GenCollectedHeap* gch = GenCollectedHeap::heap();
- assert(next_level < gch->_n_gens,
+ assert(next_level < gch->n_gens(),
"DefNewGeneration cannot be an oldest gen");
Generation* old_gen = gch->old_gen();
--- a/hotspot/src/share/vm/memory/genCollectedHeap.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/genCollectedHeap.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -78,7 +78,7 @@
};
GenCollectedHeap::GenCollectedHeap(GenCollectorPolicy *policy) :
- SharedHeap(policy),
+ SharedHeap(),
_rem_set(NULL),
_gen_policy(policy),
_process_strong_tasks(new SubTasksDone(GCH_PS_NumElements)),
@@ -90,7 +90,6 @@
jint GenCollectedHeap::initialize() {
CollectedHeap::pre_initialize();
- int i;
_n_gens = gen_policy()->number_of_generations();
assert(_n_gens == 2, "There is no support for more than two generations");
@@ -101,16 +100,6 @@
// HeapWordSize).
guarantee(HeapWordSize == wordSize, "HeapWordSize must equal wordSize");
- // The heap must be at least as aligned as generations.
- size_t gen_alignment = Generation::GenGrain;
-
- _gen_specs = gen_policy()->generations();
-
- // Make sure the sizes are all aligned.
- for (i = 0; i < _n_gens; i++) {
- _gen_specs[i]->align(gen_alignment);
- }
-
// Allocate space for the heap.
char* heap_address;
@@ -133,12 +122,12 @@
_gch = this;
- ReservedSpace young_rs = heap_rs.first_part(_gen_specs[0]->max_size(), false, false);
- _young_gen = _gen_specs[0]->init(young_rs, 0, rem_set());
- heap_rs = heap_rs.last_part(_gen_specs[0]->max_size());
+ ReservedSpace young_rs = heap_rs.first_part(gen_policy()->young_gen_spec()->max_size(), false, false);
+ _young_gen = gen_policy()->young_gen_spec()->init(young_rs, 0, rem_set());
+ heap_rs = heap_rs.last_part(gen_policy()->young_gen_spec()->max_size());
- ReservedSpace old_rs = heap_rs.first_part(_gen_specs[1]->max_size(), false, false);
- _old_gen = _gen_specs[1]->init(old_rs, 1, rem_set());
+ ReservedSpace old_rs = heap_rs.first_part(gen_policy()->old_gen_spec()->max_size(), false, false);
+ _old_gen = gen_policy()->old_gen_spec()->init(old_rs, 1, rem_set());
clear_incremental_collection_failed();
#if INCLUDE_ALL_GCS
@@ -155,21 +144,18 @@
char* GenCollectedHeap::allocate(size_t alignment,
ReservedSpace* heap_rs){
- const char overflow_msg[] = "The size of the object heap + VM data exceeds "
- "the maximum representable size";
-
// Now figure out the total size.
- size_t total_reserved = 0;
- const size_t pageSize = UseLargePages ?
- os::large_page_size() : os::vm_page_size();
-
+ const size_t pageSize = UseLargePages ? os::large_page_size() : os::vm_page_size();
assert(alignment % pageSize == 0, "Must be");
- for (int i = 0; i < _n_gens; i++) {
- total_reserved += _gen_specs[i]->max_size();
- if (total_reserved < _gen_specs[i]->max_size()) {
- vm_exit_during_initialization(overflow_msg);
- }
+ GenerationSpec* young_spec = gen_policy()->young_gen_spec();
+ GenerationSpec* old_spec = gen_policy()->old_gen_spec();
+
+ // Check for overflow.
+ size_t total_reserved = young_spec->max_size() + old_spec->max_size();
+ if (total_reserved < young_spec->max_size()) {
+ vm_exit_during_initialization("The size of the object heap + VM data exceeds "
+ "the maximum representable size");
}
assert(total_reserved % alignment == 0,
err_msg("Gen size; total_reserved=" SIZE_FORMAT ", alignment="
@@ -586,7 +572,7 @@
class AssertNonScavengableClosure: public OopClosure {
public:
virtual void do_oop(oop* p) {
- assert(!Universe::heap()->is_in_partial_collection(*p),
+ assert(!GenCollectedHeap::heap()->is_in_partial_collection(*p),
"Referent should not be scavengable."); }
virtual void do_oop(narrowOop* p) { ShouldNotReachHere(); }
};
@@ -603,7 +589,7 @@
StrongRootsScope srs(this, activate_scope);
// General roots.
- assert(_strong_roots_parity != 0, "must have called prologue code");
+ assert(Threads::thread_claim_parity() != 0, "must have called prologue code");
assert(code_roots != NULL, "code root closure should always be set");
// _n_termination for _process_strong_tasks should be set up stream
// in a method not running in a GC worker. Otherwise the GC worker
@@ -1351,7 +1337,7 @@
// back a time later than 'now'.
jlong retVal = now - tolgc_cl.time();
if (retVal < 0) {
- NOT_PRODUCT(warning("time warp: "INT64_FORMAT, (int64_t) retVal);)
+ NOT_PRODUCT(warning("time warp: " JLONG_FORMAT, retVal);)
return 0;
}
return retVal;
--- a/hotspot/src/share/vm/memory/genCollectedHeap.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/genCollectedHeap.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -67,8 +67,6 @@
Generation* _young_gen;
Generation* _old_gen;
- GenerationSpec** _gen_specs;
-
// The singleton Gen Remembered Set.
GenRemSet* _rem_set;
@@ -141,12 +139,12 @@
// Initialize ("weak") refs processing support
virtual void ref_processing_init();
- virtual CollectedHeap::Name kind() const {
+ virtual Name kind() const {
return CollectedHeap::GenCollectedHeap;
}
- Generation* young_gen() { return _young_gen; }
- Generation* old_gen() { return _old_gen; }
+ Generation* young_gen() const { return _young_gen; }
+ Generation* old_gen() const { return _old_gen; }
// The generational collector policy.
GenCollectorPolicy* gen_policy() const { return _gen_policy; }
@@ -217,7 +215,7 @@
bool is_in_young(oop p);
#ifdef ASSERT
- virtual bool is_in_partial_collection(const void* p);
+ bool is_in_partial_collection(const void* p);
#endif
virtual bool is_scavengable(const void* addr) {
--- a/hotspot/src/share/vm/memory/generation.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/generation.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -42,8 +42,6 @@
#include "utilities/copy.hpp"
#include "utilities/events.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
Generation::Generation(ReservedSpace rs, size_t initial_size, int level) :
_level(level),
_ref_processor(NULL) {
@@ -63,8 +61,8 @@
GenerationSpec* Generation::spec() {
GenCollectedHeap* gch = GenCollectedHeap::heap();
- assert(0 <= level() && level() < gch->_n_gens, "Bad gen level");
- return gch->_gen_specs[level()];
+ assert(level() == 0 || level() == 1, "Bad gen level");
+ return level() == 0 ? gch->gen_policy()->young_gen_spec() : gch->gen_policy()->old_gen_spec();
}
size_t Generation::max_capacity() const {
@@ -103,9 +101,9 @@
st->print(" total " SIZE_FORMAT "K, used " SIZE_FORMAT "K",
capacity()/K, used()/K);
st->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")",
- _virtual_space.low_boundary(),
- _virtual_space.high(),
- _virtual_space.high_boundary());
+ p2i(_virtual_space.low_boundary()),
+ p2i(_virtual_space.high()),
+ p2i(_virtual_space.high_boundary()));
}
void Generation::print_summary_info() { print_summary_info_on(tty); }
--- a/hotspot/src/share/vm/memory/generation.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/generation.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -399,7 +399,7 @@
// have to guard against non-monotonicity.
NOT_PRODUCT(
if (now < _time_of_last_gc) {
- warning("time warp: "INT64_FORMAT" to "INT64_FORMAT, (int64_t)_time_of_last_gc, (int64_t)now);
+ warning("time warp: " JLONG_FORMAT " to " JLONG_FORMAT, _time_of_last_gc, now);
}
)
return _time_of_last_gc;
--- a/hotspot/src/share/vm/memory/generationSpec.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/generationSpec.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2012, 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
@@ -39,11 +39,11 @@
size_t _max_size;
public:
- GenerationSpec(Generation::Name name, size_t init_size, size_t max_size) {
- _name = name;
- _init_size = init_size;
- _max_size = max_size;
- }
+ GenerationSpec(Generation::Name name, size_t init_size, size_t max_size, size_t alignment) :
+ _name(name),
+ _init_size(align_size_up(init_size, alignment)),
+ _max_size(align_size_up(max_size, alignment))
+ { }
Generation* init(ReservedSpace rs, int level, GenRemSet* remset);
@@ -53,12 +53,6 @@
void set_init_size(size_t size) { _init_size = size; }
size_t max_size() const { return _max_size; }
void set_max_size(size_t size) { _max_size = size; }
-
- // Alignment
- void align(size_t alignment) {
- set_init_size(align_size_up(init_size(), alignment));
- set_max_size(align_size_up(max_size(), alignment));
- }
};
typedef GenerationSpec* GenerationSpecPtr;
--- a/hotspot/src/share/vm/memory/heapInspection.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/heapInspection.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -38,8 +38,6 @@
#include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
#endif // INCLUDE_ALL_GCS
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
// HeapInspection
inline KlassInfoEntry::~KlassInfoEntry() {
@@ -100,8 +98,8 @@
// simplify the formatting (ILP32 vs LP64) - always cast the numbers to 64-bit
st->print_cr(INT64_FORMAT_W(13) " " UINT64_FORMAT_W(13) " %s",
- (jlong) _instance_count,
- (julong) _instance_words * HeapWordSize,
+ (int64_t)_instance_count,
+ (uint64_t)_instance_words * HeapWordSize,
name());
}
@@ -240,8 +238,8 @@
void KlassInfoHisto::print_elements(outputStream* st) const {
// simplify the formatting (ILP32 vs LP64) - store the sum in 64-bit
- jlong total = 0;
- julong totalw = 0;
+ int64_t total = 0;
+ uint64_t totalw = 0;
for(int i=0; i < elements()->length(); i++) {
st->print("%4d: ", i+1);
elements()->at(i)->print_on(st);
@@ -451,7 +449,7 @@
if (loader_oop == NULL) {
st->print("null");
} else {
- st->print(INTPTR_FORMAT, klass->class_loader_data());
+ st->print(INTPTR_FORMAT, p2i(klass->class_loader_data()));
}
}
@@ -557,13 +555,13 @@
}
if (csv_format) {
- st->print("%d,%d", e->index(), super_index);
+ st->print("%ld,%d", e->index(), super_index);
for (int c=0; c<KlassSizeStats::_num_columns; c++) {
if (selected[c]) {st->print("," JULONG_FORMAT, col_table[c]);}
}
st->print(",%s",e->name());
} else {
- st->print("%5d %5d", e->index(), super_index);
+ st->print("%5ld %5d", e->index(), super_index);
for (int c=0; c<KlassSizeStats::_num_columns; c++) {
if (selected[c]) {print_julong(st, width_table[c], col_table[c]);}
}
--- a/hotspot/src/share/vm/memory/metachunk.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/metachunk.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -28,8 +28,6 @@
#include "utilities/copy.hpp"
#include "utilities/debug.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
class VirtualSpaceNode;
const size_t metadata_chunk_initialize = 0xf7f7f7f7;
@@ -92,7 +90,7 @@
st->print_cr("Metachunk:"
" bottom " PTR_FORMAT " top " PTR_FORMAT
" end " PTR_FORMAT " size " SIZE_FORMAT,
- bottom(), _top, end(), word_size());
+ p2i(bottom()), p2i(_top), p2i(end()), word_size());
if (Verbose) {
st->print_cr(" used " SIZE_FORMAT " free " SIZE_FORMAT,
used_word_size(), free_word_size());
--- a/hotspot/src/share/vm/memory/metaspace.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/metaspace.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -49,8 +49,6 @@
#include "utilities/debug.hpp"
#include "utilities/macros.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
typedef BinaryTreeDictionary<Metablock, FreeList<Metablock> > BlockTreeDictionary;
typedef BinaryTreeDictionary<Metachunk, FreeList<Metachunk> > ChunkTreeDictionary;
@@ -346,7 +344,7 @@
void inc_container_count();
void dec_container_count();
#ifdef ASSERT
- uint container_count_slow();
+ uintx container_count_slow();
void verify_container_count();
#endif
@@ -388,7 +386,7 @@
#define assert_is_ptr_aligned(ptr, alignment) \
assert(is_ptr_aligned(ptr, alignment), \
err_msg(PTR_FORMAT " is not aligned to " \
- SIZE_FORMAT, ptr, alignment))
+ SIZE_FORMAT, p2i(ptr), alignment))
#define assert_is_size_aligned(size, alignment) \
assert(is_size_aligned(size, alignment), \
@@ -463,8 +461,8 @@
}
#ifdef ASSERT
-uint VirtualSpaceNode::container_count_slow() {
- uint count = 0;
+uintx VirtualSpaceNode::container_count_slow() {
+ uintx count = 0;
Metachunk* chunk = first_chunk();
Metachunk* invalid_chunk = (Metachunk*) top();
while (chunk < invalid_chunk ) {
@@ -798,10 +796,7 @@
void VirtualSpaceNode::inc_container_count() {
assert_lock_strong(SpaceManager::expand_lock());
_container_count++;
- assert(_container_count == container_count_slow(),
- err_msg("Inconsistency in container_count _container_count " SIZE_FORMAT
- " container_count_slow() " SIZE_FORMAT,
- _container_count, container_count_slow()));
+ DEBUG_ONLY(verify_container_count();)
}
void VirtualSpaceNode::dec_container_count() {
@@ -812,8 +807,8 @@
#ifdef ASSERT
void VirtualSpaceNode::verify_container_count() {
assert(_container_count == container_count_slow(),
- err_msg("Inconsistency in container_count _container_count " SIZE_FORMAT
- " container_count_slow() " SIZE_FORMAT, _container_count, container_count_slow()));
+ err_msg("Inconsistency in container_count _container_count " UINTX_FORMAT
+ " container_count_slow() " UINTX_FORMAT, _container_count, container_count_slow()));
}
#endif
@@ -916,7 +911,7 @@
if (!is_available(chunk_word_size)) {
if (TraceMetadataChunkAllocation) {
- gclog_or_tty->print("VirtualSpaceNode::take_from_committed() not available %d words ", chunk_word_size);
+ gclog_or_tty->print("VirtualSpaceNode::take_from_committed() not available " SIZE_FORMAT " words ", chunk_word_size);
// Dump some information about the virtual space that is nearly full
print_on(gclog_or_tty);
}
@@ -989,7 +984,7 @@
assert(reserved()->start() == (HeapWord*) _rs.base(),
err_msg("Reserved start was not set properly " PTR_FORMAT
- " != " PTR_FORMAT, reserved()->start(), _rs.base()));
+ " != " PTR_FORMAT, p2i(reserved()->start()), p2i(_rs.base())));
assert(reserved()->word_size() == _rs.size() / BytesPerWord,
err_msg("Reserved size was not set properly " SIZE_FORMAT
" != " SIZE_FORMAT, reserved()->word_size(),
@@ -1003,13 +998,13 @@
size_t used = used_words_in_vs();
size_t capacity = capacity_words_in_vs();
VirtualSpace* vs = virtual_space();
- st->print_cr(" space @ " PTR_FORMAT " " SIZE_FORMAT "K, %3d%% used "
+ st->print_cr(" space @ " PTR_FORMAT " " SIZE_FORMAT "K, " SIZE_FORMAT_W(3) "%% used "
"[" PTR_FORMAT ", " PTR_FORMAT ", "
PTR_FORMAT ", " PTR_FORMAT ")",
- vs, capacity / K,
+ p2i(vs), capacity / K,
capacity == 0 ? 0 : used * 100 / capacity,
- bottom(), top(), end(),
- vs->high_boundary());
+ p2i(bottom()), p2i(top()), p2i(end()),
+ p2i(vs->high_boundary()));
}
#ifdef ASSERT
@@ -1812,7 +1807,7 @@
if (TraceMetadataChunkAllocation && Verbose) {
gclog_or_tty->print_cr("ChunkManager::free_chunks_get: free_list "
PTR_FORMAT " head " PTR_FORMAT " size " SIZE_FORMAT,
- free_list, chunk, chunk->word_size());
+ p2i(free_list), p2i(chunk), chunk->word_size());
}
} else {
chunk = humongous_dictionary()->get_chunk(
@@ -1872,7 +1867,7 @@
}
gclog_or_tty->print("ChunkManager::chunk_freelist_allocate: " PTR_FORMAT " chunk "
PTR_FORMAT " size " SIZE_FORMAT " count " SIZE_FORMAT " ",
- this, chunk, chunk->word_size(), list_count);
+ p2i(this), p2i(chunk), chunk->word_size(), list_count);
locked_print_free_chunks(gclog_or_tty);
}
@@ -2019,7 +2014,7 @@
for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
Metachunk* chunk = chunks_in_use(i);
st->print("SpaceManager: %s " PTR_FORMAT,
- chunk_size_name(i), chunk);
+ chunk_size_name(i), p2i(chunk));
if (chunk != NULL) {
st->print_cr(" free " SIZE_FORMAT,
chunk->free_word_size());
@@ -2130,8 +2125,8 @@
for (ChunkIndex i = ZeroIndex;
i < NumberOfInUseLists ;
i = next_chunk_index(i) ) {
- st->print_cr(" chunks_in_use " PTR_FORMAT " chunk size " PTR_FORMAT,
- chunks_in_use(i),
+ st->print_cr(" chunks_in_use " PTR_FORMAT " chunk size " SIZE_FORMAT,
+ p2i(chunks_in_use(i)),
chunks_in_use(i) == NULL ? 0 : chunks_in_use(i)->word_size());
}
st->print_cr(" waste: Small " SIZE_FORMAT " Medium " SIZE_FORMAT
@@ -2194,7 +2189,7 @@
}
_current_chunk = NULL;
if (TraceMetadataChunkAllocation && Verbose) {
- gclog_or_tty->print_cr("SpaceManager(): " PTR_FORMAT, this);
+ gclog_or_tty->print_cr("SpaceManager(): " PTR_FORMAT, p2i(this));
}
}
@@ -2238,7 +2233,7 @@
dec_total_from_size_metrics();
if (TraceMetadataChunkAllocation && Verbose) {
- gclog_or_tty->print_cr("~SpaceManager(): " PTR_FORMAT, this);
+ gclog_or_tty->print_cr("~SpaceManager(): " PTR_FORMAT, p2i(this));
locked_print_chunks_in_use_on(gclog_or_tty);
}
@@ -2258,7 +2253,7 @@
for (ChunkIndex i = ZeroIndex; i < HumongousIndex; i = next_chunk_index(i)) {
if (TraceMetadataChunkAllocation && Verbose) {
- gclog_or_tty->print_cr("returned %d %s chunks to freelist",
+ gclog_or_tty->print_cr("returned " SIZE_FORMAT " %s chunks to freelist",
sum_count_in_chunks_in_use(i),
chunk_size_name(i));
}
@@ -2266,7 +2261,7 @@
chunk_manager()->return_chunks(i, chunks);
set_chunks_in_use(i, NULL);
if (TraceMetadataChunkAllocation && Verbose) {
- gclog_or_tty->print_cr("updated freelist count %d %s",
+ gclog_or_tty->print_cr("updated freelist count " SSIZE_FORMAT " %s",
chunk_manager()->free_chunks(i)->count(),
chunk_size_name(i));
}
@@ -2279,7 +2274,7 @@
// Humongous chunks
if (TraceMetadataChunkAllocation && Verbose) {
- gclog_or_tty->print_cr("returned %d %s humongous chunks to dictionary",
+ gclog_or_tty->print_cr("returned " SIZE_FORMAT " %s humongous chunks to dictionary",
sum_count_in_chunks_in_use(HumongousIndex),
chunk_size_name(HumongousIndex));
gclog_or_tty->print("Humongous chunk dictionary: ");
@@ -2293,14 +2288,14 @@
#endif
if (TraceMetadataChunkAllocation && Verbose) {
gclog_or_tty->print(PTR_FORMAT " (" SIZE_FORMAT ") ",
- humongous_chunks,
+ p2i(humongous_chunks),
humongous_chunks->word_size());
}
assert(humongous_chunks->word_size() == (size_t)
align_size_up(humongous_chunks->word_size(),
smallest_chunk_size()),
err_msg("Humongous chunk size is wrong: word size " SIZE_FORMAT
- " granularity %d",
+ " granularity " SIZE_FORMAT,
humongous_chunks->word_size(), smallest_chunk_size()));
Metachunk* next_humongous_chunks = humongous_chunks->next();
humongous_chunks->container()->dec_container_count();
@@ -2309,7 +2304,7 @@
}
if (TraceMetadataChunkAllocation && Verbose) {
gclog_or_tty->cr();
- gclog_or_tty->print_cr("updated dictionary count %d %s",
+ gclog_or_tty->print_cr("updated dictionary count " SIZE_FORMAT " %s",
chunk_manager()->humongous_dictionary()->total_count(),
chunk_size_name(HumongousIndex));
}
@@ -2399,7 +2394,7 @@
assert(new_chunk->is_empty(), "Not ready for reuse");
if (TraceMetadataChunkAllocation && Verbose) {
- gclog_or_tty->print("SpaceManager::add_chunk: %d) ",
+ gclog_or_tty->print("SpaceManager::add_chunk: " SIZE_FORMAT ") ",
sum_count_in_chunks_in_use());
new_chunk->print_on(gclog_or_tty);
chunk_manager()->locked_print_free_chunks(gclog_or_tty);
@@ -3097,7 +3092,7 @@
metaspace_rs = ReservedSpace(compressed_class_space_size(),
_reserve_alignment, large_pages);
if (!metaspace_rs.is_reserved()) {
- vm_exit_during_initialization(err_msg("Could not allocate metaspace: %d bytes",
+ vm_exit_during_initialization(err_msg("Could not allocate metaspace: " SIZE_FORMAT " bytes",
compressed_class_space_size()));
}
}
@@ -3119,10 +3114,10 @@
initialize_class_space(metaspace_rs);
if (PrintCompressedOopsMode || (PrintMiscellaneous && Verbose)) {
- gclog_or_tty->print_cr("Narrow klass base: " PTR_FORMAT ", Narrow klass shift: " SIZE_FORMAT,
- Universe::narrow_klass_base(), Universe::narrow_klass_shift());
+ gclog_or_tty->print_cr("Narrow klass base: " PTR_FORMAT ", Narrow klass shift: %d",
+ p2i(Universe::narrow_klass_base()), Universe::narrow_klass_shift());
gclog_or_tty->print_cr("Compressed class space size: " SIZE_FORMAT " Address: " PTR_FORMAT " Req Addr: " PTR_FORMAT,
- compressed_class_space_size(), metaspace_rs.base(), requested_addr);
+ compressed_class_space_size(), p2i(metaspace_rs.base()), p2i(requested_addr));
}
}
@@ -3251,7 +3246,7 @@
vm_exit_during_initialization("Unable to dump shared archive.",
err_msg("Size of archive (" SIZE_FORMAT ") + compressed class space ("
SIZE_FORMAT ") == total (" SIZE_FORMAT ") is larger than compressed "
- "klass limit: " SIZE_FORMAT, cds_total, compressed_class_space_size(),
+ "klass limit: " UINT64_FORMAT, cds_total, compressed_class_space_size(),
cds_total + compressed_class_space_size(), UnscaledClassSpaceMax));
}
@@ -3262,7 +3257,7 @@
Universe::set_narrow_klass_base((address)_space_list->current_virtual_space()->bottom());
if (TraceMetavirtualspaceAllocation && Verbose) {
gclog_or_tty->print_cr("Setting_narrow_klass_base to Address: " PTR_FORMAT,
- _space_list->current_virtual_space()->bottom());
+ p2i(_space_list->current_virtual_space()->bottom()));
}
Universe::set_narrow_klass_shift(0);
@@ -3768,10 +3763,10 @@
}
void Metaspace::dump(outputStream* const out) const {
- out->print_cr("\nVirtual space manager: " INTPTR_FORMAT, vsm());
+ out->print_cr("\nVirtual space manager: " INTPTR_FORMAT, p2i(vsm()));
vsm()->dump(out);
if (using_class_space()) {
- out->print_cr("\nClass space manager: " INTPTR_FORMAT, class_vsm());
+ out->print_cr("\nClass space manager: " INTPTR_FORMAT, p2i(class_vsm()));
class_vsm()->dump(out);
}
}
@@ -3932,13 +3927,13 @@
assert(vsn.is_available(word_size), \
err_msg(#word_size ": " PTR_FORMAT " bytes were not available in " \
"VirtualSpaceNode [" PTR_FORMAT ", " PTR_FORMAT ")", \
- (uintptr_t)(word_size * BytesPerWord), vsn.bottom(), vsn.end()));
+ (uintptr_t)(word_size * BytesPerWord), p2i(vsn.bottom()), p2i(vsn.end())));
#define assert_is_available_negative(word_size) \
assert(!vsn.is_available(word_size), \
err_msg(#word_size ": " PTR_FORMAT " bytes should not be available in " \
"VirtualSpaceNode [" PTR_FORMAT ", " PTR_FORMAT ")", \
- (uintptr_t)(word_size * BytesPerWord), vsn.bottom(), vsn.end()));
+ (uintptr_t)(word_size * BytesPerWord), p2i(vsn.bottom()), p2i(vsn.end())));
static void test_is_available_positive() {
// Reserve some memory.
--- a/hotspot/src/share/vm/memory/referenceProcessor.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/referenceProcessor.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -35,8 +35,6 @@
#include "runtime/java.hpp"
#include "runtime/jniHandles.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
ReferencePolicy* ReferenceProcessor::_always_clear_soft_ref_policy = NULL;
ReferencePolicy* ReferenceProcessor::_default_soft_ref_policy = NULL;
bool ReferenceProcessor::_pending_list_uses_discovered_field = false;
@@ -161,7 +159,7 @@
NOT_PRODUCT(
if (now < _soft_ref_timestamp_clock) {
- warning("time warp: "INT64_FORMAT" to "INT64_FORMAT,
+ warning("time warp: " JLONG_FORMAT " to " JLONG_FORMAT,
_soft_ref_timestamp_clock, now);
}
)
@@ -361,7 +359,7 @@
// field.
if (TraceReferenceGC && PrintGCDetails) {
gclog_or_tty->print_cr("ReferenceProcessor::enqueue_discovered_reflist list "
- INTPTR_FORMAT, (address)refs_list.head());
+ INTPTR_FORMAT, p2i(refs_list.head()));
}
oop obj = NULL;
@@ -375,7 +373,7 @@
next_d = java_lang_ref_Reference::discovered(obj);
if (TraceReferenceGC && PrintGCDetails) {
gclog_or_tty->print_cr(" obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT,
- (void *)obj, (void *)next_d);
+ p2i(obj), p2i(next_d));
}
assert(java_lang_ref_Reference::next(obj) == NULL,
"Reference not active; should not be discovered");
@@ -402,7 +400,7 @@
next_d = java_lang_ref_Reference::discovered(obj);
if (TraceReferenceGC && PrintGCDetails) {
gclog_or_tty->print_cr(" obj " INTPTR_FORMAT "/next_d " INTPTR_FORMAT,
- (void *)obj, (void *)next_d);
+ p2i(obj), p2i(next_d));
}
assert(java_lang_ref_Reference::next(obj) == NULL,
"The reference should not be enqueued");
@@ -565,7 +563,7 @@
!policy->should_clear_reference(iter.obj(), _soft_ref_timestamp_clock)) {
if (TraceReferenceGC) {
gclog_or_tty->print_cr("Dropping reference (" INTPTR_FORMAT ": %s" ") by policy",
- (void *)iter.obj(), iter.obj()->klass()->internal_name());
+ p2i(iter.obj()), iter.obj()->klass()->internal_name());
}
// Remove Reference object from list
iter.remove();
@@ -582,9 +580,9 @@
complete_gc->do_void();
NOT_PRODUCT(
if (PrintGCDetails && TraceReferenceGC) {
- gclog_or_tty->print_cr(" Dropped %d dead Refs out of %d "
- "discovered Refs by policy, from list " INTPTR_FORMAT,
- iter.removed(), iter.processed(), (address)refs_list.head());
+ gclog_or_tty->print_cr(" Dropped " SIZE_FORMAT " dead Refs out of " SIZE_FORMAT
+ " discovered Refs by policy, from list " INTPTR_FORMAT,
+ iter.removed(), iter.processed(), p2i(refs_list.head()));
}
)
}
@@ -604,7 +602,7 @@
if (iter.is_referent_alive()) {
if (TraceReferenceGC) {
gclog_or_tty->print_cr("Dropping strongly reachable reference (" INTPTR_FORMAT ": %s)",
- (void *)iter.obj(), iter.obj()->klass()->internal_name());
+ p2i(iter.obj()), iter.obj()->klass()->internal_name());
}
// The referent is reachable after all.
// Remove Reference object from list.
@@ -620,9 +618,9 @@
}
NOT_PRODUCT(
if (PrintGCDetails && TraceReferenceGC && (iter.processed() > 0)) {
- gclog_or_tty->print_cr(" Dropped %d active Refs out of %d "
- "Refs in discovered list " INTPTR_FORMAT,
- iter.removed(), iter.processed(), (address)refs_list.head());
+ gclog_or_tty->print_cr(" Dropped " SIZE_FORMAT " active Refs out of " SIZE_FORMAT
+ " Refs in discovered list " INTPTR_FORMAT,
+ iter.removed(), iter.processed(), p2i(refs_list.head()));
}
)
}
@@ -659,9 +657,9 @@
complete_gc->do_void();
NOT_PRODUCT(
if (PrintGCDetails && TraceReferenceGC && (iter.processed() > 0)) {
- gclog_or_tty->print_cr(" Dropped %d active Refs out of %d "
- "Refs in discovered list " INTPTR_FORMAT,
- iter.removed(), iter.processed(), (address)refs_list.head());
+ gclog_or_tty->print_cr(" Dropped " SIZE_FORMAT " active Refs out of " SIZE_FORMAT
+ " Refs in discovered list " INTPTR_FORMAT,
+ iter.removed(), iter.processed(), p2i(refs_list.head()));
}
)
}
@@ -678,7 +676,6 @@
ResourceMark rm;
DiscoveredListIterator iter(refs_list, keep_alive, is_alive);
while (iter.has_next()) {
- iter.update_discovered();
iter.load_ptrs(DEBUG_ONLY(false /* allow_null_referent */));
if (clear_referent) {
// NULL out referent pointer
@@ -690,13 +687,11 @@
if (TraceReferenceGC) {
gclog_or_tty->print_cr("Adding %sreference (" INTPTR_FORMAT ": %s) as pending",
clear_referent ? "cleared " : "",
- (void *)iter.obj(), iter.obj()->klass()->internal_name());
+ p2i(iter.obj()), iter.obj()->klass()->internal_name());
}
assert(iter.obj()->is_oop(UseConcMarkSweepGC), "Adding a bad reference");
iter.next();
}
- // Remember to update the next pointer of the last ref.
- iter.update_discovered();
// Close the reachable set
complete_gc->do_void();
}
@@ -807,11 +802,11 @@
for (uint i = 0; i < _max_num_q; ++i) {
total_refs += ref_lists[i].length();
if (TraceReferenceGC && PrintGCDetails) {
- gclog_or_tty->print("%d ", ref_lists[i].length());
+ gclog_or_tty->print(SIZE_FORMAT " ", ref_lists[i].length());
}
}
if (TraceReferenceGC && PrintGCDetails) {
- gclog_or_tty->print_cr(" = %d", total_refs);
+ gclog_or_tty->print_cr(" = " SIZE_FORMAT, total_refs);
}
size_t avg_refs = total_refs / _num_q + 1;
uint to_idx = 0;
@@ -877,11 +872,11 @@
for (uint i = 0; i < _max_num_q; ++i) {
balanced_total_refs += ref_lists[i].length();
if (TraceReferenceGC && PrintGCDetails) {
- gclog_or_tty->print("%d ", ref_lists[i].length());
+ gclog_or_tty->print(SIZE_FORMAT " ", ref_lists[i].length());
}
}
if (TraceReferenceGC && PrintGCDetails) {
- gclog_or_tty->print_cr(" = %d", balanced_total_refs);
+ gclog_or_tty->print_cr(" = " SIZE_FORMAT, balanced_total_refs);
gclog_or_tty->flush();
}
assert(total_refs == balanced_total_refs, "Balancing was incomplete");
@@ -923,7 +918,7 @@
size_t total_list_count = total_count(refs_lists);
if (PrintReferenceGC && PrintGCDetails) {
- gclog_or_tty->print(", %u refs", total_list_count);
+ gclog_or_tty->print(", " SIZE_FORMAT " refs", total_list_count);
}
// Phase 1 (soft refs only):
@@ -1016,7 +1011,7 @@
ShouldNotReachHere();
}
if (TraceReferenceGC && PrintGCDetails) {
- gclog_or_tty->print_cr("Thread %d gets list " INTPTR_FORMAT, id, list);
+ gclog_or_tty->print_cr("Thread %d gets list " INTPTR_FORMAT, id, p2i(list));
}
return list;
}
@@ -1043,14 +1038,14 @@
if (TraceReferenceGC) {
gclog_or_tty->print_cr("Discovered reference (mt) (" INTPTR_FORMAT ": %s)",
- (void *)obj, obj->klass()->internal_name());
+ p2i(obj), obj->klass()->internal_name());
}
} else {
// If retest was non NULL, another thread beat us to it:
// The reference has already been discovered...
if (TraceReferenceGC) {
gclog_or_tty->print_cr("Already discovered reference (" INTPTR_FORMAT ": %s)",
- (void *)obj, obj->klass()->internal_name());
+ p2i(obj), obj->klass()->internal_name());
}
}
}
@@ -1065,7 +1060,7 @@
assert(da ? referent->is_oop() : referent->is_oop_or_null(),
err_msg("Bad referent " INTPTR_FORMAT " found in Reference "
INTPTR_FORMAT " during %satomic discovery ",
- (void *)referent, (void *)obj, da ? "" : "non-"));
+ p2i(referent), p2i(obj), da ? "" : "non-"));
}
#endif
@@ -1145,7 +1140,7 @@
// The reference has already been discovered...
if (TraceReferenceGC) {
gclog_or_tty->print_cr("Already discovered reference (" INTPTR_FORMAT ": %s)",
- (void *)obj, obj->klass()->internal_name());
+ p2i(obj), obj->klass()->internal_name());
}
if (RefDiscoveryPolicy == ReferentBasedDiscovery) {
// assumes that an object is not processed twice;
@@ -1203,7 +1198,7 @@
if (TraceReferenceGC) {
gclog_or_tty->print_cr("Discovered reference (" INTPTR_FORMAT ": %s)",
- (void *)obj, obj->klass()->internal_name());
+ p2i(obj), obj->klass()->internal_name());
}
}
assert(obj->is_oop(), "Discovered a bad reference");
@@ -1314,7 +1309,7 @@
// active; we need to trace and mark its cohort.
if (TraceReferenceGC) {
gclog_or_tty->print_cr("Precleaning Reference (" INTPTR_FORMAT ": %s)",
- (void *)iter.obj(), iter.obj()->klass()->internal_name());
+ p2i(iter.obj()), iter.obj()->klass()->internal_name());
}
// Remove Reference object from list
iter.remove();
@@ -1337,9 +1332,9 @@
NOT_PRODUCT(
if (PrintGCDetails && PrintReferenceGC && (iter.processed() > 0)) {
- gclog_or_tty->print_cr(" Dropped %d Refs out of %d "
- "Refs in discovered list " INTPTR_FORMAT,
- iter.removed(), iter.processed(), (address)refs_list.head());
+ gclog_or_tty->print_cr(" Dropped " SIZE_FORMAT " Refs out of " SIZE_FORMAT
+ " Refs in discovered list " INTPTR_FORMAT,
+ iter.removed(), iter.processed(), p2i(refs_list.head()));
}
)
}
--- a/hotspot/src/share/vm/memory/referenceProcessor.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/referenceProcessor.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2013, 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
@@ -173,20 +173,6 @@
}
}
- // Update the discovered field.
- inline void update_discovered() {
- // First _prev_next ref actually points into DiscoveredList (gross).
- if (UseCompressedOops) {
- if (!oopDesc::is_null(*(narrowOop*)_prev_next)) {
- _keep_alive->do_oop((narrowOop*)_prev_next);
- }
- } else {
- if (!oopDesc::is_null(*(oop*)_prev_next)) {
- _keep_alive->do_oop((oop*)_prev_next);
- }
- }
- }
-
// NULL out referent pointer.
void clear_referent();
--- a/hotspot/src/share/vm/memory/sharedHeap.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/sharedHeap.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -35,14 +35,10 @@
#include "utilities/copy.hpp"
#include "utilities/workgroup.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
SharedHeap* SharedHeap::_sh;
-SharedHeap::SharedHeap(CollectorPolicy* policy_) :
+SharedHeap::SharedHeap() :
CollectedHeap(),
- _collector_policy(policy_),
- _strong_roots_parity(0),
_workers(NULL)
{
_sh = this; // ch is static, should be set only once.
@@ -70,26 +66,20 @@
_n_par_threads = t;
}
-void SharedHeap::change_strong_roots_parity() {
- // Also set the new collection parity.
- assert(_strong_roots_parity >= 0 && _strong_roots_parity <= 2,
- "Not in range.");
- _strong_roots_parity++;
- if (_strong_roots_parity == 3) _strong_roots_parity = 1;
- assert(_strong_roots_parity >= 1 && _strong_roots_parity <= 2,
- "Not in range.");
-}
-
SharedHeap::StrongRootsScope::StrongRootsScope(SharedHeap* heap, bool activate)
: MarkScope(activate), _sh(heap)
{
if (_active) {
- _sh->change_strong_roots_parity();
+ Threads::change_thread_claim_parity();
// Zero the claimed high water mark in the StringTable
StringTable::clear_parallel_claimed_index();
}
}
+SharedHeap::StrongRootsScope::~StrongRootsScope() {
+ Threads::assert_all_threads_claimed();
+}
+
void SharedHeap::set_barrier_set(BarrierSet* bs) {
_barrier_set = bs;
// Cached barrier set for fast access in oops
@@ -102,17 +92,3 @@
}
void SharedHeap::ref_processing_init() {}
-
-// Some utilities.
-void SharedHeap::print_size_transition(outputStream* out,
- size_t bytes_before,
- size_t bytes_after,
- size_t capacity) {
- out->print(" " SIZE_FORMAT "%s->" SIZE_FORMAT "%s(" SIZE_FORMAT "%s)",
- byte_size_in_proper_unit(bytes_before),
- proper_unit_for_byte_size(bytes_before),
- byte_size_in_proper_unit(bytes_after),
- proper_unit_for_byte_size(bytes_after),
- byte_size_in_proper_unit(capacity),
- proper_unit_for_byte_size(capacity));
-}
--- a/hotspot/src/share/vm/memory/sharedHeap.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/sharedHeap.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 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
@@ -110,19 +110,12 @@
// set the static pointer "_sh" to that instance.
static SharedHeap* _sh;
- // A gc policy, controls global gc resource issues
- CollectorPolicy *_collector_policy;
-
- // See the discussion below, in the specification of the reader function
- // for this variable.
- int _strong_roots_parity;
-
// If we're doing parallel GC, use this gang of threads.
FlexibleWorkGang* _workers;
// Full initialization is done in a concrete subtype's "initialize"
// function.
- SharedHeap(CollectorPolicy* policy_);
+ SharedHeap();
// Returns true if the calling thread holds the heap lock,
// or the calling thread is a par gc thread and the heap_lock is held
@@ -156,7 +149,10 @@
bool no_gc_in_progress() { return !is_gc_active(); }
- // Some collectors will perform "process_strong_roots" in parallel.
+ // Note, the below comment needs to be updated to reflect the changes
+ // introduced by JDK-8076225. This should be done as part of JDK-8076289.
+ //
+ //Some collectors will perform "process_strong_roots" in parallel.
// Such a call will involve claiming some fine-grained tasks, such as
// scanning of threads. To make this process simpler, we provide the
// "strong_roots_parity()" method. Collectors that start parallel tasks
@@ -182,7 +178,6 @@
// task-claiming variables may be initialized, to indicate "never
// claimed".
public:
- int strong_roots_parity() { return _strong_roots_parity; }
// Call these in sequential code around process_roots.
// strong_roots_prologue calls change_strong_roots_parity, if
@@ -192,11 +187,10 @@
public:
StrongRootsScope(SharedHeap* heap, bool activate = true);
+ ~StrongRootsScope();
};
- friend class StrongRootsScope;
private:
- void change_strong_roots_parity();
public:
FlexibleWorkGang* workers() const { return _workers; }
@@ -214,16 +208,6 @@
// Sets the number of parallel threads that will be doing tasks
// (such as process roots) subsequently.
virtual void set_par_threads(uint t);
-
- //
- // New methods from CollectedHeap
- //
-
- // Some utilities.
- void print_size_transition(outputStream* out,
- size_t bytes_before,
- size_t bytes_after,
- size_t capacity);
};
#endif // SHARE_VM_MEMORY_SHAREDHEAP_HPP
--- a/hotspot/src/share/vm/memory/space.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/space.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -44,8 +44,6 @@
#include "utilities/globalDefinitions.hpp"
#include "utilities/macros.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
HeapWord* DirtyCardToOopClosure::get_actual_top(HeapWord* top,
HeapWord* top_obj) {
if (top_obj != NULL) {
@@ -456,20 +454,20 @@
void Space::print_on(outputStream* st) const {
print_short_on(st);
st->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ")",
- bottom(), end());
+ p2i(bottom()), p2i(end()));
}
void ContiguousSpace::print_on(outputStream* st) const {
print_short_on(st);
st->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT ")",
- bottom(), top(), end());
+ p2i(bottom()), p2i(top()), p2i(end()));
}
void OffsetTableContigSpace::print_on(outputStream* st) const {
print_short_on(st);
st->print_cr(" [" INTPTR_FORMAT ", " INTPTR_FORMAT ", "
INTPTR_FORMAT ", " INTPTR_FORMAT ")",
- bottom(), top(), _offsets.threshold(), end());
+ p2i(bottom()), p2i(top()), p2i(_offsets.threshold()), p2i(end()));
}
void ContiguousSpace::verify() const {
@@ -592,7 +590,7 @@
HeapWord* ContiguousSpace::block_start_const(const void* p) const {
assert(MemRegion(bottom(), end()).contains(p),
err_msg("p (" PTR_FORMAT ") not in space [" PTR_FORMAT ", " PTR_FORMAT ")",
- p, bottom(), end()));
+ p2i(p), p2i(bottom()), p2i(end())));
if (p >= top()) {
return top();
} else {
@@ -603,7 +601,7 @@
cur += oop(cur)->size();
}
assert(oop(last)->is_oop(),
- err_msg(PTR_FORMAT " should be an object start", last));
+ err_msg(PTR_FORMAT " should be an object start", p2i(last)));
return last;
}
}
@@ -611,15 +609,15 @@
size_t ContiguousSpace::block_size(const HeapWord* p) const {
assert(MemRegion(bottom(), end()).contains(p),
err_msg("p (" PTR_FORMAT ") not in space [" PTR_FORMAT ", " PTR_FORMAT ")",
- p, bottom(), end()));
+ p2i(p), p2i(bottom()), p2i(end())));
HeapWord* current_top = top();
assert(p <= current_top,
err_msg("p > current top - p: " PTR_FORMAT ", current top: " PTR_FORMAT,
- p, current_top));
+ p2i(p), p2i(current_top)));
assert(p == current_top || oop(p)->is_oop(),
err_msg("p (" PTR_FORMAT ") is not a block start - "
"current_top: " PTR_FORMAT ", is_oop: %s",
- p, current_top, BOOL_TO_STR(oop(p)->is_oop())));
+ p2i(p), p2i(current_top), BOOL_TO_STR(oop(p)->is_oop())));
if (p < current_top) {
return oop(p)->size();
} else {
--- a/hotspot/src/share/vm/memory/space.inline.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/space.inline.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -214,7 +214,7 @@
assert(space->block_is_obj(q), "should be at block boundaries, and should be looking at objs");
// point all the oops to the new location
- size_t size = oop(q)->adjust_pointers();
+ size_t size = MarkSweep::adjust_pointers(oop(q));
size = space->adjust_obj_size(size);
q += size;
@@ -238,7 +238,7 @@
if (oop(q)->is_gc_marked()) {
// q is alive
// point all the oops to the new location
- size_t size = oop(q)->adjust_pointers();
+ size_t size = MarkSweep::adjust_pointers(oop(q));
size = space->adjust_obj_size(size);
debug_only(prev_q = q);
q += size;
--- a/hotspot/src/share/vm/memory/threadLocalAllocBuffer.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/threadLocalAllocBuffer.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -31,8 +31,6 @@
#include "runtime/thread.inline.hpp"
#include "utilities/copy.hpp"
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
// Thread-Local Edens support
// static member initialization
@@ -154,7 +152,7 @@
if (PrintTLAB && Verbose) {
gclog_or_tty->print("TLAB new size: thread: " INTPTR_FORMAT " [id: %2d]"
" refills %d alloc: %8.6f desired_size: " SIZE_FORMAT " -> " SIZE_FORMAT "\n",
- myThread(), myThread()->osthread()->thread_id(),
+ p2i(myThread()), myThread()->osthread()->thread_id(),
_target_refills, _allocation_fraction.average(), desired_size(), aligned_new_size);
}
set_desired_size(aligned_new_size);
@@ -263,7 +261,7 @@
" slow allocs: %d refill waste: " SIZE_FORMAT "B"
" alloc:%8.5f %8.0fKB refills: %d waste %4.1f%% gc: %dB"
" slow: %dB fast: %dB\n",
- tag, thrd, thrd->osthread()->thread_id(),
+ tag, p2i(thrd), thrd->osthread()->thread_id(),
_desired_size / (K / HeapWordSize),
_slow_allocations, _refill_waste_limit * HeapWordSize,
_allocation_fraction.average(),
--- a/hotspot/src/share/vm/memory/universe.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/memory/universe.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -84,8 +84,6 @@
#include "classfile/sharedClassUtil.hpp"
#endif
-PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
-
// Known objects
Klass* Universe::_boolArrayKlassObj = NULL;
Klass* Universe::_byteArrayKlassObj = NULL;
@@ -792,12 +790,12 @@
void Universe::print_compressed_oops_mode() {
tty->cr();
tty->print("heap address: " PTR_FORMAT ", size: " SIZE_FORMAT " MB",
- Universe::heap()->base(), Universe::heap()->reserved_region().byte_size()/M);
+ p2i(Universe::heap()->base()), Universe::heap()->reserved_region().byte_size()/M);
tty->print(", Compressed Oops mode: %s", narrow_oop_mode_to_string(narrow_oop_mode()));
if (Universe::narrow_oop_base() != 0) {
- tty->print(": " PTR_FORMAT, Universe::narrow_oop_base());
+ tty->print(": " PTR_FORMAT, p2i(Universe::narrow_oop_base()));
}
if (Universe::narrow_oop_shift() != 0) {
--- a/hotspot/src/share/vm/oops/instanceClassLoaderKlass.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/oops/instanceClassLoaderKlass.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2011, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 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
@@ -42,7 +42,6 @@
#if INCLUDE_ALL_GCS
#include "gc_implementation/parNew/parOopClosures.inline.hpp"
#include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
-#include "oops/oop.pcgc.inline.hpp"
#endif // INCLUDE_ALL_GCS
// Macro to define InstanceClassLoaderKlass::oop_oop_iterate for virtual/nonvirtual for
--- a/hotspot/src/share/vm/oops/instanceKlass.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/oops/instanceKlass.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -74,7 +74,6 @@
#include "gc_implementation/parallelScavenge/parallelScavengeHeap.inline.hpp"
#include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
#include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
-#include "oops/oop.pcgc.inline.hpp"
#endif // INCLUDE_ALL_GCS
#ifdef COMPILER1
#include "c1/c1_Compiler.hpp"
--- a/hotspot/src/share/vm/oops/instanceMirrorKlass.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/oops/instanceMirrorKlass.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 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
@@ -47,7 +47,6 @@
#include "gc_implementation/parNew/parOopClosures.inline.hpp"
#include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
#include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
-#include "oops/oop.pcgc.inline.hpp"
#endif // INCLUDE_ALL_GCS
int InstanceMirrorKlass::_offset_of_static_fields = 0;
--- a/hotspot/src/share/vm/oops/instanceRefKlass.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/oops/instanceRefKlass.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 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
@@ -43,7 +43,6 @@
#include "gc_implementation/parNew/parOopClosures.inline.hpp"
#include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
#include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
-#include "oops/oop.pcgc.inline.hpp"
#endif // INCLUDE_ALL_GCS
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
--- a/hotspot/src/share/vm/oops/objArrayKlass.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/oops/objArrayKlass.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -55,7 +55,6 @@
#include "gc_implementation/parallelScavenge/psCompactionManager.hpp"
#include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
#include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
-#include "oops/oop.pcgc.inline.hpp"
#endif // INCLUDE_ALL_GCS
ObjArrayKlass* ObjArrayKlass::allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS) {
--- a/hotspot/src/share/vm/runtime/thread.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/runtime/thread.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -3183,6 +3183,7 @@
int Threads::_number_of_threads = 0;
int Threads::_number_of_non_daemon_threads = 0;
int Threads::_return_code = 0;
+int Threads::_thread_claim_parity = 0;
size_t JavaThread::_stack_size_at_create = 0;
#ifdef ASSERT
bool Threads::_vm_complete = false;
@@ -3217,7 +3218,6 @@
// If CompilerThreads ever become non-JavaThreads, add them here
}
-
void Threads::initialize_java_lang_classes(JavaThread* main_thread, TRAPS) {
TraceTime timer("Initialize java.lang classes", TraceStartupTime);
@@ -4046,6 +4046,26 @@
VMThread::vm_thread()->oops_do(f, cld_f, cf);
}
+void Threads::change_thread_claim_parity() {
+ // Set the new claim parity.
+ assert(_thread_claim_parity >= 0 && _thread_claim_parity <= 2,
+ "Not in range.");
+ _thread_claim_parity++;
+ if (_thread_claim_parity == 3) _thread_claim_parity = 1;
+ assert(_thread_claim_parity >= 1 && _thread_claim_parity <= 2,
+ "Not in range.");
+}
+
+#ifndef PRODUCT
+void Threads::assert_all_threads_claimed() {
+ ALL_JAVA_THREADS(p) {
+ const int thread_parity = p->oops_do_parity();
+ assert((thread_parity == _thread_claim_parity),
+ err_msg("Thread " PTR_FORMAT " has incorrect parity %d != %d", p2i(p), thread_parity, _thread_claim_parity));
+ }
+}
+#endif // PRODUCT
+
void Threads::possibly_parallel_oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
// Introduce a mechanism allowing parallel threads to claim threads as
// root groups. Overhead should be small enough to use all the time,
@@ -4060,7 +4080,7 @@
assert(!is_par ||
(SharedHeap::heap()->n_par_threads() ==
SharedHeap::heap()->workers()->active_workers()), "Mismatch");
- int cp = SharedHeap::heap()->strong_roots_parity();
+ int cp = Threads::thread_claim_parity();
ALL_JAVA_THREADS(p) {
if (p->claim_oops_do(is_par, cp)) {
p->oops_do(f, cld_f, cf);
--- a/hotspot/src/share/vm/runtime/thread.hpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/runtime/thread.hpp Thu Apr 02 13:38:47 2015 -0700
@@ -551,6 +551,7 @@
Monitor* owned_locks() const { return _owned_locks; }
bool owns_locks() const { return owned_locks() != NULL; }
bool owns_locks_but_compiled_lock() const;
+ int oops_do_parity() const { return _oops_do_parity; }
// Deadlock detection
bool allow_allocation() { return _allow_allocation_count == 0; }
@@ -1855,6 +1856,7 @@
static int _number_of_threads;
static int _number_of_non_daemon_threads;
static int _return_code;
+ static int _thread_claim_parity;
#ifdef ASSERT
static bool _vm_complete;
#endif
@@ -1884,9 +1886,10 @@
// Does not include JNI_VERSION_1_1
static jboolean is_supported_jni_version(jint version);
- // Garbage collection
- static void follow_other_roots(void f(oop*));
+ static int thread_claim_parity() { return _thread_claim_parity; }
+ static void change_thread_claim_parity();
+ static void assert_all_threads_claimed() PRODUCT_RETURN;
// Apply "f->do_oop" to all root oops in all threads.
// This version may only be called by sequential code.
static void oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf);
--- a/hotspot/src/share/vm/runtime/vmStructs.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/runtime/vmStructs.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -527,11 +527,11 @@
nonstatic_field(CollectedHeap, _defer_initial_card_mark, bool) \
nonstatic_field(CollectedHeap, _is_gc_active, bool) \
nonstatic_field(CollectedHeap, _total_collections, unsigned int) \
+ \
nonstatic_field(CompactibleSpace, _compaction_top, HeapWord*) \
nonstatic_field(CompactibleSpace, _first_dead, HeapWord*) \
nonstatic_field(CompactibleSpace, _end_of_live, HeapWord*) \
\
- \
nonstatic_field(ContiguousSpace, _top, HeapWord*) \
nonstatic_field(ContiguousSpace, _concurrent_iteration_safe_limit, HeapWord*) \
nonstatic_field(ContiguousSpace, _saved_mark_word, HeapWord*) \
@@ -559,7 +559,9 @@
nonstatic_field(GenCollectedHeap, _young_gen, Generation*) \
nonstatic_field(GenCollectedHeap, _old_gen, Generation*) \
nonstatic_field(GenCollectedHeap, _n_gens, int) \
- nonstatic_field(GenCollectedHeap, _gen_specs, GenerationSpec**) \
+ \
+ nonstatic_field(GenCollectorPolicy, _young_gen_spec, GenerationSpec*) \
+ nonstatic_field(GenCollectorPolicy, _old_gen_spec, GenerationSpec*) \
\
nonstatic_field(HeapWord, i, char*) \
\
@@ -1505,6 +1507,7 @@
declare_type(DefNewGeneration, Generation) \
declare_type(CardGeneration, Generation) \
declare_type(TenuredGeneration, CardGeneration) \
+ declare_toplevel_type(GenCollectorPolicy) \
declare_toplevel_type(Space) \
declare_toplevel_type(BitMap) \
declare_type(CompactibleSpace, Space) \
@@ -2250,9 +2253,9 @@
\
declare_constant(CardTableRS::youngergen_card) \
\
- declare_constant(CollectedHeap::Abstract) \
- declare_constant(CollectedHeap::SharedHeap) \
declare_constant(CollectedHeap::GenCollectedHeap) \
+ declare_constant(CollectedHeap::ParallelScavengeHeap) \
+ declare_constant(CollectedHeap::G1CollectedHeap) \
\
declare_constant(GenCollectedHeap::max_gens) \
\
--- a/hotspot/src/share/vm/services/memoryService.cpp Tue Mar 31 11:13:08 2015 -0700
+++ b/hotspot/src/share/vm/services/memoryService.cpp Thu Apr 02 13:38:47 2015 -0700
@@ -130,8 +130,7 @@
GenCollectorPolicy* gen_policy = policy->as_generation_policy();
if (gen_policy != NULL) {
- GenerationSpec** specs = gen_policy->generations();
- Generation::Name kind = specs[0]->name();
+ Generation::Name kind = gen_policy->young_gen_spec()->name();
switch (kind) {
case Generation::DefNew:
_minor_gc_manager = MemoryManager::get_copy_memory_manager();
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/ergonomics/TestDynamicNumberOfGCThreads.java Thu Apr 02 13:38:47 2015 -0700
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 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.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test TestDynamicNumberOfGCThreads
+ * @bug 8017462
+ * @summary Ensure that UseDynamicNumberOfGCThreads runs
+ * @requires vm.gc=="null"
+ * @key gc
+ * @library /testlibrary
+ */
+
+import com.oracle.java.testlibrary.ProcessTools;
+import com.oracle.java.testlibrary.OutputAnalyzer;
+
+public class TestDynamicNumberOfGCThreads {
+ public static void main(String[] args) throws Exception {
+
+ testDynamicNumberOfGCThreads("UseConcMarkSweepGC");
+
+ testDynamicNumberOfGCThreads("UseG1GC");
+
+ testDynamicNumberOfGCThreads("UseParallelGC");
+ }
+
+ private static void verifyDynamicNumberOfGCThreads(OutputAnalyzer output) {
+ output.shouldContain("new_active_workers");
+ output.shouldHaveExitValue(0);
+ }
+
+ private static void testDynamicNumberOfGCThreads(String gcFlag) throws Exception {
+ // UseDynamicNumberOfGCThreads and TraceDynamicGCThreads enabled
+ ProcessBuilder pb_enabled =
+ ProcessTools.createJavaProcessBuilder("-XX:+" + gcFlag, "-Xmx10M", "-XX:+PrintGCDetails", "-XX:+UseDynamicNumberOfGCThreads", "-XX:+TraceDynamicGCThreads", GCTest.class.getName());
+ verifyDynamicNumberOfGCThreads(new OutputAnalyzer(pb_enabled.start()));
+ }
+
+ static class GCTest {
+ private static byte[] garbage;
+ public static void main(String [] args) {
+ System.out.println("Creating garbage");
+ // create 128MB of garbage. This should result in at least one GC
+ for (int i = 0; i < 1024; i++) {
+ garbage = new byte[128 * 1024];
+ }
+ System.out.println("Done");
+ }
+ }
+}