Mercurial > hg > jdk9-shenandoah > hotspot
changeset 8787:9c916db4bf3b jdk9-b60
Merge
| author | lana |
|---|---|
| date | Thu, 09 Apr 2015 17:38:28 -0700 |
| parents | 4987cd56a051 (current diff) 009d2d25b517 (diff) |
| children | d2764ea89544 dd51d7312402 |
| files | |
| diffstat | 85 files changed, 632 insertions(+), 776 deletions(-) [+] |
line wrap: on
line diff
--- a/agent/src/share/classes/sun/jvm/hotspot/memory/GenCollectedHeap.java Thu Apr 09 06:40:12 2015 -0700 +++ b/agent/src/share/classes/sun/jvm/hotspot/memory/GenCollectedHeap.java Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/concurrentMarkSweep/freeChunk.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/freeChunk.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/concurrentMarkSweep/promotionInfo.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/promotionInfo.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/concurrentMarkSweep/vmCMSOperations.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/vmCMSOperations.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/concurrentMark.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/concurrentMark.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/g1CardCounts.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CardCounts.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/g1CodeCacheRemSet.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CodeCacheRemSet.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/g1GCPhaseTimes.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/g1HRPrinter.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/g1HRPrinter.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/g1ParScanThreadState.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/g1ParScanThreadState.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/g1RemSet.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/g1RemSet.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/heapRegion.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/heapRegion.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/heapRegionSet.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/heapRegionSet.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/satbQueue.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/satbQueue.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/g1/survRateGroup.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/g1/survRateGroup.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parNew/parCardTableModRefBS.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parNew/parCardTableModRefBS.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parNew/parNewGeneration.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/gcTaskManager.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/gcTaskManager.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/gcTaskThread.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/gcTaskThread.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.hpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.inline.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.inline.hpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psMarkSweepDecorator.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psMarkSweepDecorator.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psOldGen.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psOldGen.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.hpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.inline.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.inline.hpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psTasks.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psTasks.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psVirtualspace.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psVirtualspace.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/parallelScavenge/psYoungGen.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/parallelScavenge/psYoungGen.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/shared/markSweep.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/shared/markSweep.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/shared/markSweep.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/shared/markSweep.hpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/shared/markSweep.inline.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/shared/markSweep.inline.hpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/shared/mutableNUMASpace.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/shared/mutableSpace.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/shared/mutableSpace.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_implementation/shared/spaceDecorator.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_implementation/shared/spaceDecorator.cpp Thu Apr 09 17:38:28 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/src/share/vm/gc_interface/collectedHeap.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/gc_interface/collectedHeap.hpp Thu Apr 09 17:38:28 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/src/share/vm/memory/cardTableModRefBS.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/cardTableModRefBS.cpp Thu Apr 09 17:38:28 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/src/share/vm/memory/cardTableModRefBS.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/cardTableModRefBS.hpp Thu Apr 09 17:38:28 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/src/share/vm/memory/collectorPolicy.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/collectorPolicy.cpp Thu Apr 09 17:38:28 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/src/share/vm/memory/collectorPolicy.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/collectorPolicy.hpp Thu Apr 09 17:38:28 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/src/share/vm/memory/defNewGeneration.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/defNewGeneration.cpp Thu Apr 09 17:38:28 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/src/share/vm/memory/genCollectedHeap.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/genCollectedHeap.cpp Thu Apr 09 17:38:28 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/src/share/vm/memory/genCollectedHeap.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/genCollectedHeap.hpp Thu Apr 09 17:38:28 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/src/share/vm/memory/generation.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/generation.cpp Thu Apr 09 17:38:28 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/src/share/vm/memory/generation.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/generation.hpp Thu Apr 09 17:38:28 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/src/share/vm/memory/generationSpec.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/generationSpec.hpp Thu Apr 09 17:38:28 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/src/share/vm/memory/heapInspection.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/heapInspection.cpp Thu Apr 09 17:38:28 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/src/share/vm/memory/metachunk.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/metachunk.cpp Thu Apr 09 17:38:28 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/src/share/vm/memory/metaspace.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/metaspace.cpp Thu Apr 09 17:38:28 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/src/share/vm/memory/referenceProcessor.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/referenceProcessor.cpp Thu Apr 09 17:38:28 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/src/share/vm/memory/referenceProcessor.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/referenceProcessor.hpp Thu Apr 09 17:38:28 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/src/share/vm/memory/sharedHeap.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/sharedHeap.cpp Thu Apr 09 17:38:28 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/src/share/vm/memory/sharedHeap.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/sharedHeap.hpp Thu Apr 09 17:38:28 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/src/share/vm/memory/space.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/space.cpp Thu Apr 09 17:38:28 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/src/share/vm/memory/space.inline.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/space.inline.hpp Thu Apr 09 17:38:28 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/src/share/vm/memory/threadLocalAllocBuffer.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/threadLocalAllocBuffer.cpp Thu Apr 09 17:38:28 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/src/share/vm/memory/universe.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/memory/universe.cpp Thu Apr 09 17:38:28 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/src/share/vm/oops/instanceClassLoaderKlass.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/oops/instanceClassLoaderKlass.cpp Thu Apr 09 17:38:28 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/src/share/vm/oops/instanceKlass.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/oops/instanceKlass.cpp Thu Apr 09 17:38:28 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/src/share/vm/oops/instanceMirrorKlass.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/oops/instanceMirrorKlass.cpp Thu Apr 09 17:38:28 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/src/share/vm/oops/instanceRefKlass.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/oops/instanceRefKlass.cpp Thu Apr 09 17:38:28 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/src/share/vm/oops/objArrayKlass.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/oops/objArrayKlass.cpp Thu Apr 09 17:38:28 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/src/share/vm/runtime/thread.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/runtime/thread.cpp Thu Apr 09 17:38:28 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/src/share/vm/runtime/thread.hpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/runtime/thread.hpp Thu Apr 09 17:38:28 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/src/share/vm/runtime/vmStructs.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/runtime/vmStructs.cpp Thu Apr 09 17:38:28 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/src/share/vm/services/memoryService.cpp Thu Apr 09 06:40:12 2015 -0700 +++ b/src/share/vm/services/memoryService.cpp Thu Apr 09 17:38:28 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/test/gc/ergonomics/TestDynamicNumberOfGCThreads.java Thu Apr 09 17:38:28 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"); + } + } +}