Merge
This commit is contained in:
commit
fbe6d80096
hotspot
agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1
make
src/share/vm
c1
ci
classfile
classLoaderData.cppclassLoaderData.hppdictionary.cppdictionary.hppmetadataOnStackMark.cppstringTable.cppsystemDictionary.cppsystemDictionary.hpp
code
gc_implementation
concurrentMarkSweep
cmsAdaptiveSizePolicy.cppcmsAdaptiveSizePolicy.hppcmsCollectorPolicy.cppcmsCollectorPolicy.hppcmsGCAdaptivePolicyCounters.cppcmsGCAdaptivePolicyCounters.hppcompactibleFreeListSpace.hppconcurrentMarkSweepGeneration.cppconcurrentMarkSweepGeneration.hpp
g1
concurrentMark.cppconcurrentMark.hppg1AllocRegion.inline.hppg1BlockOffsetTable.cppg1BlockOffsetTable.inline.hppg1CodeCacheRemSet.cppg1CodeCacheRemSet.hppg1CollectedHeap.cppg1CollectedHeap.hppg1CollectedHeap.inline.hppg1EvacFailure.hppg1GCPhaseTimes.cppg1GCPhaseTimes.hppg1MarkSweep.cppg1OopClosures.cppg1OopClosures.hppg1OopClosures.inline.hppg1ParScanThreadState.cppg1ParScanThreadState.hppg1ParScanThreadState.inline.hppg1RemSet.inline.hppg1SATBCardTableModRefBS.cppg1SATBCardTableModRefBS.hppg1_specialized_oop_closures.hppheapRegion.cppheapRegion.hppheapRegion.inline.hppheapRegionRemSet.cppsatbQueue.cppsatbQueue.hppvmStructs_g1.hpp
parNew
parallelScavenge
shared
memory
cardTableModRefBS.cppcollectorPolicy.cppcollectorPolicy.hppdefNewGeneration.cppgenCollectedHeap.cppgenCollectedHeap.hppgenMarkSweep.cppgeneration.cppgeneration.hppgenerationSpec.cppiterator.cppiterator.hppmetadataFactory.hppsharedHeap.cppsharedHeap.hppspace.cppuniverse.cpp
oops
prims
@ -24,23 +24,26 @@
|
||||
|
||||
package sun.jvm.hotspot.gc_implementation.g1;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Observable;
|
||||
import java.util.Observer;
|
||||
|
||||
import sun.jvm.hotspot.debugger.Address;
|
||||
import sun.jvm.hotspot.memory.ContiguousSpace;
|
||||
import sun.jvm.hotspot.memory.CompactibleSpace;
|
||||
import sun.jvm.hotspot.memory.MemRegion;
|
||||
import sun.jvm.hotspot.runtime.VM;
|
||||
import sun.jvm.hotspot.types.AddressField;
|
||||
import sun.jvm.hotspot.types.CIntegerField;
|
||||
import sun.jvm.hotspot.types.Type;
|
||||
import sun.jvm.hotspot.types.TypeDataBase;
|
||||
|
||||
// Mirror class for HeapRegion. Currently we don't actually include
|
||||
// any of its fields but only iterate over it (which we get "for free"
|
||||
// as HeapRegion ultimately inherits from ContiguousSpace).
|
||||
// any of its fields but only iterate over it.
|
||||
|
||||
public class HeapRegion extends ContiguousSpace {
|
||||
public class HeapRegion extends CompactibleSpace {
|
||||
// static int GrainBytes;
|
||||
static private CIntegerField grainBytesField;
|
||||
static private AddressField topField;
|
||||
|
||||
static {
|
||||
VM.registerVMInitializedObserver(new Observer() {
|
||||
@ -54,6 +57,8 @@ public class HeapRegion extends ContiguousSpace {
|
||||
Type type = db.lookupType("HeapRegion");
|
||||
|
||||
grainBytesField = type.getCIntegerField("GrainBytes");
|
||||
topField = type.getAddressField("_top");
|
||||
|
||||
}
|
||||
|
||||
static public long grainBytes() {
|
||||
@ -63,4 +68,25 @@ public class HeapRegion extends ContiguousSpace {
|
||||
public HeapRegion(Address addr) {
|
||||
super(addr);
|
||||
}
|
||||
|
||||
public Address top() {
|
||||
return topField.getValue(addr);
|
||||
}
|
||||
|
||||
@Override
|
||||
public List getLiveRegions() {
|
||||
List res = new ArrayList();
|
||||
res.add(new MemRegion(bottom(), top()));
|
||||
return res;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long used() {
|
||||
return top().minus(bottom());
|
||||
}
|
||||
|
||||
@Override
|
||||
public long free() {
|
||||
return end().minus(top());
|
||||
}
|
||||
}
|
||||
|
@ -93,6 +93,7 @@ ifeq ($(INCLUDE_ALL_GCS), false)
|
||||
ageTable.cpp \
|
||||
collectorCounters.cpp \
|
||||
cSpaceCounters.cpp \
|
||||
gcId.cpp \
|
||||
gcPolicyCounters.cpp \
|
||||
gcStats.cpp \
|
||||
gcTimer.cpp \
|
||||
|
@ -1050,6 +1050,7 @@ JRT_ENTRY(void, Runtime1::patch_code(JavaThread* thread, Runtime1::StubID stub_i
|
||||
n_copy->set_data((intx) (load_klass()));
|
||||
} else {
|
||||
assert(mirror() != NULL, "klass not set");
|
||||
// Don't need a G1 pre-barrier here since we assert above that data isn't an oop.
|
||||
n_copy->set_data(cast_from_oop<intx>(mirror()));
|
||||
}
|
||||
|
||||
|
@ -185,6 +185,10 @@ private:
|
||||
}
|
||||
}
|
||||
|
||||
void ensure_metadata_alive(ciMetadata* m) {
|
||||
_factory->ensure_metadata_alive(m);
|
||||
}
|
||||
|
||||
ciInstance* get_instance(oop o) {
|
||||
if (o == NULL) return NULL;
|
||||
return get_object(o)->as_instance();
|
||||
|
@ -43,6 +43,7 @@ class ciKlass : public ciType {
|
||||
friend class ciMethod;
|
||||
friend class ciMethodData;
|
||||
friend class ciObjArrayKlass;
|
||||
friend class ciReceiverTypeData;
|
||||
|
||||
private:
|
||||
ciSymbol* _name;
|
||||
|
@ -170,6 +170,7 @@ void ciReceiverTypeData::translate_receiver_data_from(const ProfileData* data) {
|
||||
Klass* k = data->as_ReceiverTypeData()->receiver(row);
|
||||
if (k != NULL) {
|
||||
ciKlass* klass = CURRENT_ENV->get_klass(k);
|
||||
CURRENT_ENV->ensure_metadata_alive(klass);
|
||||
set_receiver(row, klass);
|
||||
}
|
||||
}
|
||||
@ -191,6 +192,7 @@ void ciReturnTypeEntry::translate_type_data_from(const ReturnTypeEntry* ret) {
|
||||
void ciSpeculativeTrapData::translate_from(const ProfileData* data) {
|
||||
Method* m = data->as_SpeculativeTrapData()->method();
|
||||
ciMethod* ci_m = CURRENT_ENV->get_method(m);
|
||||
CURRENT_ENV->ensure_metadata_alive(ci_m);
|
||||
set_method(ci_m);
|
||||
}
|
||||
|
||||
|
@ -70,6 +70,7 @@ protected:
|
||||
Klass* v = TypeEntries::valid_klass(k);
|
||||
if (v != NULL) {
|
||||
ciKlass* klass = CURRENT_ENV->get_klass(v);
|
||||
CURRENT_ENV->ensure_metadata_alive(klass);
|
||||
return with_status(klass, k);
|
||||
}
|
||||
return with_status(NULL, k);
|
||||
|
@ -46,6 +46,9 @@
|
||||
#include "oops/oop.inline.hpp"
|
||||
#include "oops/oop.inline2.hpp"
|
||||
#include "runtime/fieldType.hpp"
|
||||
#if INCLUDE_ALL_GCS
|
||||
# include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
|
||||
#endif
|
||||
|
||||
// ciObjectFactory
|
||||
//
|
||||
@ -374,6 +377,37 @@ ciMetadata* ciObjectFactory::create_new_object(Metadata* o) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// ciObjectFactory::ensure_metadata_alive
|
||||
//
|
||||
// Ensure that the metadata wrapped by the ciMetadata is kept alive by GC.
|
||||
// This is primarily useful for metadata which is considered as weak roots
|
||||
// by the GC but need to be strong roots if reachable from a current compilation.
|
||||
//
|
||||
void ciObjectFactory::ensure_metadata_alive(ciMetadata* m) {
|
||||
ASSERT_IN_VM; // We're handling raw oops here.
|
||||
|
||||
#if INCLUDE_ALL_GCS
|
||||
if (!UseG1GC) {
|
||||
return;
|
||||
}
|
||||
Klass* metadata_owner_klass;
|
||||
if (m->is_klass()) {
|
||||
metadata_owner_klass = m->as_klass()->get_Klass();
|
||||
} else if (m->is_method()) {
|
||||
metadata_owner_klass = m->as_method()->get_Method()->constants()->pool_holder();
|
||||
} else {
|
||||
fatal("Not implemented for other types of metadata");
|
||||
}
|
||||
|
||||
oop metadata_holder = metadata_owner_klass->klass_holder();
|
||||
if (metadata_holder != NULL) {
|
||||
G1SATBCardTableModRefBS::enqueue(metadata_holder);
|
||||
}
|
||||
|
||||
#endif
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// ciObjectFactory::get_unloaded_method
|
||||
//
|
||||
|
@ -75,6 +75,8 @@ private:
|
||||
ciObject* create_new_object(oop o);
|
||||
ciMetadata* create_new_object(Metadata* o);
|
||||
|
||||
void ensure_metadata_alive(ciMetadata* m);
|
||||
|
||||
static bool is_equal(NonPermObject* p, oop key) {
|
||||
return p->object()->get_oop() == key;
|
||||
}
|
||||
|
@ -332,6 +332,27 @@ void ClassLoaderData::unload() {
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef ASSERT
|
||||
class AllAliveClosure : public OopClosure {
|
||||
BoolObjectClosure* _is_alive_closure;
|
||||
bool _found_dead;
|
||||
public:
|
||||
AllAliveClosure(BoolObjectClosure* is_alive_closure) : _is_alive_closure(is_alive_closure), _found_dead(false) {}
|
||||
template <typename T> void do_oop_work(T* p) {
|
||||
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 (!_is_alive_closure->do_object_b(obj)) {
|
||||
_found_dead = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
void do_oop(oop* p) { do_oop_work<oop>(p); }
|
||||
void do_oop(narrowOop* p) { do_oop_work<narrowOop>(p); }
|
||||
bool found_dead() { return _found_dead; }
|
||||
};
|
||||
#endif
|
||||
|
||||
oop ClassLoaderData::keep_alive_object() const {
|
||||
assert(!keep_alive(), "Don't use with CLDs that are artificially kept alive");
|
||||
return is_anonymous() ? _klasses->java_mirror() : class_loader();
|
||||
@ -341,7 +362,15 @@ bool ClassLoaderData::is_alive(BoolObjectClosure* is_alive_closure) const {
|
||||
bool alive = keep_alive() // null class loader and incomplete anonymous klasses.
|
||||
|| is_alive_closure->do_object_b(keep_alive_object());
|
||||
|
||||
assert(!alive || claimed(), "must be claimed");
|
||||
#ifdef ASSERT
|
||||
if (alive) {
|
||||
AllAliveClosure all_alive_closure(is_alive_closure);
|
||||
KlassToOopClosure klass_closure(&all_alive_closure);
|
||||
const_cast<ClassLoaderData*>(this)->oops_do(&all_alive_closure, &klass_closure, false);
|
||||
assert(!all_alive_closure.found_dead(), err_msg("Found dead oop in alive cld: " PTR_FORMAT, p2i(this)));
|
||||
}
|
||||
#endif
|
||||
|
||||
return alive;
|
||||
}
|
||||
|
||||
@ -620,9 +649,9 @@ void ClassLoaderDataGraph::keep_alive_oops_do(OopClosure* f, KlassClosure* klass
|
||||
|
||||
void ClassLoaderDataGraph::always_strong_oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
|
||||
if (ClassUnloading) {
|
||||
ClassLoaderDataGraph::keep_alive_oops_do(f, klass_closure, must_claim);
|
||||
keep_alive_oops_do(f, klass_closure, must_claim);
|
||||
} else {
|
||||
ClassLoaderDataGraph::oops_do(f, klass_closure, must_claim);
|
||||
oops_do(f, klass_closure, must_claim);
|
||||
}
|
||||
}
|
||||
|
||||
@ -632,6 +661,27 @@ void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {
|
||||
}
|
||||
}
|
||||
|
||||
void ClassLoaderDataGraph::roots_cld_do(CLDClosure* strong, CLDClosure* weak) {
|
||||
for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->_next) {
|
||||
CLDClosure* closure = cld->keep_alive() ? strong : weak;
|
||||
if (closure != NULL) {
|
||||
closure->do_cld(cld);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ClassLoaderDataGraph::keep_alive_cld_do(CLDClosure* cl) {
|
||||
roots_cld_do(cl, NULL);
|
||||
}
|
||||
|
||||
void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) {
|
||||
if (ClassUnloading) {
|
||||
keep_alive_cld_do(cl);
|
||||
} else {
|
||||
cld_do(cl);
|
||||
}
|
||||
}
|
||||
|
||||
void ClassLoaderDataGraph::classes_do(KlassClosure* klass_closure) {
|
||||
for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
|
||||
cld->classes_do(klass_closure);
|
||||
@ -689,6 +739,16 @@ GrowableArray<ClassLoaderData*>* ClassLoaderDataGraph::new_clds() {
|
||||
return array;
|
||||
}
|
||||
|
||||
bool ClassLoaderDataGraph::unload_list_contains(const void* x) {
|
||||
assert(SafepointSynchronize::is_at_safepoint(), "only safe to call at safepoint");
|
||||
for (ClassLoaderData* cld = _unloading; cld != NULL; cld = cld->next()) {
|
||||
if (cld->metaspace_or_null() != NULL && cld->metaspace_or_null()->contains(x)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
#ifndef PRODUCT
|
||||
bool ClassLoaderDataGraph::contains_loader_data(ClassLoaderData* loader_data) {
|
||||
for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
|
||||
@ -809,6 +869,60 @@ Metaspace* ClassLoaderData::rw_metaspace() {
|
||||
return _rw_metaspace;
|
||||
}
|
||||
|
||||
ClassLoaderDataGraphKlassIteratorAtomic::ClassLoaderDataGraphKlassIteratorAtomic()
|
||||
: _next_klass(NULL) {
|
||||
ClassLoaderData* cld = ClassLoaderDataGraph::_head;
|
||||
Klass* klass = NULL;
|
||||
|
||||
// Find the first klass in the CLDG.
|
||||
while (cld != NULL) {
|
||||
klass = cld->_klasses;
|
||||
if (klass != NULL) {
|
||||
_next_klass = klass;
|
||||
return;
|
||||
}
|
||||
cld = cld->next();
|
||||
}
|
||||
}
|
||||
|
||||
Klass* ClassLoaderDataGraphKlassIteratorAtomic::next_klass_in_cldg(Klass* klass) {
|
||||
Klass* next = klass->next_link();
|
||||
if (next != NULL) {
|
||||
return next;
|
||||
}
|
||||
|
||||
// No more klasses in the current CLD. Time to find a new CLD.
|
||||
ClassLoaderData* cld = klass->class_loader_data();
|
||||
while (next == NULL) {
|
||||
cld = cld->next();
|
||||
if (cld == NULL) {
|
||||
break;
|
||||
}
|
||||
next = cld->_klasses;
|
||||
}
|
||||
|
||||
return next;
|
||||
}
|
||||
|
||||
Klass* ClassLoaderDataGraphKlassIteratorAtomic::next_klass() {
|
||||
Klass* head = (Klass*)_next_klass;
|
||||
|
||||
while (head != NULL) {
|
||||
Klass* next = next_klass_in_cldg(head);
|
||||
|
||||
Klass* old_head = (Klass*)Atomic::cmpxchg_ptr(next, &_next_klass, head);
|
||||
|
||||
if (old_head == head) {
|
||||
return head; // Won the CAS.
|
||||
}
|
||||
|
||||
head = old_head;
|
||||
}
|
||||
|
||||
// Nothing more for the iterator to hand out.
|
||||
assert(head == NULL, err_msg("head is " PTR_FORMAT ", expected not null:", p2i(head)));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ClassLoaderDataGraphMetaspaceIterator::ClassLoaderDataGraphMetaspaceIterator() {
|
||||
_data = ClassLoaderDataGraph::_head;
|
||||
|
@ -31,7 +31,6 @@
|
||||
#include "memory/metaspaceCounters.hpp"
|
||||
#include "runtime/mutex.hpp"
|
||||
#include "utilities/growableArray.hpp"
|
||||
|
||||
#if INCLUDE_TRACE
|
||||
# include "utilities/ticks.hpp"
|
||||
#endif
|
||||
@ -59,6 +58,7 @@ class Metadebug;
|
||||
class ClassLoaderDataGraph : public AllStatic {
|
||||
friend class ClassLoaderData;
|
||||
friend class ClassLoaderDataGraphMetaspaceIterator;
|
||||
friend class ClassLoaderDataGraphKlassIteratorAtomic;
|
||||
friend class VMStructs;
|
||||
private:
|
||||
// All CLDs (except the null CLD) can be reached by walking _head->_next->...
|
||||
@ -75,10 +75,16 @@ class ClassLoaderDataGraph : public AllStatic {
|
||||
static ClassLoaderData* find_or_create(Handle class_loader, TRAPS);
|
||||
static void purge();
|
||||
static void clear_claimed_marks();
|
||||
// oops do
|
||||
static void oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim);
|
||||
static void always_strong_oops_do(OopClosure* blk, KlassClosure* klass_closure, bool must_claim);
|
||||
static void keep_alive_oops_do(OopClosure* blk, KlassClosure* klass_closure, bool must_claim);
|
||||
static void always_strong_oops_do(OopClosure* blk, KlassClosure* klass_closure, bool must_claim);
|
||||
// cld do
|
||||
static void cld_do(CLDClosure* cl);
|
||||
static void roots_cld_do(CLDClosure* strong, CLDClosure* weak);
|
||||
static void keep_alive_cld_do(CLDClosure* cl);
|
||||
static void always_strong_cld_do(CLDClosure* cl);
|
||||
// klass do
|
||||
static void classes_do(KlassClosure* klass_closure);
|
||||
static void classes_do(void f(Klass* const));
|
||||
static void methods_do(void f(Method*));
|
||||
@ -104,6 +110,7 @@ class ClassLoaderDataGraph : public AllStatic {
|
||||
static void dump() { dump_on(tty); }
|
||||
static void verify();
|
||||
|
||||
static bool unload_list_contains(const void* x);
|
||||
#ifndef PRODUCT
|
||||
static bool contains_loader_data(ClassLoaderData* loader_data);
|
||||
#endif
|
||||
@ -136,6 +143,7 @@ class ClassLoaderData : public CHeapObj<mtClass> {
|
||||
};
|
||||
|
||||
friend class ClassLoaderDataGraph;
|
||||
friend class ClassLoaderDataGraphKlassIteratorAtomic;
|
||||
friend class ClassLoaderDataGraphMetaspaceIterator;
|
||||
friend class MetaDataFactory;
|
||||
friend class Method;
|
||||
@ -195,7 +203,6 @@ class ClassLoaderData : public CHeapObj<mtClass> {
|
||||
|
||||
void unload();
|
||||
bool keep_alive() const { return _keep_alive; }
|
||||
bool is_alive(BoolObjectClosure* is_alive_closure) const;
|
||||
void classes_do(void f(Klass*));
|
||||
void loaded_classes_do(KlassClosure* klass_closure);
|
||||
void classes_do(void f(InstanceKlass*));
|
||||
@ -208,6 +215,9 @@ class ClassLoaderData : public CHeapObj<mtClass> {
|
||||
MetaWord* allocate(size_t size);
|
||||
|
||||
public:
|
||||
|
||||
bool is_alive(BoolObjectClosure* is_alive_closure) const;
|
||||
|
||||
// Accessors
|
||||
Metaspace* metaspace_or_null() const { return _metaspace; }
|
||||
|
||||
@ -293,6 +303,16 @@ class ClassLoaderData : public CHeapObj<mtClass> {
|
||||
void initialize_shared_metaspaces();
|
||||
};
|
||||
|
||||
// An iterator that distributes Klasses to parallel worker threads.
|
||||
class ClassLoaderDataGraphKlassIteratorAtomic : public StackObj {
|
||||
volatile Klass* _next_klass;
|
||||
public:
|
||||
ClassLoaderDataGraphKlassIteratorAtomic();
|
||||
Klass* next_klass();
|
||||
private:
|
||||
static Klass* next_klass_in_cldg(Klass* klass);
|
||||
};
|
||||
|
||||
class ClassLoaderDataGraphMetaspaceIterator : public StackObj {
|
||||
ClassLoaderData* _data;
|
||||
public:
|
||||
|
@ -199,6 +199,26 @@ bool Dictionary::do_unloading() {
|
||||
return class_was_unloaded;
|
||||
}
|
||||
|
||||
void Dictionary::roots_oops_do(OopClosure* strong, OopClosure* weak) {
|
||||
// Skip the strong roots probe marking if the closures are the same.
|
||||
if (strong == weak) {
|
||||
oops_do(strong);
|
||||
return;
|
||||
}
|
||||
|
||||
for (int index = 0; index < table_size(); index++) {
|
||||
for (DictionaryEntry *probe = bucket(index);
|
||||
probe != NULL;
|
||||
probe = probe->next()) {
|
||||
Klass* e = probe->klass();
|
||||
ClassLoaderData* loader_data = probe->loader_data();
|
||||
if (is_strongly_reachable(loader_data, e)) {
|
||||
probe->set_strongly_reachable();
|
||||
}
|
||||
}
|
||||
}
|
||||
_pd_cache_table->roots_oops_do(strong, weak);
|
||||
}
|
||||
|
||||
void Dictionary::always_strong_oops_do(OopClosure* blk) {
|
||||
// Follow all system classes and temporary placeholders in dictionary; only
|
||||
@ -490,6 +510,23 @@ void ProtectionDomainCacheTable::oops_do(OopClosure* f) {
|
||||
}
|
||||
}
|
||||
|
||||
void ProtectionDomainCacheTable::roots_oops_do(OopClosure* strong, OopClosure* weak) {
|
||||
for (int index = 0; index < table_size(); index++) {
|
||||
for (ProtectionDomainCacheEntry* probe = bucket(index);
|
||||
probe != NULL;
|
||||
probe = probe->next()) {
|
||||
if (probe->is_strongly_reachable()) {
|
||||
probe->reset_strongly_reachable();
|
||||
probe->oops_do(strong);
|
||||
} else {
|
||||
if (weak != NULL) {
|
||||
probe->oops_do(weak);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
uint ProtectionDomainCacheTable::bucket_size() {
|
||||
return sizeof(ProtectionDomainCacheEntry);
|
||||
}
|
||||
|
@ -89,6 +89,7 @@ public:
|
||||
// GC support
|
||||
void oops_do(OopClosure* f);
|
||||
void always_strong_oops_do(OopClosure* blk);
|
||||
void roots_oops_do(OopClosure* strong, OopClosure* weak);
|
||||
|
||||
void always_strong_classes_do(KlassClosure* closure);
|
||||
|
||||
@ -218,6 +219,7 @@ public:
|
||||
// GC support
|
||||
void oops_do(OopClosure* f);
|
||||
void always_strong_oops_do(OopClosure* f);
|
||||
void roots_oops_do(OopClosure* strong, OopClosure* weak);
|
||||
|
||||
static uint bucket_size();
|
||||
|
||||
|
@ -47,8 +47,11 @@ MetadataOnStackMark::MetadataOnStackMark() {
|
||||
if (_marked_objects == NULL) {
|
||||
_marked_objects = new (ResourceObj::C_HEAP, mtClass) GrowableArray<Metadata*>(1000, true);
|
||||
}
|
||||
|
||||
Threads::metadata_do(Metadata::mark_on_stack);
|
||||
CodeCache::alive_nmethods_do(nmethod::mark_on_stack);
|
||||
if (JvmtiExport::has_redefined_a_class()) {
|
||||
CodeCache::alive_nmethods_do(nmethod::mark_on_stack);
|
||||
}
|
||||
CompileBroker::mark_on_stack();
|
||||
JvmtiCurrentBreakpoints::metadata_do(Metadata::mark_on_stack);
|
||||
ThreadService::metadata_do(Metadata::mark_on_stack);
|
||||
|
@ -37,6 +37,7 @@
|
||||
#include "runtime/mutexLocker.hpp"
|
||||
#include "utilities/hashtable.inline.hpp"
|
||||
#if INCLUDE_ALL_GCS
|
||||
#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
|
||||
#include "gc_implementation/g1/g1StringDedup.hpp"
|
||||
#endif
|
||||
|
||||
@ -157,11 +158,26 @@ oop StringTable::lookup(Symbol* symbol) {
|
||||
return lookup(chars, length);
|
||||
}
|
||||
|
||||
// Tell the GC that this string was looked up in the StringTable.
|
||||
static void ensure_string_alive(oop string) {
|
||||
// A lookup in the StringTable could return an object that was previously
|
||||
// considered dead. The SATB part of G1 needs to get notified about this
|
||||
// potential resurrection, otherwise the marking might not find the object.
|
||||
#if INCLUDE_ALL_GCS
|
||||
if (UseG1GC && string != NULL) {
|
||||
G1SATBCardTableModRefBS::enqueue(string);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
oop StringTable::lookup(jchar* name, int len) {
|
||||
unsigned int hash = hash_string(name, len);
|
||||
int index = the_table()->hash_to_index(hash);
|
||||
return the_table()->lookup(index, name, len, hash);
|
||||
oop string = the_table()->lookup(index, name, len, hash);
|
||||
|
||||
ensure_string_alive(string);
|
||||
|
||||
return string;
|
||||
}
|
||||
|
||||
|
||||
@ -172,7 +188,10 @@ oop StringTable::intern(Handle string_or_null, jchar* name,
|
||||
oop found_string = the_table()->lookup(index, name, len, hashValue);
|
||||
|
||||
// Found
|
||||
if (found_string != NULL) return found_string;
|
||||
if (found_string != NULL) {
|
||||
ensure_string_alive(found_string);
|
||||
return found_string;
|
||||
}
|
||||
|
||||
debug_only(StableMemoryChecker smc(name, len * sizeof(name[0])));
|
||||
assert(!Universe::heap()->is_in_reserved(name),
|
||||
@ -197,11 +216,17 @@ oop StringTable::intern(Handle string_or_null, jchar* name,
|
||||
|
||||
// Grab the StringTable_lock before getting the_table() because it could
|
||||
// change at safepoint.
|
||||
MutexLocker ml(StringTable_lock, THREAD);
|
||||
oop added_or_found;
|
||||
{
|
||||
MutexLocker ml(StringTable_lock, THREAD);
|
||||
// Otherwise, add to symbol to table
|
||||
added_or_found = the_table()->basic_add(index, string, name, len,
|
||||
hashValue, CHECK_NULL);
|
||||
}
|
||||
|
||||
// Otherwise, add to symbol to table
|
||||
return the_table()->basic_add(index, string, name, len,
|
||||
hashValue, CHECK_NULL);
|
||||
ensure_string_alive(added_or_found);
|
||||
|
||||
return added_or_found;
|
||||
}
|
||||
|
||||
oop StringTable::intern(Symbol* symbol, TRAPS) {
|
||||
|
@ -1612,13 +1612,7 @@ void SystemDictionary::add_to_hierarchy(instanceKlassHandle k, TRAPS) {
|
||||
// system dictionary and follows the remaining classes' contents.
|
||||
|
||||
void SystemDictionary::always_strong_oops_do(OopClosure* blk) {
|
||||
blk->do_oop(&_java_system_loader);
|
||||
blk->do_oop(&_system_loader_lock_obj);
|
||||
|
||||
dictionary()->always_strong_oops_do(blk);
|
||||
|
||||
// Visit extra methods
|
||||
invoke_method_table()->oops_do(blk);
|
||||
roots_oops_do(blk, NULL);
|
||||
}
|
||||
|
||||
void SystemDictionary::always_strong_classes_do(KlassClosure* closure) {
|
||||
@ -1685,6 +1679,17 @@ bool SystemDictionary::do_unloading(BoolObjectClosure* is_alive) {
|
||||
return unloading_occurred;
|
||||
}
|
||||
|
||||
void SystemDictionary::roots_oops_do(OopClosure* strong, OopClosure* weak) {
|
||||
strong->do_oop(&_java_system_loader);
|
||||
strong->do_oop(&_system_loader_lock_obj);
|
||||
|
||||
// Adjust dictionary
|
||||
dictionary()->roots_oops_do(strong, weak);
|
||||
|
||||
// Visit extra methods
|
||||
invoke_method_table()->oops_do(strong);
|
||||
}
|
||||
|
||||
void SystemDictionary::oops_do(OopClosure* f) {
|
||||
f->do_oop(&_java_system_loader);
|
||||
f->do_oop(&_system_loader_lock_obj);
|
||||
|
@ -330,6 +330,7 @@ public:
|
||||
|
||||
// Applies "f->do_oop" to all root oops in the system dictionary.
|
||||
static void oops_do(OopClosure* f);
|
||||
static void roots_oops_do(OopClosure* strong, OopClosure* weak);
|
||||
|
||||
// System loader lock
|
||||
static oop system_loader_lock() { return _system_loader_lock_obj; }
|
||||
|
@ -331,6 +331,11 @@ void CodeCache::blobs_do(CodeBlobClosure* f) {
|
||||
// Walk the list of methods which might contain non-perm oops.
|
||||
void CodeCache::scavenge_root_nmethods_do(CodeBlobClosure* f) {
|
||||
assert_locked_or_safepoint(CodeCache_lock);
|
||||
|
||||
if (UseG1GC) {
|
||||
return;
|
||||
}
|
||||
|
||||
debug_only(mark_scavenge_root_nmethods());
|
||||
|
||||
for (nmethod* cur = scavenge_root_nmethods(); cur != NULL; cur = cur->scavenge_root_link()) {
|
||||
@ -356,6 +361,11 @@ void CodeCache::scavenge_root_nmethods_do(CodeBlobClosure* f) {
|
||||
|
||||
void CodeCache::add_scavenge_root_nmethod(nmethod* nm) {
|
||||
assert_locked_or_safepoint(CodeCache_lock);
|
||||
|
||||
if (UseG1GC) {
|
||||
return;
|
||||
}
|
||||
|
||||
nm->set_on_scavenge_root_list();
|
||||
nm->set_scavenge_root_link(_scavenge_root_nmethods);
|
||||
set_scavenge_root_nmethods(nm);
|
||||
@ -364,6 +374,11 @@ void CodeCache::add_scavenge_root_nmethod(nmethod* nm) {
|
||||
|
||||
void CodeCache::drop_scavenge_root_nmethod(nmethod* nm) {
|
||||
assert_locked_or_safepoint(CodeCache_lock);
|
||||
|
||||
if (UseG1GC) {
|
||||
return;
|
||||
}
|
||||
|
||||
print_trace("drop_scavenge_root", nm);
|
||||
nmethod* last = NULL;
|
||||
nmethod* cur = scavenge_root_nmethods();
|
||||
@ -385,6 +400,11 @@ void CodeCache::drop_scavenge_root_nmethod(nmethod* nm) {
|
||||
|
||||
void CodeCache::prune_scavenge_root_nmethods() {
|
||||
assert_locked_or_safepoint(CodeCache_lock);
|
||||
|
||||
if (UseG1GC) {
|
||||
return;
|
||||
}
|
||||
|
||||
debug_only(mark_scavenge_root_nmethods());
|
||||
|
||||
nmethod* last = NULL;
|
||||
@ -417,6 +437,10 @@ void CodeCache::prune_scavenge_root_nmethods() {
|
||||
|
||||
#ifndef PRODUCT
|
||||
void CodeCache::asserted_non_scavengable_nmethods_do(CodeBlobClosure* f) {
|
||||
if (UseG1GC) {
|
||||
return;
|
||||
}
|
||||
|
||||
// While we are here, verify the integrity of the list.
|
||||
mark_scavenge_root_nmethods();
|
||||
for (nmethod* cur = scavenge_root_nmethods(); cur != NULL; cur = cur->scavenge_root_link()) {
|
||||
@ -457,9 +481,36 @@ void CodeCache::verify_perm_nmethods(CodeBlobClosure* f_or_null) {
|
||||
}
|
||||
#endif //PRODUCT
|
||||
|
||||
void CodeCache::verify_clean_inline_caches() {
|
||||
#ifdef ASSERT
|
||||
FOR_ALL_ALIVE_BLOBS(cb) {
|
||||
if (cb->is_nmethod()) {
|
||||
nmethod* nm = (nmethod*)cb;
|
||||
assert(!nm->is_unloaded(), "Tautology");
|
||||
nm->verify_clean_inline_caches();
|
||||
nm->verify();
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void CodeCache::verify_icholder_relocations() {
|
||||
#ifdef ASSERT
|
||||
// make sure that we aren't leaking icholders
|
||||
int count = 0;
|
||||
FOR_ALL_BLOBS(cb) {
|
||||
if (cb->is_nmethod()) {
|
||||
nmethod* nm = (nmethod*)cb;
|
||||
count += nm->verify_icholder_relocations();
|
||||
}
|
||||
}
|
||||
|
||||
assert(count + InlineCacheBuffer::pending_icholder_count() + CompiledICHolder::live_not_claimed_count() ==
|
||||
CompiledICHolder::live_count(), "must agree");
|
||||
#endif
|
||||
}
|
||||
|
||||
void CodeCache::gc_prologue() {
|
||||
assert(!nmethod::oops_do_marking_is_active(), "oops_do_marking_epilogue must be called");
|
||||
}
|
||||
|
||||
void CodeCache::gc_epilogue() {
|
||||
@ -472,41 +523,15 @@ void CodeCache::gc_epilogue() {
|
||||
nm->cleanup_inline_caches();
|
||||
}
|
||||
DEBUG_ONLY(nm->verify());
|
||||
nm->fix_oop_relocations();
|
||||
DEBUG_ONLY(nm->verify_oop_relocations());
|
||||
}
|
||||
}
|
||||
set_needs_cache_clean(false);
|
||||
prune_scavenge_root_nmethods();
|
||||
assert(!nmethod::oops_do_marking_is_active(), "oops_do_marking_prologue must be called");
|
||||
|
||||
#ifdef ASSERT
|
||||
// make sure that we aren't leaking icholders
|
||||
int count = 0;
|
||||
FOR_ALL_BLOBS(cb) {
|
||||
if (cb->is_nmethod()) {
|
||||
RelocIterator iter((nmethod*)cb);
|
||||
while(iter.next()) {
|
||||
if (iter.type() == relocInfo::virtual_call_type) {
|
||||
if (CompiledIC::is_icholder_call_site(iter.virtual_call_reloc())) {
|
||||
CompiledIC *ic = CompiledIC_at(iter.reloc());
|
||||
if (TraceCompiledIC) {
|
||||
tty->print("noticed icholder " INTPTR_FORMAT " ", p2i(ic->cached_icholder()));
|
||||
ic->print();
|
||||
}
|
||||
assert(ic->cached_icholder() != NULL, "must be non-NULL");
|
||||
count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
assert(count + InlineCacheBuffer::pending_icholder_count() + CompiledICHolder::live_not_claimed_count() ==
|
||||
CompiledICHolder::live_count(), "must agree");
|
||||
#endif
|
||||
verify_icholder_relocations();
|
||||
}
|
||||
|
||||
|
||||
void CodeCache::verify_oops() {
|
||||
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
|
||||
VerifyOopClosure voc;
|
||||
|
@ -134,10 +134,6 @@ class CodeCache : AllStatic {
|
||||
// to) any unmarked codeBlobs in the cache. Sets "marked_for_unloading"
|
||||
// to "true" iff some code got unloaded.
|
||||
static void do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred);
|
||||
static void oops_do(OopClosure* f) {
|
||||
CodeBlobToOopClosure oopc(f, /*do_marking=*/ false);
|
||||
blobs_do(&oopc);
|
||||
}
|
||||
static void asserted_non_scavengable_nmethods_do(CodeBlobClosure* f = NULL) PRODUCT_RETURN;
|
||||
static void scavenge_root_nmethods_do(CodeBlobClosure* f);
|
||||
|
||||
@ -173,6 +169,9 @@ class CodeCache : AllStatic {
|
||||
static void set_needs_cache_clean(bool v) { _needs_cache_clean = v; }
|
||||
static void clear_inline_caches(); // clear all inline caches
|
||||
|
||||
static void verify_clean_inline_caches();
|
||||
static void verify_icholder_relocations();
|
||||
|
||||
// Deoptimization
|
||||
static int mark_for_deoptimization(DepChange& changes);
|
||||
#ifdef HOTSWAP
|
||||
|
@ -99,13 +99,13 @@ void CompiledIC::internal_set_ic_destination(address entry_point, bool is_icstub
|
||||
}
|
||||
|
||||
{
|
||||
MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
|
||||
MutexLockerEx pl(SafepointSynchronize::is_at_safepoint() ? NULL : Patching_lock, Mutex::_no_safepoint_check_flag);
|
||||
#ifdef ASSERT
|
||||
CodeBlob* cb = CodeCache::find_blob_unsafe(_ic_call);
|
||||
assert(cb != NULL && cb->is_nmethod(), "must be nmethod");
|
||||
CodeBlob* cb = CodeCache::find_blob_unsafe(_ic_call);
|
||||
assert(cb != NULL && cb->is_nmethod(), "must be nmethod");
|
||||
#endif
|
||||
_ic_call->set_destination_mt_safe(entry_point);
|
||||
}
|
||||
_ic_call->set_destination_mt_safe(entry_point);
|
||||
}
|
||||
|
||||
if (is_optimized() || is_icstub) {
|
||||
// Optimized call sites don't have a cache value and ICStub call
|
||||
@ -159,10 +159,24 @@ address CompiledIC::stub_address() const {
|
||||
//-----------------------------------------------------------------------------
|
||||
// High-level access to an inline cache. Guaranteed to be MT-safe.
|
||||
|
||||
void CompiledIC::initialize_from_iter(RelocIterator* iter) {
|
||||
assert(iter->addr() == _ic_call->instruction_address(), "must find ic_call");
|
||||
|
||||
if (iter->type() == relocInfo::virtual_call_type) {
|
||||
virtual_call_Relocation* r = iter->virtual_call_reloc();
|
||||
_is_optimized = false;
|
||||
_value = nativeMovConstReg_at(r->cached_value());
|
||||
} else {
|
||||
assert(iter->type() == relocInfo::opt_virtual_call_type, "must be a virtual call");
|
||||
_is_optimized = true;
|
||||
_value = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
CompiledIC::CompiledIC(nmethod* nm, NativeCall* call)
|
||||
: _ic_call(call)
|
||||
{
|
||||
address ic_call = call->instruction_address();
|
||||
address ic_call = _ic_call->instruction_address();
|
||||
|
||||
assert(ic_call != NULL, "ic_call address must be set");
|
||||
assert(nm != NULL, "must pass nmethod");
|
||||
@ -173,15 +187,21 @@ CompiledIC::CompiledIC(nmethod* nm, NativeCall* call)
|
||||
bool ret = iter.next();
|
||||
assert(ret == true, "relocInfo must exist at this address");
|
||||
assert(iter.addr() == ic_call, "must find ic_call");
|
||||
if (iter.type() == relocInfo::virtual_call_type) {
|
||||
virtual_call_Relocation* r = iter.virtual_call_reloc();
|
||||
_is_optimized = false;
|
||||
_value = nativeMovConstReg_at(r->cached_value());
|
||||
} else {
|
||||
assert(iter.type() == relocInfo::opt_virtual_call_type, "must be a virtual call");
|
||||
_is_optimized = true;
|
||||
_value = NULL;
|
||||
}
|
||||
|
||||
initialize_from_iter(&iter);
|
||||
}
|
||||
|
||||
CompiledIC::CompiledIC(RelocIterator* iter)
|
||||
: _ic_call(nativeCall_at(iter->addr()))
|
||||
{
|
||||
address ic_call = _ic_call->instruction_address();
|
||||
|
||||
nmethod* nm = iter->code();
|
||||
assert(ic_call != NULL, "ic_call address must be set");
|
||||
assert(nm != NULL, "must pass nmethod");
|
||||
assert(nm->contains(ic_call), "must be in nmethod");
|
||||
|
||||
initialize_from_iter(iter);
|
||||
}
|
||||
|
||||
bool CompiledIC::set_to_megamorphic(CallInfo* call_info, Bytecodes::Code bytecode, TRAPS) {
|
||||
@ -509,7 +529,7 @@ bool CompiledIC::is_icholder_entry(address entry) {
|
||||
void CompiledStaticCall::set_to_clean() {
|
||||
assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
|
||||
// Reset call site
|
||||
MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
|
||||
MutexLockerEx pl(SafepointSynchronize::is_at_safepoint() ? NULL : Patching_lock, Mutex::_no_safepoint_check_flag);
|
||||
#ifdef ASSERT
|
||||
CodeBlob* cb = CodeCache::find_blob_unsafe(this);
|
||||
assert(cb != NULL && cb->is_nmethod(), "must be nmethod");
|
||||
|
@ -150,6 +150,9 @@ class CompiledIC: public ResourceObj {
|
||||
bool _is_optimized; // an optimized virtual call (i.e., no compiled IC)
|
||||
|
||||
CompiledIC(nmethod* nm, NativeCall* ic_call);
|
||||
CompiledIC(RelocIterator* iter);
|
||||
|
||||
void initialize_from_iter(RelocIterator* iter);
|
||||
|
||||
static bool is_icholder_entry(address entry);
|
||||
|
||||
@ -183,6 +186,7 @@ class CompiledIC: public ResourceObj {
|
||||
friend CompiledIC* CompiledIC_before(nmethod* nm, address return_addr);
|
||||
friend CompiledIC* CompiledIC_at(nmethod* nm, address call_site);
|
||||
friend CompiledIC* CompiledIC_at(Relocation* call_site);
|
||||
friend CompiledIC* CompiledIC_at(RelocIterator* reloc_iter);
|
||||
|
||||
// This is used to release CompiledICHolder*s from nmethods that
|
||||
// are about to be freed. The callsite might contain other stale
|
||||
@ -263,6 +267,13 @@ inline CompiledIC* CompiledIC_at(Relocation* call_site) {
|
||||
return c_ic;
|
||||
}
|
||||
|
||||
inline CompiledIC* CompiledIC_at(RelocIterator* reloc_iter) {
|
||||
assert(reloc_iter->type() == relocInfo::virtual_call_type ||
|
||||
reloc_iter->type() == relocInfo::opt_virtual_call_type, "wrong reloc. info");
|
||||
CompiledIC* c_ic = new CompiledIC(reloc_iter);
|
||||
c_ic->verify();
|
||||
return c_ic;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// The CompiledStaticCall represents a call to a static method in the compiled
|
||||
|
@ -51,6 +51,8 @@
|
||||
|
||||
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
|
||||
|
||||
unsigned char nmethod::_global_unloading_clock = 0;
|
||||
|
||||
#ifdef DTRACE_ENABLED
|
||||
|
||||
// Only bother with this argument setup if dtrace is available
|
||||
@ -446,6 +448,7 @@ const char* nmethod::compile_kind() const {
|
||||
// Fill in default values for various flag fields
|
||||
void nmethod::init_defaults() {
|
||||
_state = in_use;
|
||||
_unloading_clock = 0;
|
||||
_marked_for_reclamation = 0;
|
||||
_has_flushed_dependencies = 0;
|
||||
_has_unsafe_access = 0;
|
||||
@ -464,7 +467,11 @@ void nmethod::init_defaults() {
|
||||
_oops_do_mark_link = NULL;
|
||||
_jmethod_id = NULL;
|
||||
_osr_link = NULL;
|
||||
_scavenge_root_link = NULL;
|
||||
if (UseG1GC) {
|
||||
_unloading_next = NULL;
|
||||
} else {
|
||||
_scavenge_root_link = NULL;
|
||||
}
|
||||
_scavenge_root_state = 0;
|
||||
_compiler = NULL;
|
||||
#if INCLUDE_RTM_OPT
|
||||
@ -1146,7 +1153,7 @@ void nmethod::cleanup_inline_caches() {
|
||||
switch(iter.type()) {
|
||||
case relocInfo::virtual_call_type:
|
||||
case relocInfo::opt_virtual_call_type: {
|
||||
CompiledIC *ic = CompiledIC_at(iter.reloc());
|
||||
CompiledIC *ic = CompiledIC_at(&iter);
|
||||
// Ok, to lookup references to zombies here
|
||||
CodeBlob *cb = CodeCache::find_blob_unsafe(ic->ic_destination());
|
||||
if( cb != NULL && cb->is_nmethod() ) {
|
||||
@ -1170,6 +1177,77 @@ void nmethod::cleanup_inline_caches() {
|
||||
}
|
||||
}
|
||||
|
||||
void nmethod::verify_clean_inline_caches() {
|
||||
assert_locked_or_safepoint(CompiledIC_lock);
|
||||
|
||||
// If the method is not entrant or zombie then a JMP is plastered over the
|
||||
// first few bytes. If an oop in the old code was there, that oop
|
||||
// should not get GC'd. Skip the first few bytes of oops on
|
||||
// not-entrant methods.
|
||||
address low_boundary = verified_entry_point();
|
||||
if (!is_in_use()) {
|
||||
low_boundary += NativeJump::instruction_size;
|
||||
// %%% Note: On SPARC we patch only a 4-byte trap, not a full NativeJump.
|
||||
// This means that the low_boundary is going to be a little too high.
|
||||
// This shouldn't matter, since oops of non-entrant methods are never used.
|
||||
// In fact, why are we bothering to look at oops in a non-entrant method??
|
||||
}
|
||||
|
||||
ResourceMark rm;
|
||||
RelocIterator iter(this, low_boundary);
|
||||
while(iter.next()) {
|
||||
switch(iter.type()) {
|
||||
case relocInfo::virtual_call_type:
|
||||
case relocInfo::opt_virtual_call_type: {
|
||||
CompiledIC *ic = CompiledIC_at(&iter);
|
||||
// Ok, to lookup references to zombies here
|
||||
CodeBlob *cb = CodeCache::find_blob_unsafe(ic->ic_destination());
|
||||
if( cb != NULL && cb->is_nmethod() ) {
|
||||
nmethod* nm = (nmethod*)cb;
|
||||
// Verify that inline caches pointing to both zombie and not_entrant methods are clean
|
||||
if (!nm->is_in_use() || (nm->method()->code() != nm)) {
|
||||
assert(ic->is_clean(), "IC should be clean");
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case relocInfo::static_call_type: {
|
||||
CompiledStaticCall *csc = compiledStaticCall_at(iter.reloc());
|
||||
CodeBlob *cb = CodeCache::find_blob_unsafe(csc->destination());
|
||||
if( cb != NULL && cb->is_nmethod() ) {
|
||||
nmethod* nm = (nmethod*)cb;
|
||||
// Verify that inline caches pointing to both zombie and not_entrant methods are clean
|
||||
if (!nm->is_in_use() || (nm->method()->code() != nm)) {
|
||||
assert(csc->is_clean(), "IC should be clean");
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int nmethod::verify_icholder_relocations() {
|
||||
int count = 0;
|
||||
|
||||
RelocIterator iter(this);
|
||||
while(iter.next()) {
|
||||
if (iter.type() == relocInfo::virtual_call_type) {
|
||||
if (CompiledIC::is_icholder_call_site(iter.virtual_call_reloc())) {
|
||||
CompiledIC *ic = CompiledIC_at(&iter);
|
||||
if (TraceCompiledIC) {
|
||||
tty->print("noticed icholder " INTPTR_FORMAT " ", p2i(ic->cached_icholder()));
|
||||
ic->print();
|
||||
}
|
||||
assert(ic->cached_icholder() != NULL, "must be non-NULL");
|
||||
count++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
// This is a private interface with the sweeper.
|
||||
void nmethod::mark_as_seen_on_stack() {
|
||||
assert(is_alive(), "Must be an alive method");
|
||||
@ -1202,6 +1280,23 @@ void nmethod::inc_decompile_count() {
|
||||
mdo->inc_decompile_count();
|
||||
}
|
||||
|
||||
void nmethod::increase_unloading_clock() {
|
||||
_global_unloading_clock++;
|
||||
if (_global_unloading_clock == 0) {
|
||||
// _nmethods are allocated with _unloading_clock == 0,
|
||||
// so 0 is never used as a clock value.
|
||||
_global_unloading_clock = 1;
|
||||
}
|
||||
}
|
||||
|
||||
void nmethod::set_unloading_clock(unsigned char unloading_clock) {
|
||||
OrderAccess::release_store((volatile jubyte*)&_unloading_clock, unloading_clock);
|
||||
}
|
||||
|
||||
unsigned char nmethod::unloading_clock() {
|
||||
return (unsigned char)OrderAccess::load_acquire((volatile jubyte*)&_unloading_clock);
|
||||
}
|
||||
|
||||
void nmethod::make_unloaded(BoolObjectClosure* is_alive, oop cause) {
|
||||
|
||||
post_compiled_method_unload();
|
||||
@ -1247,6 +1342,10 @@ void nmethod::make_unloaded(BoolObjectClosure* is_alive, oop cause) {
|
||||
// for later on.
|
||||
CodeCache::set_needs_cache_clean(true);
|
||||
}
|
||||
|
||||
// Unregister must be done before the state change
|
||||
Universe::heap()->unregister_nmethod(this);
|
||||
|
||||
_state = unloaded;
|
||||
|
||||
// Log the unloading.
|
||||
@ -1590,6 +1689,35 @@ void nmethod::post_compiled_method_unload() {
|
||||
set_unload_reported();
|
||||
}
|
||||
|
||||
void static clean_ic_if_metadata_is_dead(CompiledIC *ic, BoolObjectClosure *is_alive) {
|
||||
if (ic->is_icholder_call()) {
|
||||
// The only exception is compiledICHolder oops which may
|
||||
// yet be marked below. (We check this further below).
|
||||
CompiledICHolder* cichk_oop = ic->cached_icholder();
|
||||
if (cichk_oop->holder_method()->method_holder()->is_loader_alive(is_alive) &&
|
||||
cichk_oop->holder_klass()->is_loader_alive(is_alive)) {
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
Metadata* ic_oop = ic->cached_metadata();
|
||||
if (ic_oop != NULL) {
|
||||
if (ic_oop->is_klass()) {
|
||||
if (((Klass*)ic_oop)->is_loader_alive(is_alive)) {
|
||||
return;
|
||||
}
|
||||
} else if (ic_oop->is_method()) {
|
||||
if (((Method*)ic_oop)->method_holder()->is_loader_alive(is_alive)) {
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
ShouldNotReachHere();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ic->set_to_clean();
|
||||
}
|
||||
|
||||
// This is called at the end of the strong tracing/marking phase of a
|
||||
// GC to unload an nmethod if it contains otherwise unreachable
|
||||
// oops.
|
||||
@ -1632,32 +1760,8 @@ void nmethod::do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred)
|
||||
RelocIterator iter(this, low_boundary);
|
||||
while(iter.next()) {
|
||||
if (iter.type() == relocInfo::virtual_call_type) {
|
||||
CompiledIC *ic = CompiledIC_at(iter.reloc());
|
||||
if (ic->is_icholder_call()) {
|
||||
// The only exception is compiledICHolder oops which may
|
||||
// yet be marked below. (We check this further below).
|
||||
CompiledICHolder* cichk_oop = ic->cached_icholder();
|
||||
if (cichk_oop->holder_method()->method_holder()->is_loader_alive(is_alive) &&
|
||||
cichk_oop->holder_klass()->is_loader_alive(is_alive)) {
|
||||
continue;
|
||||
}
|
||||
} else {
|
||||
Metadata* ic_oop = ic->cached_metadata();
|
||||
if (ic_oop != NULL) {
|
||||
if (ic_oop->is_klass()) {
|
||||
if (((Klass*)ic_oop)->is_loader_alive(is_alive)) {
|
||||
continue;
|
||||
}
|
||||
} else if (ic_oop->is_method()) {
|
||||
if (((Method*)ic_oop)->method_holder()->is_loader_alive(is_alive)) {
|
||||
continue;
|
||||
}
|
||||
} else {
|
||||
ShouldNotReachHere();
|
||||
}
|
||||
}
|
||||
}
|
||||
ic->set_to_clean();
|
||||
CompiledIC *ic = CompiledIC_at(&iter);
|
||||
clean_ic_if_metadata_is_dead(ic, is_alive);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1695,6 +1799,175 @@ void nmethod::do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred)
|
||||
verify_metadata_loaders(low_boundary, is_alive);
|
||||
}
|
||||
|
||||
template <class CompiledICorStaticCall>
|
||||
static bool clean_if_nmethod_is_unloaded(CompiledICorStaticCall *ic, address addr, BoolObjectClosure *is_alive, nmethod* from) {
|
||||
// Ok, to lookup references to zombies here
|
||||
CodeBlob *cb = CodeCache::find_blob_unsafe(addr);
|
||||
if (cb != NULL && cb->is_nmethod()) {
|
||||
nmethod* nm = (nmethod*)cb;
|
||||
|
||||
if (nm->unloading_clock() != nmethod::global_unloading_clock()) {
|
||||
// The nmethod has not been processed yet.
|
||||
return true;
|
||||
}
|
||||
|
||||
// Clean inline caches pointing to both zombie and not_entrant methods
|
||||
if (!nm->is_in_use() || (nm->method()->code() != nm)) {
|
||||
ic->set_to_clean();
|
||||
assert(ic->is_clean(), err_msg("nmethod " PTR_FORMAT "not clean %s", from, from->method()->name_and_sig_as_C_string()));
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool clean_if_nmethod_is_unloaded(CompiledIC *ic, BoolObjectClosure *is_alive, nmethod* from) {
|
||||
return clean_if_nmethod_is_unloaded(ic, ic->ic_destination(), is_alive, from);
|
||||
}
|
||||
|
||||
static bool clean_if_nmethod_is_unloaded(CompiledStaticCall *csc, BoolObjectClosure *is_alive, nmethod* from) {
|
||||
return clean_if_nmethod_is_unloaded(csc, csc->destination(), is_alive, from);
|
||||
}
|
||||
|
||||
bool nmethod::do_unloading_parallel(BoolObjectClosure* is_alive, bool unloading_occurred) {
|
||||
ResourceMark rm;
|
||||
|
||||
// Make sure the oop's ready to receive visitors
|
||||
assert(!is_zombie() && !is_unloaded(),
|
||||
"should not call follow on zombie or unloaded nmethod");
|
||||
|
||||
// If the method is not entrant then a JMP is plastered over the
|
||||
// first few bytes. If an oop in the old code was there, that oop
|
||||
// should not get GC'd. Skip the first few bytes of oops on
|
||||
// not-entrant methods.
|
||||
address low_boundary = verified_entry_point();
|
||||
if (is_not_entrant()) {
|
||||
low_boundary += NativeJump::instruction_size;
|
||||
// %%% Note: On SPARC we patch only a 4-byte trap, not a full NativeJump.
|
||||
// (See comment above.)
|
||||
}
|
||||
|
||||
// The RedefineClasses() API can cause the class unloading invariant
|
||||
// to no longer be true. See jvmtiExport.hpp for details.
|
||||
// Also, leave a debugging breadcrumb in local flag.
|
||||
bool a_class_was_redefined = JvmtiExport::has_redefined_a_class();
|
||||
if (a_class_was_redefined) {
|
||||
// This set of the unloading_occurred flag is done before the
|
||||
// call to post_compiled_method_unload() so that the unloading
|
||||
// of this nmethod is reported.
|
||||
unloading_occurred = true;
|
||||
}
|
||||
|
||||
// Exception cache
|
||||
clean_exception_cache(is_alive);
|
||||
|
||||
bool is_unloaded = false;
|
||||
bool postponed = false;
|
||||
|
||||
RelocIterator iter(this, low_boundary);
|
||||
while(iter.next()) {
|
||||
|
||||
switch (iter.type()) {
|
||||
|
||||
case relocInfo::virtual_call_type:
|
||||
if (unloading_occurred) {
|
||||
// If class unloading occurred we first iterate over all inline caches and
|
||||
// clear ICs where the cached oop is referring to an unloaded klass or method.
|
||||
clean_ic_if_metadata_is_dead(CompiledIC_at(&iter), is_alive);
|
||||
}
|
||||
|
||||
postponed |= clean_if_nmethod_is_unloaded(CompiledIC_at(&iter), is_alive, this);
|
||||
break;
|
||||
|
||||
case relocInfo::opt_virtual_call_type:
|
||||
postponed |= clean_if_nmethod_is_unloaded(CompiledIC_at(&iter), is_alive, this);
|
||||
break;
|
||||
|
||||
case relocInfo::static_call_type:
|
||||
postponed |= clean_if_nmethod_is_unloaded(compiledStaticCall_at(iter.reloc()), is_alive, this);
|
||||
break;
|
||||
|
||||
case relocInfo::oop_type:
|
||||
if (!is_unloaded) {
|
||||
// Unload check
|
||||
oop_Relocation* r = iter.oop_reloc();
|
||||
// Traverse those oops directly embedded in the code.
|
||||
// Other oops (oop_index>0) are seen as part of scopes_oops.
|
||||
assert(1 == (r->oop_is_immediate()) +
|
||||
(r->oop_addr() >= oops_begin() && r->oop_addr() < oops_end()),
|
||||
"oop must be found in exactly one place");
|
||||
if (r->oop_is_immediate() && r->oop_value() != NULL) {
|
||||
if (can_unload(is_alive, r->oop_addr(), unloading_occurred)) {
|
||||
is_unloaded = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
if (is_unloaded) {
|
||||
return postponed;
|
||||
}
|
||||
|
||||
// Scopes
|
||||
for (oop* p = oops_begin(); p < oops_end(); p++) {
|
||||
if (*p == Universe::non_oop_word()) continue; // skip non-oops
|
||||
if (can_unload(is_alive, p, unloading_occurred)) {
|
||||
is_unloaded = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (is_unloaded) {
|
||||
return postponed;
|
||||
}
|
||||
|
||||
// Ensure that all metadata is still alive
|
||||
verify_metadata_loaders(low_boundary, is_alive);
|
||||
|
||||
return postponed;
|
||||
}
|
||||
|
||||
void nmethod::do_unloading_parallel_postponed(BoolObjectClosure* is_alive, bool unloading_occurred) {
|
||||
ResourceMark rm;
|
||||
|
||||
// Make sure the oop's ready to receive visitors
|
||||
assert(!is_zombie(),
|
||||
"should not call follow on zombie nmethod");
|
||||
|
||||
// If the method is not entrant then a JMP is plastered over the
|
||||
// first few bytes. If an oop in the old code was there, that oop
|
||||
// should not get GC'd. Skip the first few bytes of oops on
|
||||
// not-entrant methods.
|
||||
address low_boundary = verified_entry_point();
|
||||
if (is_not_entrant()) {
|
||||
low_boundary += NativeJump::instruction_size;
|
||||
// %%% Note: On SPARC we patch only a 4-byte trap, not a full NativeJump.
|
||||
// (See comment above.)
|
||||
}
|
||||
|
||||
RelocIterator iter(this, low_boundary);
|
||||
while(iter.next()) {
|
||||
|
||||
switch (iter.type()) {
|
||||
|
||||
case relocInfo::virtual_call_type:
|
||||
clean_if_nmethod_is_unloaded(CompiledIC_at(&iter), is_alive, this);
|
||||
break;
|
||||
|
||||
case relocInfo::opt_virtual_call_type:
|
||||
clean_if_nmethod_is_unloaded(CompiledIC_at(&iter), is_alive, this);
|
||||
break;
|
||||
|
||||
case relocInfo::static_call_type:
|
||||
clean_if_nmethod_is_unloaded(compiledStaticCall_at(iter.reloc()), is_alive, this);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef ASSERT
|
||||
|
||||
class CheckClass : AllStatic {
|
||||
@ -1741,7 +2014,7 @@ void nmethod::verify_metadata_loaders(address low_boundary, BoolObjectClosure* i
|
||||
// compiled code is maintaining a link to dead metadata.
|
||||
address static_call_addr = NULL;
|
||||
if (iter.type() == relocInfo::opt_virtual_call_type) {
|
||||
CompiledIC* cic = CompiledIC_at(iter.reloc());
|
||||
CompiledIC* cic = CompiledIC_at(&iter);
|
||||
if (!cic->is_call_to_interpreted()) {
|
||||
static_call_addr = iter.addr();
|
||||
}
|
||||
@ -1793,7 +2066,7 @@ void nmethod::metadata_do(void f(Metadata*)) {
|
||||
}
|
||||
} else if (iter.type() == relocInfo::virtual_call_type) {
|
||||
// Check compiledIC holders associated with this nmethod
|
||||
CompiledIC *ic = CompiledIC_at(iter.reloc());
|
||||
CompiledIC *ic = CompiledIC_at(&iter);
|
||||
if (ic->is_icholder_call()) {
|
||||
CompiledICHolder* cichk = ic->cached_icholder();
|
||||
f(cichk->holder_method());
|
||||
@ -1911,7 +2184,7 @@ void nmethod::oops_do_marking_epilogue() {
|
||||
assert(cur != NULL, "not NULL-terminated");
|
||||
nmethod* next = cur->_oops_do_mark_link;
|
||||
cur->_oops_do_mark_link = NULL;
|
||||
cur->fix_oop_relocations();
|
||||
cur->verify_oop_relocations();
|
||||
NOT_PRODUCT(if (TraceScavenge) cur->print_on(tty, "oops_do, unmark"));
|
||||
cur = next;
|
||||
}
|
||||
@ -2479,6 +2752,10 @@ public:
|
||||
};
|
||||
|
||||
void nmethod::verify_scavenge_root_oops() {
|
||||
if (UseG1GC) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!on_scavenge_root_list()) {
|
||||
// Actually look inside, to verify the claim that it's clean.
|
||||
DebugScavengeRoot debug_scavenge_root(this);
|
||||
@ -2922,7 +3199,7 @@ void nmethod::print_calls(outputStream* st) {
|
||||
case relocInfo::virtual_call_type:
|
||||
case relocInfo::opt_virtual_call_type: {
|
||||
VerifyMutexLocker mc(CompiledIC_lock);
|
||||
CompiledIC_at(iter.reloc())->print();
|
||||
CompiledIC_at(&iter)->print();
|
||||
break;
|
||||
}
|
||||
case relocInfo::static_call_type:
|
||||
|
@ -111,6 +111,11 @@ class nmethod : public CodeBlob {
|
||||
friend class NMethodSweeper;
|
||||
friend class CodeCache; // scavengable oops
|
||||
private:
|
||||
|
||||
// GC support to help figure out if an nmethod has been
|
||||
// cleaned/unloaded by the current GC.
|
||||
static unsigned char _global_unloading_clock;
|
||||
|
||||
// Shared fields for all nmethod's
|
||||
Method* _method;
|
||||
int _entry_bci; // != InvocationEntryBci if this nmethod is an on-stack replacement method
|
||||
@ -118,7 +123,13 @@ class nmethod : public CodeBlob {
|
||||
|
||||
// To support simple linked-list chaining of nmethods:
|
||||
nmethod* _osr_link; // from InstanceKlass::osr_nmethods_head
|
||||
nmethod* _scavenge_root_link; // from CodeCache::scavenge_root_nmethods
|
||||
|
||||
union {
|
||||
// Used by G1 to chain nmethods.
|
||||
nmethod* _unloading_next;
|
||||
// Used by non-G1 GCs to chain nmethods.
|
||||
nmethod* _scavenge_root_link; // from CodeCache::scavenge_root_nmethods
|
||||
};
|
||||
|
||||
static nmethod* volatile _oops_do_mark_nmethods;
|
||||
nmethod* volatile _oops_do_mark_link;
|
||||
@ -180,6 +191,8 @@ class nmethod : public CodeBlob {
|
||||
// Protected by Patching_lock
|
||||
volatile unsigned char _state; // {alive, not_entrant, zombie, unloaded}
|
||||
|
||||
volatile unsigned char _unloading_clock; // Incremented after GC unloaded/cleaned the nmethod
|
||||
|
||||
#ifdef ASSERT
|
||||
bool _oops_are_stale; // indicates that it's no longer safe to access oops section
|
||||
#endif
|
||||
@ -437,6 +450,15 @@ class nmethod : public CodeBlob {
|
||||
bool unload_reported() { return _unload_reported; }
|
||||
void set_unload_reported() { _unload_reported = true; }
|
||||
|
||||
void set_unloading_next(nmethod* next) { _unloading_next = next; }
|
||||
nmethod* unloading_next() { return _unloading_next; }
|
||||
|
||||
static unsigned char global_unloading_clock() { return _global_unloading_clock; }
|
||||
static void increase_unloading_clock();
|
||||
|
||||
void set_unloading_clock(unsigned char unloading_clock);
|
||||
unsigned char unloading_clock();
|
||||
|
||||
bool is_marked_for_deoptimization() const { return _marked_for_deoptimization; }
|
||||
void mark_for_deoptimization() { _marked_for_deoptimization = true; }
|
||||
|
||||
@ -552,6 +574,10 @@ public:
|
||||
return (addr >= code_begin() && addr < verified_entry_point());
|
||||
}
|
||||
|
||||
// Verify calls to dead methods have been cleaned.
|
||||
void verify_clean_inline_caches();
|
||||
// Verify and count cached icholder relocations.
|
||||
int verify_icholder_relocations();
|
||||
// Check that all metadata is still alive
|
||||
void verify_metadata_loaders(address low_boundary, BoolObjectClosure* is_alive);
|
||||
|
||||
@ -577,6 +603,10 @@ public:
|
||||
|
||||
// GC support
|
||||
void do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred);
|
||||
// The parallel versions are used by G1.
|
||||
bool do_unloading_parallel(BoolObjectClosure* is_alive, bool unloading_occurred);
|
||||
void do_unloading_parallel_postponed(BoolObjectClosure* is_alive, bool unloading_occurred);
|
||||
// Unload a nmethod if the *root object is dead.
|
||||
bool can_unload(BoolObjectClosure* is_alive, oop* root, bool unloading_occurred);
|
||||
|
||||
void preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map,
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -1,477 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2004, 2013, 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSADAPTIVESIZEPOLICY_HPP
|
||||
#define SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSADAPTIVESIZEPOLICY_HPP
|
||||
|
||||
#include "gc_implementation/shared/adaptiveSizePolicy.hpp"
|
||||
#include "runtime/timer.hpp"
|
||||
|
||||
// This class keeps statistical information and computes the
|
||||
// size of the heap for the concurrent mark sweep collector.
|
||||
//
|
||||
// Cost for garbage collector include cost for
|
||||
// minor collection
|
||||
// concurrent collection
|
||||
// stop-the-world component
|
||||
// concurrent component
|
||||
// major compacting collection
|
||||
// uses decaying cost
|
||||
|
||||
// Forward decls
|
||||
class elapsedTimer;
|
||||
|
||||
class CMSAdaptiveSizePolicy : public AdaptiveSizePolicy {
|
||||
friend class CMSGCAdaptivePolicyCounters;
|
||||
friend class CMSCollector;
|
||||
private:
|
||||
|
||||
// Total number of processors available
|
||||
int _processor_count;
|
||||
// Number of processors used by the concurrent phases of GC
|
||||
// This number is assumed to be the same for all concurrent
|
||||
// phases.
|
||||
int _concurrent_processor_count;
|
||||
|
||||
// Time that the mutators run exclusive of a particular
|
||||
// phase. For example, the time the mutators run excluding
|
||||
// the time during which the cms collector runs concurrently
|
||||
// with the mutators.
|
||||
// Between end of most recent cms reset and start of initial mark
|
||||
// This may be redundant
|
||||
double _latest_cms_reset_end_to_initial_mark_start_secs;
|
||||
// Between end of the most recent initial mark and start of remark
|
||||
double _latest_cms_initial_mark_end_to_remark_start_secs;
|
||||
// Between end of most recent collection and start of
|
||||
// a concurrent collection
|
||||
double _latest_cms_collection_end_to_collection_start_secs;
|
||||
// Times of the concurrent phases of the most recent
|
||||
// concurrent collection
|
||||
double _latest_cms_concurrent_marking_time_secs;
|
||||
double _latest_cms_concurrent_precleaning_time_secs;
|
||||
double _latest_cms_concurrent_sweeping_time_secs;
|
||||
// Between end of most recent STW MSC and start of next STW MSC
|
||||
double _latest_cms_msc_end_to_msc_start_time_secs;
|
||||
// Between end of most recent MS and start of next MS
|
||||
// This does not include any time spent during a concurrent
|
||||
// collection.
|
||||
double _latest_cms_ms_end_to_ms_start;
|
||||
// Between start and end of the initial mark of the most recent
|
||||
// concurrent collection.
|
||||
double _latest_cms_initial_mark_start_to_end_time_secs;
|
||||
// Between start and end of the remark phase of the most recent
|
||||
// concurrent collection
|
||||
double _latest_cms_remark_start_to_end_time_secs;
|
||||
// Between start and end of the most recent MS STW marking phase
|
||||
double _latest_cms_ms_marking_start_to_end_time_secs;
|
||||
|
||||
// Pause time timers
|
||||
static elapsedTimer _STW_timer;
|
||||
// Concurrent collection timer. Used for total of all concurrent phases
|
||||
// during 1 collection cycle.
|
||||
static elapsedTimer _concurrent_timer;
|
||||
|
||||
// When the size of the generation is changed, the size
|
||||
// of the change will rounded up or down (depending on the
|
||||
// type of change) by this value.
|
||||
size_t _generation_alignment;
|
||||
|
||||
// If this variable is true, the size of the young generation
|
||||
// may be changed in order to reduce the pause(s) of the
|
||||
// collection of the tenured generation in order to meet the
|
||||
// pause time goal. It is common to change the size of the
|
||||
// tenured generation in order to meet the pause time goal
|
||||
// for the tenured generation. With the CMS collector for
|
||||
// the tenured generation, the size of the young generation
|
||||
// can have an significant affect on the pause times for collecting the
|
||||
// tenured generation.
|
||||
// This is a duplicate of a variable in PSAdaptiveSizePolicy. It
|
||||
// is duplicated because it is not clear that it is general enough
|
||||
// to go into AdaptiveSizePolicy.
|
||||
int _change_young_gen_for_maj_pauses;
|
||||
|
||||
// Variable that is set to true after a collection.
|
||||
bool _first_after_collection;
|
||||
|
||||
// Fraction of collections that are of each type
|
||||
double concurrent_fraction() const;
|
||||
double STW_msc_fraction() const;
|
||||
double STW_ms_fraction() const;
|
||||
|
||||
// This call cannot be put into the epilogue as long as some
|
||||
// of the counters can be set during concurrent phases.
|
||||
virtual void clear_generation_free_space_flags();
|
||||
|
||||
void set_first_after_collection() { _first_after_collection = true; }
|
||||
|
||||
protected:
|
||||
// Average of the sum of the concurrent times for
|
||||
// one collection in seconds.
|
||||
AdaptiveWeightedAverage* _avg_concurrent_time;
|
||||
// Average time between concurrent collections in seconds.
|
||||
AdaptiveWeightedAverage* _avg_concurrent_interval;
|
||||
// Average cost of the concurrent part of a collection
|
||||
// in seconds.
|
||||
AdaptiveWeightedAverage* _avg_concurrent_gc_cost;
|
||||
|
||||
// Average of the initial pause of a concurrent collection in seconds.
|
||||
AdaptivePaddedAverage* _avg_initial_pause;
|
||||
// Average of the remark pause of a concurrent collection in seconds.
|
||||
AdaptivePaddedAverage* _avg_remark_pause;
|
||||
|
||||
// Average of the stop-the-world (STW) (initial mark + remark)
|
||||
// times in seconds for concurrent collections.
|
||||
AdaptiveWeightedAverage* _avg_cms_STW_time;
|
||||
// Average of the STW collection cost for concurrent collections.
|
||||
AdaptiveWeightedAverage* _avg_cms_STW_gc_cost;
|
||||
|
||||
// Average of the bytes free at the start of the sweep.
|
||||
AdaptiveWeightedAverage* _avg_cms_free_at_sweep;
|
||||
// Average of the bytes free at the end of the collection.
|
||||
AdaptiveWeightedAverage* _avg_cms_free;
|
||||
// Average of the bytes promoted between cms collections.
|
||||
AdaptiveWeightedAverage* _avg_cms_promo;
|
||||
|
||||
// stop-the-world (STW) mark-sweep-compact
|
||||
// Average of the pause time in seconds for STW mark-sweep-compact
|
||||
// collections.
|
||||
AdaptiveWeightedAverage* _avg_msc_pause;
|
||||
// Average of the interval in seconds between STW mark-sweep-compact
|
||||
// collections.
|
||||
AdaptiveWeightedAverage* _avg_msc_interval;
|
||||
// Average of the collection costs for STW mark-sweep-compact
|
||||
// collections.
|
||||
AdaptiveWeightedAverage* _avg_msc_gc_cost;
|
||||
|
||||
// Averages for mark-sweep collections.
|
||||
// The collection may have started as a background collection
|
||||
// that completes in a stop-the-world (STW) collection.
|
||||
// Average of the pause time in seconds for mark-sweep
|
||||
// collections.
|
||||
AdaptiveWeightedAverage* _avg_ms_pause;
|
||||
// Average of the interval in seconds between mark-sweep
|
||||
// collections.
|
||||
AdaptiveWeightedAverage* _avg_ms_interval;
|
||||
// Average of the collection costs for mark-sweep
|
||||
// collections.
|
||||
AdaptiveWeightedAverage* _avg_ms_gc_cost;
|
||||
|
||||
// These variables contain a linear fit of
|
||||
// a generation size as the independent variable
|
||||
// and a pause time as the dependent variable.
|
||||
// For example _remark_pause_old_estimator
|
||||
// is a fit of the old generation size as the
|
||||
// independent variable and the remark pause
|
||||
// as the dependent variable.
|
||||
// remark pause time vs. cms gen size
|
||||
LinearLeastSquareFit* _remark_pause_old_estimator;
|
||||
// initial pause time vs. cms gen size
|
||||
LinearLeastSquareFit* _initial_pause_old_estimator;
|
||||
// remark pause time vs. young gen size
|
||||
LinearLeastSquareFit* _remark_pause_young_estimator;
|
||||
// initial pause time vs. young gen size
|
||||
LinearLeastSquareFit* _initial_pause_young_estimator;
|
||||
|
||||
// Accessors
|
||||
int processor_count() const { return _processor_count; }
|
||||
int concurrent_processor_count() const { return _concurrent_processor_count; }
|
||||
|
||||
AdaptiveWeightedAverage* avg_concurrent_time() const {
|
||||
return _avg_concurrent_time;
|
||||
}
|
||||
|
||||
AdaptiveWeightedAverage* avg_concurrent_interval() const {
|
||||
return _avg_concurrent_interval;
|
||||
}
|
||||
|
||||
AdaptiveWeightedAverage* avg_concurrent_gc_cost() const {
|
||||
return _avg_concurrent_gc_cost;
|
||||
}
|
||||
|
||||
AdaptiveWeightedAverage* avg_cms_STW_time() const {
|
||||
return _avg_cms_STW_time;
|
||||
}
|
||||
|
||||
AdaptiveWeightedAverage* avg_cms_STW_gc_cost() const {
|
||||
return _avg_cms_STW_gc_cost;
|
||||
}
|
||||
|
||||
AdaptivePaddedAverage* avg_initial_pause() const {
|
||||
return _avg_initial_pause;
|
||||
}
|
||||
|
||||
AdaptivePaddedAverage* avg_remark_pause() const {
|
||||
return _avg_remark_pause;
|
||||
}
|
||||
|
||||
AdaptiveWeightedAverage* avg_cms_free() const {
|
||||
return _avg_cms_free;
|
||||
}
|
||||
|
||||
AdaptiveWeightedAverage* avg_cms_free_at_sweep() const {
|
||||
return _avg_cms_free_at_sweep;
|
||||
}
|
||||
|
||||
AdaptiveWeightedAverage* avg_msc_pause() const {
|
||||
return _avg_msc_pause;
|
||||
}
|
||||
|
||||
AdaptiveWeightedAverage* avg_msc_interval() const {
|
||||
return _avg_msc_interval;
|
||||
}
|
||||
|
||||
AdaptiveWeightedAverage* avg_msc_gc_cost() const {
|
||||
return _avg_msc_gc_cost;
|
||||
}
|
||||
|
||||
AdaptiveWeightedAverage* avg_ms_pause() const {
|
||||
return _avg_ms_pause;
|
||||
}
|
||||
|
||||
AdaptiveWeightedAverage* avg_ms_interval() const {
|
||||
return _avg_ms_interval;
|
||||
}
|
||||
|
||||
AdaptiveWeightedAverage* avg_ms_gc_cost() const {
|
||||
return _avg_ms_gc_cost;
|
||||
}
|
||||
|
||||
LinearLeastSquareFit* remark_pause_old_estimator() {
|
||||
return _remark_pause_old_estimator;
|
||||
}
|
||||
LinearLeastSquareFit* initial_pause_old_estimator() {
|
||||
return _initial_pause_old_estimator;
|
||||
}
|
||||
LinearLeastSquareFit* remark_pause_young_estimator() {
|
||||
return _remark_pause_young_estimator;
|
||||
}
|
||||
LinearLeastSquareFit* initial_pause_young_estimator() {
|
||||
return _initial_pause_young_estimator;
|
||||
}
|
||||
|
||||
// These *slope() methods return the slope
|
||||
// m for the linear fit of an independent
|
||||
// variable vs. a dependent variable. For
|
||||
// example
|
||||
// remark_pause = m * old_generation_size + c
|
||||
// These may be used to determine if an
|
||||
// adjustment should be made to achieve a goal.
|
||||
// For example, if remark_pause_old_slope() is
|
||||
// positive, a reduction of the old generation
|
||||
// size has on average resulted in the reduction
|
||||
// of the remark pause.
|
||||
float remark_pause_old_slope() {
|
||||
return _remark_pause_old_estimator->slope();
|
||||
}
|
||||
|
||||
float initial_pause_old_slope() {
|
||||
return _initial_pause_old_estimator->slope();
|
||||
}
|
||||
|
||||
float remark_pause_young_slope() {
|
||||
return _remark_pause_young_estimator->slope();
|
||||
}
|
||||
|
||||
float initial_pause_young_slope() {
|
||||
return _initial_pause_young_estimator->slope();
|
||||
}
|
||||
|
||||
// Update estimators
|
||||
void update_minor_pause_old_estimator(double minor_pause_in_ms);
|
||||
|
||||
// Fraction of processors used by the concurrent phases.
|
||||
double concurrent_processor_fraction();
|
||||
|
||||
// Returns the total times for the concurrent part of the
|
||||
// latest collection in seconds.
|
||||
double concurrent_collection_time();
|
||||
|
||||
// Return the total times for the concurrent part of the
|
||||
// latest collection in seconds where the times of the various
|
||||
// concurrent phases are scaled by the processor fraction used
|
||||
// during the phase.
|
||||
double scaled_concurrent_collection_time();
|
||||
|
||||
// Dimensionless concurrent GC cost for all the concurrent phases.
|
||||
double concurrent_collection_cost(double interval_in_seconds);
|
||||
|
||||
// Dimensionless GC cost
|
||||
double collection_cost(double pause_in_seconds, double interval_in_seconds);
|
||||
|
||||
virtual GCPolicyKind kind() const { return _gc_cms_adaptive_size_policy; }
|
||||
|
||||
virtual double time_since_major_gc() const;
|
||||
|
||||
// This returns the maximum average for the concurrent, ms, and
|
||||
// msc collections. This is meant to be used for the calculation
|
||||
// of the decayed major gc cost and is not in general the
|
||||
// average of all the different types of major collections.
|
||||
virtual double major_gc_interval_average_for_decay() const;
|
||||
|
||||
public:
|
||||
CMSAdaptiveSizePolicy(size_t init_eden_size,
|
||||
size_t init_promo_size,
|
||||
size_t init_survivor_size,
|
||||
double max_gc_minor_pause_sec,
|
||||
double max_gc_pause_sec,
|
||||
uint gc_cost_ratio);
|
||||
|
||||
// The timers for the stop-the-world phases measure a total
|
||||
// stop-the-world time. The timer is started and stopped
|
||||
// for each phase but is only reset after the final checkpoint.
|
||||
void checkpoint_roots_initial_begin();
|
||||
void checkpoint_roots_initial_end(GCCause::Cause gc_cause);
|
||||
void checkpoint_roots_final_begin();
|
||||
void checkpoint_roots_final_end(GCCause::Cause gc_cause);
|
||||
|
||||
// Methods for gathering information about the
|
||||
// concurrent marking phase of the collection.
|
||||
// Records the mutator times and
|
||||
// resets the concurrent timer.
|
||||
void concurrent_marking_begin();
|
||||
// Resets concurrent phase timer in the begin methods and
|
||||
// saves the time for a phase in the end methods.
|
||||
void concurrent_marking_end();
|
||||
void concurrent_sweeping_begin();
|
||||
void concurrent_sweeping_end();
|
||||
// Similar to the above (e.g., concurrent_marking_end()) and
|
||||
// is used for both the precleaning an abortable precleaning
|
||||
// phases.
|
||||
void concurrent_precleaning_begin();
|
||||
void concurrent_precleaning_end();
|
||||
// Stops the concurrent phases time. Gathers
|
||||
// information and resets the timer.
|
||||
void concurrent_phases_end(GCCause::Cause gc_cause,
|
||||
size_t cur_eden,
|
||||
size_t cur_promo);
|
||||
|
||||
// Methods for gather information about STW Mark-Sweep-Compact
|
||||
void msc_collection_begin();
|
||||
void msc_collection_end(GCCause::Cause gc_cause);
|
||||
|
||||
// Methods for gather information about Mark-Sweep done
|
||||
// in the foreground.
|
||||
void ms_collection_begin();
|
||||
void ms_collection_end(GCCause::Cause gc_cause);
|
||||
|
||||
// Cost for a mark-sweep tenured gen collection done in the foreground
|
||||
double ms_gc_cost() const {
|
||||
return MAX2(0.0F, _avg_ms_gc_cost->average());
|
||||
}
|
||||
|
||||
// Cost of collecting the tenured generation. Includes
|
||||
// concurrent collection and STW collection costs
|
||||
double cms_gc_cost() const;
|
||||
|
||||
// Cost of STW mark-sweep-compact tenured gen collection.
|
||||
double msc_gc_cost() const {
|
||||
return MAX2(0.0F, _avg_msc_gc_cost->average());
|
||||
}
|
||||
|
||||
//
|
||||
double compacting_gc_cost() const {
|
||||
double result = MIN2(1.0, minor_gc_cost() + msc_gc_cost());
|
||||
assert(result >= 0.0, "Both minor and major costs are non-negative");
|
||||
return result;
|
||||
}
|
||||
|
||||
// Restarts the concurrent phases timer.
|
||||
void concurrent_phases_resume();
|
||||
|
||||
// Time beginning and end of the marking phase for
|
||||
// a synchronous MS collection. A MS collection
|
||||
// that finishes in the foreground can have started
|
||||
// in the background. These methods capture the
|
||||
// completion of the marking (after the initial
|
||||
// marking) that is done in the foreground.
|
||||
void ms_collection_marking_begin();
|
||||
void ms_collection_marking_end(GCCause::Cause gc_cause);
|
||||
|
||||
static elapsedTimer* concurrent_timer_ptr() {
|
||||
return &_concurrent_timer;
|
||||
}
|
||||
|
||||
AdaptiveWeightedAverage* avg_cms_promo() const {
|
||||
return _avg_cms_promo;
|
||||
}
|
||||
|
||||
int change_young_gen_for_maj_pauses() {
|
||||
return _change_young_gen_for_maj_pauses;
|
||||
}
|
||||
void set_change_young_gen_for_maj_pauses(int v) {
|
||||
_change_young_gen_for_maj_pauses = v;
|
||||
}
|
||||
|
||||
void clear_internal_time_intervals();
|
||||
|
||||
|
||||
// Either calculated_promo_size_in_bytes() or promo_size()
|
||||
// should be deleted.
|
||||
size_t promo_size() { return _promo_size; }
|
||||
void set_promo_size(size_t v) { _promo_size = v; }
|
||||
|
||||
// Cost of GC for all types of collections.
|
||||
virtual double gc_cost() const;
|
||||
|
||||
size_t generation_alignment() { return _generation_alignment; }
|
||||
|
||||
virtual void compute_eden_space_size(size_t cur_eden,
|
||||
size_t max_eden_size);
|
||||
// Calculates new survivor space size; returns a new tenuring threshold
|
||||
// value. Stores new survivor size in _survivor_size.
|
||||
virtual uint compute_survivor_space_size_and_threshold(
|
||||
bool is_survivor_overflow,
|
||||
uint tenuring_threshold,
|
||||
size_t survivor_limit);
|
||||
|
||||
virtual void compute_tenured_generation_free_space(size_t cur_tenured_free,
|
||||
size_t max_tenured_available,
|
||||
size_t cur_eden);
|
||||
|
||||
size_t eden_decrement_aligned_down(size_t cur_eden);
|
||||
size_t eden_increment_aligned_up(size_t cur_eden);
|
||||
|
||||
size_t adjust_eden_for_pause_time(size_t cur_eden);
|
||||
size_t adjust_eden_for_throughput(size_t cur_eden);
|
||||
size_t adjust_eden_for_footprint(size_t cur_eden);
|
||||
|
||||
size_t promo_decrement_aligned_down(size_t cur_promo);
|
||||
size_t promo_increment_aligned_up(size_t cur_promo);
|
||||
|
||||
size_t adjust_promo_for_pause_time(size_t cur_promo);
|
||||
size_t adjust_promo_for_throughput(size_t cur_promo);
|
||||
size_t adjust_promo_for_footprint(size_t cur_promo, size_t cur_eden);
|
||||
|
||||
// Scale down the input size by the ratio of the cost to collect the
|
||||
// generation to the total GC cost.
|
||||
size_t scale_by_gen_gc_cost(size_t base_change, double gen_gc_cost);
|
||||
|
||||
// Return the value and clear it.
|
||||
bool get_and_clear_first_after_collection();
|
||||
|
||||
// Printing support
|
||||
virtual bool print_adaptive_size_policy_on(outputStream* st) const;
|
||||
};
|
||||
|
||||
#endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSADAPTIVESIZEPOLICY_HPP
|
@ -23,9 +23,8 @@
|
||||
*/
|
||||
|
||||
#include "precompiled.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
|
||||
#include "gc_implementation/shared/adaptiveSizePolicy.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
|
||||
#include "gc_implementation/parNew/parNewGeneration.hpp"
|
||||
#include "gc_implementation/shared/gcPolicyCounters.hpp"
|
||||
#include "gc_implementation/shared/vmGCOperations.hpp"
|
||||
@ -57,25 +56,12 @@ void ConcurrentMarkSweepPolicy::initialize_generations() {
|
||||
if (_generations == NULL)
|
||||
vm_exit_during_initialization("Unable to allocate gen spec");
|
||||
|
||||
if (UseParNewGC) {
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
_generations[0] = new GenerationSpec(Generation::ASParNew,
|
||||
_initial_young_size, _max_young_size);
|
||||
} else {
|
||||
_generations[0] = new GenerationSpec(Generation::ParNew,
|
||||
_initial_young_size, _max_young_size);
|
||||
}
|
||||
} else {
|
||||
_generations[0] = new GenerationSpec(Generation::DefNew,
|
||||
_initial_young_size, _max_young_size);
|
||||
}
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
_generations[1] = new GenerationSpec(Generation::ASConcurrentMarkSweep,
|
||||
_initial_old_size, _max_old_size);
|
||||
} else {
|
||||
_generations[1] = new GenerationSpec(Generation::ConcurrentMarkSweep,
|
||||
_initial_old_size, _max_old_size);
|
||||
}
|
||||
Generation::Name yg_name =
|
||||
UseParNewGC ? Generation::ParNew : Generation::DefNew;
|
||||
_generations[0] = new GenerationSpec(yg_name, _initial_young_size,
|
||||
_max_young_size);
|
||||
_generations[1] = new GenerationSpec(Generation::ConcurrentMarkSweep,
|
||||
_initial_old_size, _max_old_size);
|
||||
|
||||
if (_generations[0] == NULL || _generations[1] == NULL) {
|
||||
vm_exit_during_initialization("Unable to allocate gen spec");
|
||||
@ -85,14 +71,12 @@ void ConcurrentMarkSweepPolicy::initialize_generations() {
|
||||
void ConcurrentMarkSweepPolicy::initialize_size_policy(size_t init_eden_size,
|
||||
size_t init_promo_size,
|
||||
size_t init_survivor_size) {
|
||||
double max_gc_minor_pause_sec = ((double) MaxGCMinorPauseMillis)/1000.0;
|
||||
double max_gc_pause_sec = ((double) MaxGCPauseMillis)/1000.0;
|
||||
_size_policy = new CMSAdaptiveSizePolicy(init_eden_size,
|
||||
init_promo_size,
|
||||
init_survivor_size,
|
||||
max_gc_minor_pause_sec,
|
||||
max_gc_pause_sec,
|
||||
GCTimeRatio);
|
||||
_size_policy = new AdaptiveSizePolicy(init_eden_size,
|
||||
init_promo_size,
|
||||
init_survivor_size,
|
||||
max_gc_pause_sec,
|
||||
GCTimeRatio);
|
||||
}
|
||||
|
||||
void ConcurrentMarkSweepPolicy::initialize_gc_policy_counters() {
|
||||
@ -110,22 +94,3 @@ bool ConcurrentMarkSweepPolicy::has_soft_ended_eden()
|
||||
{
|
||||
return CMSIncrementalMode;
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// ASConcurrentMarkSweepPolicy methods
|
||||
//
|
||||
|
||||
void ASConcurrentMarkSweepPolicy::initialize_gc_policy_counters() {
|
||||
|
||||
assert(size_policy() != NULL, "A size policy is required");
|
||||
// initialize the policy counters - 2 collectors, 3 generations
|
||||
if (UseParNewGC) {
|
||||
_gc_policy_counters = new CMSGCAdaptivePolicyCounters("ParNew:CMS", 2, 3,
|
||||
size_policy());
|
||||
}
|
||||
else {
|
||||
_gc_policy_counters = new CMSGCAdaptivePolicyCounters("Copy:CMS", 2, 3,
|
||||
size_policy());
|
||||
}
|
||||
}
|
||||
|
@ -47,19 +47,4 @@ class ConcurrentMarkSweepPolicy : public GenCollectorPolicy {
|
||||
virtual bool has_soft_ended_eden();
|
||||
};
|
||||
|
||||
class ASConcurrentMarkSweepPolicy : public ConcurrentMarkSweepPolicy {
|
||||
public:
|
||||
|
||||
// Initialize the jstat counters. This method requires a
|
||||
// size policy. The size policy is expected to be created
|
||||
// after the generations are fully initialized so the
|
||||
// initialization of the counters need to be done post
|
||||
// the initialization of the generations.
|
||||
void initialize_gc_policy_counters();
|
||||
|
||||
virtual CollectorPolicy::Name kind() {
|
||||
return CollectorPolicy::ASConcurrentMarkSweepPolicyKind;
|
||||
}
|
||||
};
|
||||
|
||||
#endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSCOLLECTORPOLICY_HPP
|
||||
|
@ -1,303 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2004, 2010, 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "precompiled.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
|
||||
#include "memory/resourceArea.hpp"
|
||||
|
||||
CMSGCAdaptivePolicyCounters::CMSGCAdaptivePolicyCounters(const char* name_arg,
|
||||
int collectors,
|
||||
int generations,
|
||||
AdaptiveSizePolicy* size_policy_arg)
|
||||
: GCAdaptivePolicyCounters(name_arg,
|
||||
collectors,
|
||||
generations,
|
||||
size_policy_arg) {
|
||||
if (UsePerfData) {
|
||||
EXCEPTION_MARK;
|
||||
ResourceMark rm;
|
||||
|
||||
const char* cname =
|
||||
PerfDataManager::counter_name(name_space(), "cmsCapacity");
|
||||
_cms_capacity_counter = PerfDataManager::create_variable(SUN_GC, cname,
|
||||
PerfData::U_Bytes, (jlong) OldSize, CHECK);
|
||||
#ifdef NOT_PRODUCT
|
||||
cname =
|
||||
PerfDataManager::counter_name(name_space(), "initialPause");
|
||||
_initial_pause_counter = PerfDataManager::create_variable(SUN_GC, cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_initial_pause()->last_sample(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "remarkPause");
|
||||
_remark_pause_counter = PerfDataManager::create_variable(SUN_GC, cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_remark_pause()->last_sample(),
|
||||
CHECK);
|
||||
#endif
|
||||
cname =
|
||||
PerfDataManager::counter_name(name_space(), "avgInitialPause");
|
||||
_avg_initial_pause_counter = PerfDataManager::create_variable(SUN_GC, cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_initial_pause()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgRemarkPause");
|
||||
_avg_remark_pause_counter = PerfDataManager::create_variable(SUN_GC, cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_remark_pause()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgSTWGcCost");
|
||||
_avg_cms_STW_gc_cost_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_cms_STW_gc_cost()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgSTWTime");
|
||||
_avg_cms_STW_time_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_cms_STW_time()->average(),
|
||||
CHECK);
|
||||
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgConcurrentTime");
|
||||
_avg_concurrent_time_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_concurrent_time()->average(),
|
||||
CHECK);
|
||||
|
||||
cname =
|
||||
PerfDataManager::counter_name(name_space(), "avgConcurrentInterval");
|
||||
_avg_concurrent_interval_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_concurrent_interval()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgConcurrentGcCost");
|
||||
_avg_concurrent_gc_cost_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_concurrent_gc_cost()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgCMSFreeAtSweep");
|
||||
_avg_cms_free_at_sweep_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_cms_free_at_sweep()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgCMSFree");
|
||||
_avg_cms_free_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_cms_free()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgCMSPromo");
|
||||
_avg_cms_promo_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_cms_promo()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgMscPause");
|
||||
_avg_msc_pause_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_msc_pause()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgMscInterval");
|
||||
_avg_msc_interval_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_msc_interval()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "mscGcCost");
|
||||
_msc_gc_cost_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_msc_gc_cost()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgMsPause");
|
||||
_avg_ms_pause_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_ms_pause()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgMsInterval");
|
||||
_avg_ms_interval_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_ms_interval()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "msGcCost");
|
||||
_ms_gc_cost_counter = PerfDataManager::create_variable(SUN_GC,
|
||||
cname,
|
||||
PerfData::U_Ticks,
|
||||
(jlong) cms_size_policy()->avg_ms_gc_cost()->average(),
|
||||
CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "majorGcCost");
|
||||
_major_gc_cost_counter = PerfDataManager::create_variable(SUN_GC, cname,
|
||||
PerfData::U_Ticks, (jlong) cms_size_policy()->cms_gc_cost(), CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgPromotedAvg");
|
||||
_promoted_avg_counter =
|
||||
PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
|
||||
cms_size_policy()->calculated_promo_size_in_bytes(), CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgPromotedDev");
|
||||
_promoted_avg_dev_counter =
|
||||
PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
|
||||
(jlong) 0 , CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "avgPromotedPaddedAvg");
|
||||
_promoted_padded_avg_counter =
|
||||
PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
|
||||
cms_size_policy()->calculated_promo_size_in_bytes(), CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(),
|
||||
"changeYoungGenForMajPauses");
|
||||
_change_young_gen_for_maj_pauses_counter =
|
||||
PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Events,
|
||||
(jlong)0, CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "remarkPauseOldSlope");
|
||||
_remark_pause_old_slope_counter =
|
||||
PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
|
||||
(jlong) cms_size_policy()->remark_pause_old_slope(), CHECK);
|
||||
|
||||
cname = PerfDataManager::counter_name(name_space(), "initialPauseOldSlope");
|
||||
_initial_pause_old_slope_counter =
|
||||
PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
|
||||
(jlong) cms_size_policy()->initial_pause_old_slope(), CHECK);
|
||||
|
||||
cname =
|
||||
PerfDataManager::counter_name(name_space(), "remarkPauseYoungSlope") ;
|
||||
_remark_pause_young_slope_counter =
|
||||
PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
|
||||
(jlong) cms_size_policy()->remark_pause_young_slope(), CHECK);
|
||||
|
||||
cname =
|
||||
PerfDataManager::counter_name(name_space(), "initialPauseYoungSlope");
|
||||
_initial_pause_young_slope_counter =
|
||||
PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,
|
||||
(jlong) cms_size_policy()->initial_pause_young_slope(), CHECK);
|
||||
|
||||
|
||||
}
|
||||
assert(size_policy()->is_gc_cms_adaptive_size_policy(),
|
||||
"Wrong type of size policy");
|
||||
}
|
||||
|
||||
void CMSGCAdaptivePolicyCounters::update_counters() {
|
||||
if (UsePerfData) {
|
||||
GCAdaptivePolicyCounters::update_counters_from_policy();
|
||||
update_counters_from_policy();
|
||||
}
|
||||
}
|
||||
|
||||
void CMSGCAdaptivePolicyCounters::update_counters(CMSGCStats* gc_stats) {
|
||||
if (UsePerfData) {
|
||||
update_counters();
|
||||
update_promoted((size_t) gc_stats->avg_promoted()->last_sample());
|
||||
update_avg_promoted_avg(gc_stats);
|
||||
update_avg_promoted_dev(gc_stats);
|
||||
update_avg_promoted_padded_avg(gc_stats);
|
||||
}
|
||||
}
|
||||
|
||||
void CMSGCAdaptivePolicyCounters::update_counters_from_policy() {
|
||||
if (UsePerfData && (cms_size_policy() != NULL)) {
|
||||
|
||||
GCAdaptivePolicyCounters::update_counters_from_policy();
|
||||
|
||||
update_major_gc_cost_counter();
|
||||
update_mutator_cost_counter();
|
||||
|
||||
update_eden_size();
|
||||
update_promo_size();
|
||||
|
||||
// If these updates from the last_sample() work,
|
||||
// revise the update methods for these counters
|
||||
// (both here and in PS).
|
||||
update_survived((size_t) cms_size_policy()->avg_survived()->last_sample());
|
||||
|
||||
update_avg_concurrent_time_counter();
|
||||
update_avg_concurrent_interval_counter();
|
||||
update_avg_concurrent_gc_cost_counter();
|
||||
#ifdef NOT_PRODUCT
|
||||
update_initial_pause_counter();
|
||||
update_remark_pause_counter();
|
||||
#endif
|
||||
update_avg_initial_pause_counter();
|
||||
update_avg_remark_pause_counter();
|
||||
|
||||
update_avg_cms_STW_time_counter();
|
||||
update_avg_cms_STW_gc_cost_counter();
|
||||
|
||||
update_avg_cms_free_counter();
|
||||
update_avg_cms_free_at_sweep_counter();
|
||||
update_avg_cms_promo_counter();
|
||||
|
||||
update_avg_msc_pause_counter();
|
||||
update_avg_msc_interval_counter();
|
||||
update_msc_gc_cost_counter();
|
||||
|
||||
update_avg_ms_pause_counter();
|
||||
update_avg_ms_interval_counter();
|
||||
update_ms_gc_cost_counter();
|
||||
|
||||
update_avg_old_live_counter();
|
||||
|
||||
update_survivor_size_counters();
|
||||
update_avg_survived_avg_counters();
|
||||
update_avg_survived_dev_counters();
|
||||
|
||||
update_decrement_tenuring_threshold_for_gc_cost();
|
||||
update_increment_tenuring_threshold_for_gc_cost();
|
||||
update_decrement_tenuring_threshold_for_survivor_limit();
|
||||
|
||||
update_change_young_gen_for_maj_pauses();
|
||||
|
||||
update_major_collection_slope_counter();
|
||||
update_remark_pause_old_slope_counter();
|
||||
update_initial_pause_old_slope_counter();
|
||||
update_remark_pause_young_slope_counter();
|
||||
update_initial_pause_young_slope_counter();
|
||||
|
||||
update_decide_at_full_gc_counter();
|
||||
}
|
||||
}
|
@ -1,308 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2004, 2010, 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSGCADAPTIVEPOLICYCOUNTERS_HPP
|
||||
#define SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSGCADAPTIVEPOLICYCOUNTERS_HPP
|
||||
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
|
||||
#include "gc_implementation/shared/gcAdaptivePolicyCounters.hpp"
|
||||
#include "gc_implementation/shared/gcStats.hpp"
|
||||
#include "runtime/perfData.hpp"
|
||||
|
||||
// CMSGCAdaptivePolicyCounters is a holder class for performance counters
|
||||
// that track the data and decisions for the ergonomics policy for the
|
||||
// concurrent mark sweep collector
|
||||
|
||||
class CMSGCAdaptivePolicyCounters : public GCAdaptivePolicyCounters {
|
||||
friend class VMStructs;
|
||||
|
||||
private:
|
||||
|
||||
// Capacity of tenured generation recorded at the end of
|
||||
// any collection.
|
||||
PerfVariable* _cms_capacity_counter; // Make this common with PS _old_capacity
|
||||
|
||||
// Average stop-the-world pause time for both initial and
|
||||
// remark pauses sampled at the end of the checkpointRootsFinalWork.
|
||||
PerfVariable* _avg_cms_STW_time_counter;
|
||||
// Average stop-the-world (STW) GC cost for the STW pause time
|
||||
// _avg_cms_STW_time_counter.
|
||||
PerfVariable* _avg_cms_STW_gc_cost_counter;
|
||||
|
||||
#ifdef NOT_PRODUCT
|
||||
// These are useful to see how the most recent values of these
|
||||
// counters compare to their respective averages but
|
||||
// do not control behavior.
|
||||
PerfVariable* _initial_pause_counter;
|
||||
PerfVariable* _remark_pause_counter;
|
||||
#endif
|
||||
|
||||
// Average of the initial marking pause for a concurrent collection.
|
||||
PerfVariable* _avg_initial_pause_counter;
|
||||
// Average of the remark pause for a concurrent collection.
|
||||
PerfVariable* _avg_remark_pause_counter;
|
||||
|
||||
// Average for the sum of all the concurrent times per collection.
|
||||
PerfVariable* _avg_concurrent_time_counter;
|
||||
// Average for the time between the most recent end of a
|
||||
// concurrent collection and the beginning of the next
|
||||
// concurrent collection.
|
||||
PerfVariable* _avg_concurrent_interval_counter;
|
||||
// Average of the concurrent GC costs based on _avg_concurrent_time_counter
|
||||
// and _avg_concurrent_interval_counter.
|
||||
PerfVariable* _avg_concurrent_gc_cost_counter;
|
||||
|
||||
// Average of the free space in the tenured generation at the
|
||||
// end of the sweep of the tenured generation.
|
||||
PerfVariable* _avg_cms_free_counter;
|
||||
// Average of the free space in the tenured generation at the
|
||||
// start of the sweep of the tenured generation.
|
||||
PerfVariable* _avg_cms_free_at_sweep_counter;
|
||||
// Average of the free space in the tenured generation at the
|
||||
// after any resizing of the tenured generation at the end
|
||||
// of a collection of the tenured generation.
|
||||
PerfVariable* _avg_cms_promo_counter;
|
||||
|
||||
// Average of the mark-sweep-compact (MSC) pause time for a collection
|
||||
// of the tenured generation.
|
||||
PerfVariable* _avg_msc_pause_counter;
|
||||
// Average for the time between the most recent end of a
|
||||
// MSC collection and the beginning of the next MSC collection.
|
||||
PerfVariable* _avg_msc_interval_counter;
|
||||
// Average for the GC cost of a MSC collection based on
|
||||
// _avg_msc_pause_counter and _avg_msc_interval_counter.
|
||||
PerfVariable* _msc_gc_cost_counter;
|
||||
|
||||
// Average of the mark-sweep (MS) pause time for a collection
|
||||
// of the tenured generation.
|
||||
PerfVariable* _avg_ms_pause_counter;
|
||||
// Average for the time between the most recent end of a
|
||||
// MS collection and the beginning of the next MS collection.
|
||||
PerfVariable* _avg_ms_interval_counter;
|
||||
// Average for the GC cost of a MS collection based on
|
||||
// _avg_ms_pause_counter and _avg_ms_interval_counter.
|
||||
PerfVariable* _ms_gc_cost_counter;
|
||||
|
||||
// Average of the bytes promoted per minor collection.
|
||||
PerfVariable* _promoted_avg_counter;
|
||||
// Average of the deviation of the promoted average.
|
||||
PerfVariable* _promoted_avg_dev_counter;
|
||||
// Padded average of the bytes promoted per minor collection.
|
||||
PerfVariable* _promoted_padded_avg_counter;
|
||||
|
||||
// See description of the _change_young_gen_for_maj_pauses
|
||||
// variable recently in cmsAdaptiveSizePolicy.hpp.
|
||||
PerfVariable* _change_young_gen_for_maj_pauses_counter;
|
||||
|
||||
// See descriptions of _remark_pause_old_slope, _initial_pause_old_slope,
|
||||
// etc. variables recently in cmsAdaptiveSizePolicy.hpp.
|
||||
PerfVariable* _remark_pause_old_slope_counter;
|
||||
PerfVariable* _initial_pause_old_slope_counter;
|
||||
PerfVariable* _remark_pause_young_slope_counter;
|
||||
PerfVariable* _initial_pause_young_slope_counter;
|
||||
|
||||
CMSAdaptiveSizePolicy* cms_size_policy() {
|
||||
assert(_size_policy->kind() ==
|
||||
AdaptiveSizePolicy::_gc_cms_adaptive_size_policy,
|
||||
"Wrong size policy");
|
||||
return (CMSAdaptiveSizePolicy*)_size_policy;
|
||||
}
|
||||
|
||||
inline void update_avg_cms_STW_time_counter() {
|
||||
_avg_cms_STW_time_counter->set_value(
|
||||
(jlong) (cms_size_policy()->avg_cms_STW_time()->average() *
|
||||
(double) MILLIUNITS));
|
||||
}
|
||||
|
||||
inline void update_avg_cms_STW_gc_cost_counter() {
|
||||
_avg_cms_STW_gc_cost_counter->set_value(
|
||||
(jlong) (cms_size_policy()->avg_cms_STW_gc_cost()->average() * 100.0));
|
||||
}
|
||||
|
||||
inline void update_avg_initial_pause_counter() {
|
||||
_avg_initial_pause_counter->set_value(
|
||||
(jlong) (cms_size_policy()->avg_initial_pause()->average() *
|
||||
(double) MILLIUNITS));
|
||||
}
|
||||
#ifdef NOT_PRODUCT
|
||||
inline void update_avg_remark_pause_counter() {
|
||||
_avg_remark_pause_counter->set_value(
|
||||
(jlong) (cms_size_policy()-> avg_remark_pause()->average() *
|
||||
(double) MILLIUNITS));
|
||||
}
|
||||
|
||||
inline void update_initial_pause_counter() {
|
||||
_initial_pause_counter->set_value(
|
||||
(jlong) (cms_size_policy()->avg_initial_pause()->average() *
|
||||
(double) MILLIUNITS));
|
||||
}
|
||||
#endif
|
||||
inline void update_remark_pause_counter() {
|
||||
_remark_pause_counter->set_value(
|
||||
(jlong) (cms_size_policy()-> avg_remark_pause()->last_sample() *
|
||||
(double) MILLIUNITS));
|
||||
}
|
||||
|
||||
inline void update_avg_concurrent_time_counter() {
|
||||
_avg_concurrent_time_counter->set_value(
|
||||
(jlong) (cms_size_policy()->avg_concurrent_time()->last_sample() *
|
||||
(double) MILLIUNITS));
|
||||
}
|
||||
|
||||
inline void update_avg_concurrent_interval_counter() {
|
||||
_avg_concurrent_interval_counter->set_value(
|
||||
(jlong) (cms_size_policy()->avg_concurrent_interval()->average() *
|
||||
(double) MILLIUNITS));
|
||||
}
|
||||
|
||||
inline void update_avg_concurrent_gc_cost_counter() {
|
||||
_avg_concurrent_gc_cost_counter->set_value(
|
||||
(jlong) (cms_size_policy()->avg_concurrent_gc_cost()->average() * 100.0));
|
||||
}
|
||||
|
||||
inline void update_avg_cms_free_counter() {
|
||||
_avg_cms_free_counter->set_value(
|
||||
(jlong) cms_size_policy()->avg_cms_free()->average());
|
||||
}
|
||||
|
||||
inline void update_avg_cms_free_at_sweep_counter() {
|
||||
_avg_cms_free_at_sweep_counter->set_value(
|
||||
(jlong) cms_size_policy()->avg_cms_free_at_sweep()->average());
|
||||
}
|
||||
|
||||
inline void update_avg_cms_promo_counter() {
|
||||
_avg_cms_promo_counter->set_value(
|
||||
(jlong) cms_size_policy()->avg_cms_promo()->average());
|
||||
}
|
||||
|
||||
inline void update_avg_old_live_counter() {
|
||||
_avg_old_live_counter->set_value(
|
||||
(jlong)(cms_size_policy()->avg_old_live()->average())
|
||||
);
|
||||
}
|
||||
|
||||
inline void update_avg_msc_pause_counter() {
|
||||
_avg_msc_pause_counter->set_value(
|
||||
(jlong) (cms_size_policy()->avg_msc_pause()->average() *
|
||||
(double) MILLIUNITS));
|
||||
}
|
||||
|
||||
inline void update_avg_msc_interval_counter() {
|
||||
_avg_msc_interval_counter->set_value(
|
||||
(jlong) (cms_size_policy()->avg_msc_interval()->average() *
|
||||
(double) MILLIUNITS));
|
||||
}
|
||||
|
||||
inline void update_msc_gc_cost_counter() {
|
||||
_msc_gc_cost_counter->set_value(
|
||||
(jlong) (cms_size_policy()->avg_msc_gc_cost()->average() * 100.0));
|
||||
}
|
||||
|
||||
inline void update_avg_ms_pause_counter() {
|
||||
_avg_ms_pause_counter->set_value(
|
||||
(jlong) (cms_size_policy()->avg_ms_pause()->average() *
|
||||
(double) MILLIUNITS));
|
||||
}
|
||||
|
||||
inline void update_avg_ms_interval_counter() {
|
||||
_avg_ms_interval_counter->set_value(
|
||||
(jlong) (cms_size_policy()->avg_ms_interval()->average() *
|
||||
(double) MILLIUNITS));
|
||||
}
|
||||
|
||||
inline void update_ms_gc_cost_counter() {
|
||||
_ms_gc_cost_counter->set_value(
|
||||
(jlong) (cms_size_policy()->avg_ms_gc_cost()->average() * 100.0));
|
||||
}
|
||||
|
||||
inline void update_major_gc_cost_counter() {
|
||||
_major_gc_cost_counter->set_value(
|
||||
(jlong)(cms_size_policy()->cms_gc_cost() * 100.0)
|
||||
);
|
||||
}
|
||||
inline void update_mutator_cost_counter() {
|
||||
_mutator_cost_counter->set_value(
|
||||
(jlong)(cms_size_policy()->mutator_cost() * 100.0)
|
||||
);
|
||||
}
|
||||
|
||||
inline void update_avg_promoted_avg(CMSGCStats* gc_stats) {
|
||||
_promoted_avg_counter->set_value(
|
||||
(jlong)(gc_stats->avg_promoted()->average())
|
||||
);
|
||||
}
|
||||
inline void update_avg_promoted_dev(CMSGCStats* gc_stats) {
|
||||
_promoted_avg_dev_counter->set_value(
|
||||
(jlong)(gc_stats->avg_promoted()->deviation())
|
||||
);
|
||||
}
|
||||
inline void update_avg_promoted_padded_avg(CMSGCStats* gc_stats) {
|
||||
_promoted_padded_avg_counter->set_value(
|
||||
(jlong)(gc_stats->avg_promoted()->padded_average())
|
||||
);
|
||||
}
|
||||
inline void update_remark_pause_old_slope_counter() {
|
||||
_remark_pause_old_slope_counter->set_value(
|
||||
(jlong)(cms_size_policy()->remark_pause_old_slope() * 1000)
|
||||
);
|
||||
}
|
||||
inline void update_initial_pause_old_slope_counter() {
|
||||
_initial_pause_old_slope_counter->set_value(
|
||||
(jlong)(cms_size_policy()->initial_pause_old_slope() * 1000)
|
||||
);
|
||||
}
|
||||
inline void update_remark_pause_young_slope_counter() {
|
||||
_remark_pause_young_slope_counter->set_value(
|
||||
(jlong)(cms_size_policy()->remark_pause_young_slope() * 1000)
|
||||
);
|
||||
}
|
||||
inline void update_initial_pause_young_slope_counter() {
|
||||
_initial_pause_young_slope_counter->set_value(
|
||||
(jlong)(cms_size_policy()->initial_pause_young_slope() * 1000)
|
||||
);
|
||||
}
|
||||
inline void update_change_young_gen_for_maj_pauses() {
|
||||
_change_young_gen_for_maj_pauses_counter->set_value(
|
||||
cms_size_policy()->change_young_gen_for_maj_pauses());
|
||||
}
|
||||
|
||||
public:
|
||||
CMSGCAdaptivePolicyCounters(const char* name, int collectors, int generations,
|
||||
AdaptiveSizePolicy* size_policy);
|
||||
|
||||
// update counters
|
||||
void update_counters();
|
||||
void update_counters(CMSGCStats* gc_stats);
|
||||
void update_counters_from_policy();
|
||||
|
||||
inline void update_cms_capacity_counter(size_t size_in_bytes) {
|
||||
_cms_capacity_counter->set_value(size_in_bytes);
|
||||
}
|
||||
|
||||
virtual GCPolicyCounters::Name kind() const {
|
||||
return GCPolicyCounters::CMSGCAdaptivePolicyCountersKind;
|
||||
}
|
||||
};
|
||||
|
||||
#endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSGCADAPTIVEPOLICYCOUNTERS_HPP
|
@ -70,7 +70,6 @@ class LinearAllocBlock VALUE_OBJ_CLASS_SPEC {
|
||||
class CompactibleFreeListSpace: public CompactibleSpace {
|
||||
friend class VMStructs;
|
||||
friend class ConcurrentMarkSweepGeneration;
|
||||
friend class ASConcurrentMarkSweepGeneration;
|
||||
friend class CMSCollector;
|
||||
// Local alloc buffer for promotion into this space.
|
||||
friend class CFLS_LAB;
|
||||
|
@ -27,9 +27,8 @@
|
||||
#include "classfile/stringTable.hpp"
|
||||
#include "classfile/systemDictionary.hpp"
|
||||
#include "code/codeCache.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
|
||||
#include "gc_implementation/shared/adaptiveSizePolicy.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.inline.hpp"
|
||||
@ -319,27 +318,13 @@ void CMSCollector::ref_processor_init() {
|
||||
}
|
||||
}
|
||||
|
||||
CMSAdaptiveSizePolicy* CMSCollector::size_policy() {
|
||||
AdaptiveSizePolicy* CMSCollector::size_policy() {
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
assert(gch->kind() == CollectedHeap::GenCollectedHeap,
|
||||
"Wrong type of heap");
|
||||
CMSAdaptiveSizePolicy* sp = (CMSAdaptiveSizePolicy*)
|
||||
gch->gen_policy()->size_policy();
|
||||
assert(sp->is_gc_cms_adaptive_size_policy(),
|
||||
"Wrong type of size policy");
|
||||
return sp;
|
||||
return gch->gen_policy()->size_policy();
|
||||
}
|
||||
|
||||
CMSGCAdaptivePolicyCounters* CMSCollector::gc_adaptive_policy_counters() {
|
||||
CMSGCAdaptivePolicyCounters* results =
|
||||
(CMSGCAdaptivePolicyCounters*) collector_policy()->counters();
|
||||
assert(
|
||||
results->kind() == GCPolicyCounters::CMSGCAdaptivePolicyCountersKind,
|
||||
"Wrong gc policy counter kind");
|
||||
return results;
|
||||
}
|
||||
|
||||
|
||||
void ConcurrentMarkSweepGeneration::initialize_performance_counters() {
|
||||
|
||||
const char* gen_name = "old";
|
||||
@ -1573,11 +1558,11 @@ bool CMSCollector::shouldConcurrentCollect() {
|
||||
}
|
||||
|
||||
if (MetaspaceGC::should_concurrent_collect()) {
|
||||
if (Verbose && PrintGCDetails) {
|
||||
if (Verbose && PrintGCDetails) {
|
||||
gclog_or_tty->print("CMSCollector: collect for metadata allocation ");
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// CMSTriggerInterval starts a CMS cycle if enough time has passed.
|
||||
if (CMSTriggerInterval >= 0) {
|
||||
@ -2031,11 +2016,6 @@ void CMSCollector::do_compaction_work(bool clear_all_soft_refs) {
|
||||
"collections passed to foreground collector", _full_gcs_since_conc_gc);
|
||||
}
|
||||
|
||||
// Sample collection interval time and reset for collection pause.
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->msc_collection_begin();
|
||||
}
|
||||
|
||||
// Temporarily widen the span of the weak reference processing to
|
||||
// the entire heap.
|
||||
MemRegion new_span(GenCollectedHeap::heap()->reserved_region());
|
||||
@ -2111,11 +2091,6 @@ void CMSCollector::do_compaction_work(bool clear_all_soft_refs) {
|
||||
_inter_sweep_timer.reset();
|
||||
_inter_sweep_timer.start();
|
||||
|
||||
// Sample collection pause time and reset for collection interval.
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->msc_collection_end(gch->gc_cause());
|
||||
}
|
||||
|
||||
gc_timer->register_gc_end();
|
||||
|
||||
gc_tracer->report_gc_end(gc_timer->gc_end(), gc_timer->time_partitions());
|
||||
@ -2373,26 +2348,14 @@ void CMSCollector::collect_in_background(bool clear_all_soft_refs, GCCause::Caus
|
||||
}
|
||||
break;
|
||||
case Precleaning:
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->concurrent_precleaning_begin();
|
||||
}
|
||||
// marking from roots in markFromRoots has been completed
|
||||
preclean();
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->concurrent_precleaning_end();
|
||||
}
|
||||
assert(_collectorState == AbortablePreclean ||
|
||||
_collectorState == FinalMarking,
|
||||
"Collector state should have changed");
|
||||
break;
|
||||
case AbortablePreclean:
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->concurrent_phases_resume();
|
||||
}
|
||||
abortable_preclean();
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->concurrent_precleaning_end();
|
||||
}
|
||||
assert(_collectorState == FinalMarking, "Collector state should "
|
||||
"have changed");
|
||||
break;
|
||||
@ -2406,23 +2369,12 @@ void CMSCollector::collect_in_background(bool clear_all_soft_refs, GCCause::Caus
|
||||
assert(_foregroundGCShouldWait, "block post-condition");
|
||||
break;
|
||||
case Sweeping:
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->concurrent_sweeping_begin();
|
||||
}
|
||||
// final marking in checkpointRootsFinal has been completed
|
||||
sweep(true);
|
||||
assert(_collectorState == Resizing, "Collector state change "
|
||||
"to Resizing must be done under the free_list_lock");
|
||||
_full_gcs_since_conc_gc = 0;
|
||||
|
||||
// Stop the timers for adaptive size policy for the concurrent phases
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->concurrent_sweeping_end();
|
||||
size_policy()->concurrent_phases_end(gch->gc_cause(),
|
||||
gch->prev_gen(_cmsGen)->capacity(),
|
||||
_cmsGen->free());
|
||||
}
|
||||
|
||||
case Resizing: {
|
||||
// Sweeping has been completed...
|
||||
// At this point the background collection has completed.
|
||||
@ -2539,9 +2491,6 @@ void CMSCollector::collect_in_foreground(bool clear_all_soft_refs, GCCause::Caus
|
||||
const GCId gc_id = _collectorState == InitialMarking ? GCId::peek() : _gc_tracer_cm->gc_id();
|
||||
NOT_PRODUCT(GCTraceTime t("CMS:MS (foreground) ", PrintGCDetails && Verbose,
|
||||
true, NULL, gc_id);)
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->ms_collection_begin();
|
||||
}
|
||||
COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact);
|
||||
|
||||
HandleMark hm; // Discard invalid handles created during verification
|
||||
@ -2633,11 +2582,6 @@ void CMSCollector::collect_in_foreground(bool clear_all_soft_refs, GCCause::Caus
|
||||
}
|
||||
}
|
||||
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
size_policy()->ms_collection_end(gch->gc_cause());
|
||||
}
|
||||
|
||||
if (VerifyAfterGC &&
|
||||
GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
|
||||
Universe::verify();
|
||||
@ -3053,20 +2997,21 @@ void CMSCollector::verify_after_remark_work_1() {
|
||||
HandleMark hm;
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
|
||||
// Get a clear set of claim bits for the strong roots processing to work with.
|
||||
// Get a clear set of claim bits for the roots processing to work with.
|
||||
ClassLoaderDataGraph::clear_claimed_marks();
|
||||
|
||||
// Mark from roots one level into CMS
|
||||
MarkRefsIntoClosure notOlder(_span, verification_mark_bm());
|
||||
gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
|
||||
|
||||
gch->gen_process_strong_roots(_cmsGen->level(),
|
||||
true, // younger gens are roots
|
||||
true, // activate StrongRootsScope
|
||||
SharedHeap::ScanningOption(roots_scanning_options()),
|
||||
¬Older,
|
||||
NULL,
|
||||
NULL); // SSS: Provide correct closure
|
||||
gch->gen_process_roots(_cmsGen->level(),
|
||||
true, // younger gens are roots
|
||||
true, // activate StrongRootsScope
|
||||
SharedHeap::ScanningOption(roots_scanning_options()),
|
||||
should_unload_classes(),
|
||||
¬Older,
|
||||
NULL,
|
||||
NULL); // SSS: Provide correct closure
|
||||
|
||||
// Now mark from the roots
|
||||
MarkFromRootsClosure markFromRootsClosure(this, _span,
|
||||
@ -3117,22 +3062,24 @@ void CMSCollector::verify_after_remark_work_2() {
|
||||
HandleMark hm;
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
|
||||
// Get a clear set of claim bits for the strong roots processing to work with.
|
||||
// Get a clear set of claim bits for the roots processing to work with.
|
||||
ClassLoaderDataGraph::clear_claimed_marks();
|
||||
|
||||
// Mark from roots one level into CMS
|
||||
MarkRefsIntoVerifyClosure notOlder(_span, verification_mark_bm(),
|
||||
markBitMap());
|
||||
KlassToOopClosure klass_closure(¬Older);
|
||||
CLDToOopClosure cld_closure(¬Older, true);
|
||||
|
||||
gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
|
||||
gch->gen_process_strong_roots(_cmsGen->level(),
|
||||
true, // younger gens are roots
|
||||
true, // activate StrongRootsScope
|
||||
SharedHeap::ScanningOption(roots_scanning_options()),
|
||||
¬Older,
|
||||
NULL,
|
||||
&klass_closure);
|
||||
|
||||
gch->gen_process_roots(_cmsGen->level(),
|
||||
true, // younger gens are roots
|
||||
true, // activate StrongRootsScope
|
||||
SharedHeap::ScanningOption(roots_scanning_options()),
|
||||
should_unload_classes(),
|
||||
¬Older,
|
||||
NULL,
|
||||
&cld_closure);
|
||||
|
||||
// Now mark from the roots
|
||||
MarkFromRootsVerifyClosure markFromRootsClosure(this, _span,
|
||||
@ -3319,12 +3266,10 @@ bool ConcurrentMarkSweepGeneration::is_too_full() const {
|
||||
void CMSCollector::setup_cms_unloading_and_verification_state() {
|
||||
const bool should_verify = VerifyBeforeGC || VerifyAfterGC || VerifyDuringGC
|
||||
|| VerifyBeforeExit;
|
||||
const int rso = SharedHeap::SO_Strings | SharedHeap::SO_AllCodeCache;
|
||||
const int rso = SharedHeap::SO_AllCodeCache;
|
||||
|
||||
// We set the proper root for this CMS cycle here.
|
||||
if (should_unload_classes()) { // Should unload classes this cycle
|
||||
remove_root_scanning_option(SharedHeap::SO_AllClasses);
|
||||
add_root_scanning_option(SharedHeap::SO_SystemClasses);
|
||||
remove_root_scanning_option(rso); // Shrink the root set appropriately
|
||||
set_verifying(should_verify); // Set verification state for this cycle
|
||||
return; // Nothing else needs to be done at this time
|
||||
@ -3332,8 +3277,6 @@ void CMSCollector::setup_cms_unloading_and_verification_state() {
|
||||
|
||||
// Not unloading classes this cycle
|
||||
assert(!should_unload_classes(), "Inconsistency!");
|
||||
remove_root_scanning_option(SharedHeap::SO_SystemClasses);
|
||||
add_root_scanning_option(SharedHeap::SO_AllClasses);
|
||||
|
||||
if ((!verifying() || unloaded_classes_last_cycle()) && should_verify) {
|
||||
// Include symbols, strings and code cache elements to prevent their resurrection.
|
||||
@ -3687,9 +3630,6 @@ void CMSCollector::checkpointRootsInitialWork(bool asynch) {
|
||||
|
||||
NOT_PRODUCT(GCTraceTime t("\ncheckpointRootsInitialWork",
|
||||
PrintGCDetails && Verbose, true, _gc_timer_cm, _gc_tracer_cm->gc_id());)
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->checkpoint_roots_initial_begin();
|
||||
}
|
||||
|
||||
// Reset all the PLAB chunk arrays if necessary.
|
||||
if (_survivor_plab_array != NULL && !CMSPLABRecordAlways) {
|
||||
@ -3744,15 +3684,16 @@ void CMSCollector::checkpointRootsInitialWork(bool asynch) {
|
||||
gch->set_par_threads(0);
|
||||
} else {
|
||||
// The serial version.
|
||||
KlassToOopClosure klass_closure(¬Older);
|
||||
CLDToOopClosure cld_closure(¬Older, true);
|
||||
gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
|
||||
gch->gen_process_strong_roots(_cmsGen->level(),
|
||||
true, // younger gens are roots
|
||||
true, // activate StrongRootsScope
|
||||
SharedHeap::ScanningOption(roots_scanning_options()),
|
||||
¬Older,
|
||||
NULL,
|
||||
&klass_closure);
|
||||
gch->gen_process_roots(_cmsGen->level(),
|
||||
true, // younger gens are roots
|
||||
true, // activate StrongRootsScope
|
||||
SharedHeap::ScanningOption(roots_scanning_options()),
|
||||
should_unload_classes(),
|
||||
¬Older,
|
||||
NULL,
|
||||
&cld_closure);
|
||||
}
|
||||
}
|
||||
|
||||
@ -3769,9 +3710,6 @@ void CMSCollector::checkpointRootsInitialWork(bool asynch) {
|
||||
// Save the end of the used_region of the constituent generations
|
||||
// to be used to limit the extent of sweep in each generation.
|
||||
save_sweep_limits();
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->checkpoint_roots_initial_end(gch->gc_cause());
|
||||
}
|
||||
verify_overflow_empty();
|
||||
}
|
||||
|
||||
@ -3788,15 +3726,6 @@ bool CMSCollector::markFromRoots(bool asynch) {
|
||||
|
||||
bool res;
|
||||
if (asynch) {
|
||||
|
||||
// Start the timers for adaptive size policy for the concurrent phases
|
||||
// Do it here so that the foreground MS can use the concurrent
|
||||
// timer since a foreground MS might has the sweep done concurrently
|
||||
// or STW.
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->concurrent_marking_begin();
|
||||
}
|
||||
|
||||
// Weak ref discovery note: We may be discovering weak
|
||||
// refs in this generation concurrent (but interleaved) with
|
||||
// weak ref discovery by a younger generation collector.
|
||||
@ -3814,22 +3743,12 @@ bool CMSCollector::markFromRoots(bool asynch) {
|
||||
gclog_or_tty->print_cr("bailing out to foreground collection");
|
||||
}
|
||||
}
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->concurrent_marking_end();
|
||||
}
|
||||
} else {
|
||||
assert(SafepointSynchronize::is_at_safepoint(),
|
||||
"inconsistent with asynch == false");
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->ms_collection_marking_begin();
|
||||
}
|
||||
// already have locks
|
||||
res = markFromRootsWork(asynch);
|
||||
_collectorState = FinalMarking;
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
size_policy()->ms_collection_marking_end(gch->gc_cause());
|
||||
}
|
||||
}
|
||||
verify_overflow_empty();
|
||||
return res;
|
||||
@ -4705,8 +4624,7 @@ size_t CMSCollector::preclean_work(bool clean_refs, bool clean_survivor) {
|
||||
|
||||
if (clean_survivor) { // preclean the active survivor space(s)
|
||||
assert(_young_gen->kind() == Generation::DefNew ||
|
||||
_young_gen->kind() == Generation::ParNew ||
|
||||
_young_gen->kind() == Generation::ASParNew,
|
||||
_young_gen->kind() == Generation::ParNew,
|
||||
"incorrect type for cast");
|
||||
DefNewGeneration* dng = (DefNewGeneration*)_young_gen;
|
||||
PushAndMarkClosure pam_cl(this, _span, ref_processor(),
|
||||
@ -5077,10 +4995,6 @@ void CMSCollector::checkpointRootsFinalWork(bool asynch,
|
||||
assert(haveFreelistLocks(), "must have free list locks");
|
||||
assert_lock_strong(bitMapLock());
|
||||
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->checkpoint_roots_final_begin();
|
||||
}
|
||||
|
||||
ResourceMark rm;
|
||||
HandleMark hm;
|
||||
|
||||
@ -5214,9 +5128,6 @@ void CMSCollector::checkpointRootsFinalWork(bool asynch,
|
||||
"Should be clear by end of the final marking");
|
||||
assert(_ct->klass_rem_set()->mod_union_is_clear(),
|
||||
"Should be clear by end of the final marking");
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
size_policy()->checkpoint_roots_final_end(gch->gc_cause());
|
||||
}
|
||||
}
|
||||
|
||||
void CMSParInitialMarkTask::work(uint worker_id) {
|
||||
@ -5228,7 +5139,6 @@ void CMSParInitialMarkTask::work(uint worker_id) {
|
||||
_timer.start();
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
Par_MarkRefsIntoClosure par_mri_cl(_collector->_span, &(_collector->_markBitMap));
|
||||
KlassToOopClosure klass_closure(&par_mri_cl);
|
||||
|
||||
// ---------- young gen roots --------------
|
||||
{
|
||||
@ -5244,13 +5154,17 @@ void CMSParInitialMarkTask::work(uint worker_id) {
|
||||
// ---------- remaining roots --------------
|
||||
_timer.reset();
|
||||
_timer.start();
|
||||
gch->gen_process_strong_roots(_collector->_cmsGen->level(),
|
||||
false, // yg was scanned above
|
||||
false, // this is parallel code
|
||||
SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
|
||||
&par_mri_cl,
|
||||
NULL,
|
||||
&klass_closure);
|
||||
|
||||
CLDToOopClosure cld_closure(&par_mri_cl, true);
|
||||
|
||||
gch->gen_process_roots(_collector->_cmsGen->level(),
|
||||
false, // yg was scanned above
|
||||
false, // this is parallel code
|
||||
SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
|
||||
_collector->should_unload_classes(),
|
||||
&par_mri_cl,
|
||||
NULL,
|
||||
&cld_closure);
|
||||
assert(_collector->should_unload_classes()
|
||||
|| (_collector->CMSCollector::roots_scanning_options() & SharedHeap::SO_AllCodeCache),
|
||||
"if we didn't scan the code cache, we have to be ready to drop nmethods with expired weak oops");
|
||||
@ -5379,13 +5293,15 @@ void CMSParRemarkTask::work(uint worker_id) {
|
||||
// ---------- remaining roots --------------
|
||||
_timer.reset();
|
||||
_timer.start();
|
||||
gch->gen_process_strong_roots(_collector->_cmsGen->level(),
|
||||
false, // yg was scanned above
|
||||
false, // this is parallel code
|
||||
SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
|
||||
&par_mrias_cl,
|
||||
NULL,
|
||||
NULL); // The dirty klasses will be handled below
|
||||
gch->gen_process_roots(_collector->_cmsGen->level(),
|
||||
false, // yg was scanned above
|
||||
false, // this is parallel code
|
||||
SharedHeap::ScanningOption(_collector->CMSCollector::roots_scanning_options()),
|
||||
_collector->should_unload_classes(),
|
||||
&par_mrias_cl,
|
||||
NULL,
|
||||
NULL); // The dirty klasses will be handled below
|
||||
|
||||
assert(_collector->should_unload_classes()
|
||||
|| (_collector->CMSCollector::roots_scanning_options() & SharedHeap::SO_AllCodeCache),
|
||||
"if we didn't scan the code cache, we have to be ready to drop nmethods with expired weak oops");
|
||||
@ -5440,7 +5356,7 @@ void CMSParRemarkTask::work(uint worker_id) {
|
||||
// We might have added oops to ClassLoaderData::_handles during the
|
||||
// concurrent marking phase. These oops point to newly allocated objects
|
||||
// that are guaranteed to be kept alive. Either by the direct allocation
|
||||
// code, or when the young collector processes the strong roots. Hence,
|
||||
// code, or when the young collector processes the roots. Hence,
|
||||
// we don't have to revisit the _handles block during the remark phase.
|
||||
|
||||
// ---------- rescan dirty cards ------------
|
||||
@ -5862,7 +5778,7 @@ void CMSCollector::do_remark_parallel() {
|
||||
cms_space,
|
||||
n_workers, workers, task_queues());
|
||||
|
||||
// Set up for parallel process_strong_roots work.
|
||||
// Set up for parallel process_roots work.
|
||||
gch->set_par_threads(n_workers);
|
||||
// We won't be iterating over the cards in the card table updating
|
||||
// the younger_gen cards, so we shouldn't call the following else
|
||||
@ -5871,7 +5787,7 @@ void CMSCollector::do_remark_parallel() {
|
||||
// gch->rem_set()->prepare_for_younger_refs_iterate(true); // parallel
|
||||
|
||||
// The young gen rescan work will not be done as part of
|
||||
// process_strong_roots (which currently doesn't knw how to
|
||||
// process_roots (which currently doesn't know how to
|
||||
// parallelize such a scan), but rather will be broken up into
|
||||
// a set of parallel tasks (via the sampling that the [abortable]
|
||||
// preclean phase did of EdenSpace, plus the [two] tasks of
|
||||
@ -5968,13 +5884,15 @@ void CMSCollector::do_remark_non_parallel() {
|
||||
|
||||
gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
|
||||
GenCollectedHeap::StrongRootsScope srs(gch);
|
||||
gch->gen_process_strong_roots(_cmsGen->level(),
|
||||
true, // younger gens as roots
|
||||
false, // use the local StrongRootsScope
|
||||
SharedHeap::ScanningOption(roots_scanning_options()),
|
||||
&mrias_cl,
|
||||
NULL,
|
||||
NULL); // The dirty klasses will be handled below
|
||||
|
||||
gch->gen_process_roots(_cmsGen->level(),
|
||||
true, // younger gens as roots
|
||||
false, // use the local StrongRootsScope
|
||||
SharedHeap::ScanningOption(roots_scanning_options()),
|
||||
should_unload_classes(),
|
||||
&mrias_cl,
|
||||
NULL,
|
||||
NULL); // The dirty klasses will be handled below
|
||||
|
||||
assert(should_unload_classes()
|
||||
|| (roots_scanning_options() & SharedHeap::SO_AllCodeCache),
|
||||
@ -6014,7 +5932,7 @@ void CMSCollector::do_remark_non_parallel() {
|
||||
// We might have added oops to ClassLoaderData::_handles during the
|
||||
// concurrent marking phase. These oops point to newly allocated objects
|
||||
// that are guaranteed to be kept alive. Either by the direct allocation
|
||||
// code, or when the young collector processes the strong roots. Hence,
|
||||
// code, or when the young collector processes the roots. Hence,
|
||||
// we don't have to revisit the _handles block during the remark phase.
|
||||
|
||||
verify_work_stacks_empty();
|
||||
@ -6264,15 +6182,14 @@ void CMSCollector::refProcessingWork(bool asynch, bool clear_all_soft_refs) {
|
||||
// Clean up unreferenced symbols in symbol table.
|
||||
SymbolTable::unlink();
|
||||
}
|
||||
|
||||
{
|
||||
GCTraceTime t("scrub string table", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
|
||||
// Delete entries for dead interned strings.
|
||||
StringTable::unlink(&_is_alive_closure);
|
||||
}
|
||||
}
|
||||
|
||||
// CMS doesn't use the StringTable as hard roots when class unloading is turned off.
|
||||
// Need to check if we really scanned the StringTable.
|
||||
if ((roots_scanning_options() & SharedHeap::SO_Strings) == 0) {
|
||||
GCTraceTime t("scrub string table", PrintGCDetails, false, _gc_timer_cm, _gc_tracer_cm->gc_id());
|
||||
// Delete entries for dead interned strings.
|
||||
StringTable::unlink(&_is_alive_closure);
|
||||
}
|
||||
|
||||
// Restore any preserved marks as a result of mark stack or
|
||||
// work queue overflow
|
||||
@ -6329,7 +6246,6 @@ void CMSCollector::sweep(bool asynch) {
|
||||
|
||||
_inter_sweep_timer.stop();
|
||||
_inter_sweep_estimate.sample(_inter_sweep_timer.seconds());
|
||||
size_policy()->avg_cms_free_at_sweep()->sample(_cmsGen->free());
|
||||
|
||||
assert(!_intra_sweep_timer.is_active(), "Should not be active");
|
||||
_intra_sweep_timer.reset();
|
||||
@ -6454,17 +6370,6 @@ void ConcurrentMarkSweepGeneration::update_gc_stats(int current_level,
|
||||
}
|
||||
}
|
||||
|
||||
CMSAdaptiveSizePolicy* ConcurrentMarkSweepGeneration::size_policy() {
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
assert(gch->kind() == CollectedHeap::GenCollectedHeap,
|
||||
"Wrong type of heap");
|
||||
CMSAdaptiveSizePolicy* sp = (CMSAdaptiveSizePolicy*)
|
||||
gch->gen_policy()->size_policy();
|
||||
assert(sp->is_gc_cms_adaptive_size_policy(),
|
||||
"Wrong type of size policy");
|
||||
return sp;
|
||||
}
|
||||
|
||||
void ConcurrentMarkSweepGeneration::rotate_debug_collection_type() {
|
||||
if (PrintGCDetails && Verbose) {
|
||||
gclog_or_tty->print("Rotate from %d ", _debug_collection_type);
|
||||
@ -6540,9 +6445,6 @@ void CMSCollector::sweepWork(ConcurrentMarkSweepGeneration* gen,
|
||||
// Reset CMS data structures (for now just the marking bit map)
|
||||
// preparatory for the next cycle.
|
||||
void CMSCollector::reset(bool asynch) {
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
CMSAdaptiveSizePolicy* sp = size_policy();
|
||||
AdaptiveSizePolicyOutput(sp, gch->total_collections());
|
||||
if (asynch) {
|
||||
CMSTokenSyncWithLocks ts(true, bitMapLock());
|
||||
|
||||
@ -6597,7 +6499,7 @@ void CMSCollector::reset(bool asynch) {
|
||||
// Because only the full (i.e., concurrent mode failure) collections
|
||||
// are being measured for gc overhead limits, clean the "near" flag
|
||||
// and count.
|
||||
sp->reset_gc_overhead_limit_count();
|
||||
size_policy()->reset_gc_overhead_limit_count();
|
||||
_collectorState = Idling;
|
||||
} else {
|
||||
// already have the lock
|
||||
@ -7064,7 +6966,6 @@ void MarkRefsIntoAndScanClosure::do_yield_work() {
|
||||
ConcurrentMarkSweepThread::desynchronize(true);
|
||||
ConcurrentMarkSweepThread::acknowledge_yield_request();
|
||||
_collector->stopTimer();
|
||||
GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
|
||||
if (PrintCMSStatistics != 0) {
|
||||
_collector->incrementYields();
|
||||
}
|
||||
@ -7225,7 +7126,6 @@ void ScanMarkedObjectsAgainCarefullyClosure::do_yield_work() {
|
||||
ConcurrentMarkSweepThread::desynchronize(true);
|
||||
ConcurrentMarkSweepThread::acknowledge_yield_request();
|
||||
_collector->stopTimer();
|
||||
GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
|
||||
if (PrintCMSStatistics != 0) {
|
||||
_collector->incrementYields();
|
||||
}
|
||||
@ -7298,7 +7198,6 @@ void SurvivorSpacePrecleanClosure::do_yield_work() {
|
||||
ConcurrentMarkSweepThread::desynchronize(true);
|
||||
ConcurrentMarkSweepThread::acknowledge_yield_request();
|
||||
_collector->stopTimer();
|
||||
GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
|
||||
if (PrintCMSStatistics != 0) {
|
||||
_collector->incrementYields();
|
||||
}
|
||||
@ -7457,7 +7356,6 @@ void MarkFromRootsClosure::do_yield_work() {
|
||||
ConcurrentMarkSweepThread::desynchronize(true);
|
||||
ConcurrentMarkSweepThread::acknowledge_yield_request();
|
||||
_collector->stopTimer();
|
||||
GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
|
||||
if (PrintCMSStatistics != 0) {
|
||||
_collector->incrementYields();
|
||||
}
|
||||
@ -8099,7 +7997,6 @@ void CMSPrecleanRefsYieldClosure::do_yield_work() {
|
||||
ConcurrentMarkSweepThread::acknowledge_yield_request();
|
||||
|
||||
_collector->stopTimer();
|
||||
GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
|
||||
if (PrintCMSStatistics != 0) {
|
||||
_collector->incrementYields();
|
||||
}
|
||||
@ -8780,7 +8677,6 @@ void SweepClosure::do_yield_work(HeapWord* addr) {
|
||||
ConcurrentMarkSweepThread::desynchronize(true);
|
||||
ConcurrentMarkSweepThread::acknowledge_yield_request();
|
||||
_collector->stopTimer();
|
||||
GCPauseTimer p(_collector->size_policy()->concurrent_timer_ptr());
|
||||
if (PrintCMSStatistics != 0) {
|
||||
_collector->incrementYields();
|
||||
}
|
||||
@ -9327,172 +9223,6 @@ bool CMSCollector::no_preserved_marks() const {
|
||||
}
|
||||
#endif
|
||||
|
||||
CMSAdaptiveSizePolicy* ASConcurrentMarkSweepGeneration::cms_size_policy() const
|
||||
{
|
||||
GenCollectedHeap* gch = (GenCollectedHeap*) GenCollectedHeap::heap();
|
||||
CMSAdaptiveSizePolicy* size_policy =
|
||||
(CMSAdaptiveSizePolicy*) gch->gen_policy()->size_policy();
|
||||
assert(size_policy->is_gc_cms_adaptive_size_policy(),
|
||||
"Wrong type for size policy");
|
||||
return size_policy;
|
||||
}
|
||||
|
||||
void ASConcurrentMarkSweepGeneration::resize(size_t cur_promo_size,
|
||||
size_t desired_promo_size) {
|
||||
if (cur_promo_size < desired_promo_size) {
|
||||
size_t expand_bytes = desired_promo_size - cur_promo_size;
|
||||
if (PrintAdaptiveSizePolicy && Verbose) {
|
||||
gclog_or_tty->print_cr(" ASConcurrentMarkSweepGeneration::resize "
|
||||
"Expanding tenured generation by " SIZE_FORMAT " (bytes)",
|
||||
expand_bytes);
|
||||
}
|
||||
expand(expand_bytes,
|
||||
MinHeapDeltaBytes,
|
||||
CMSExpansionCause::_adaptive_size_policy);
|
||||
} else if (desired_promo_size < cur_promo_size) {
|
||||
size_t shrink_bytes = cur_promo_size - desired_promo_size;
|
||||
if (PrintAdaptiveSizePolicy && Verbose) {
|
||||
gclog_or_tty->print_cr(" ASConcurrentMarkSweepGeneration::resize "
|
||||
"Shrinking tenured generation by " SIZE_FORMAT " (bytes)",
|
||||
shrink_bytes);
|
||||
}
|
||||
shrink(shrink_bytes);
|
||||
}
|
||||
}
|
||||
|
||||
CMSGCAdaptivePolicyCounters* ASConcurrentMarkSweepGeneration::gc_adaptive_policy_counters() {
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
CMSGCAdaptivePolicyCounters* counters =
|
||||
(CMSGCAdaptivePolicyCounters*) gch->collector_policy()->counters();
|
||||
assert(counters->kind() == GCPolicyCounters::CMSGCAdaptivePolicyCountersKind,
|
||||
"Wrong kind of counters");
|
||||
return counters;
|
||||
}
|
||||
|
||||
|
||||
void ASConcurrentMarkSweepGeneration::update_counters() {
|
||||
if (UsePerfData) {
|
||||
_space_counters->update_all();
|
||||
_gen_counters->update_all();
|
||||
CMSGCAdaptivePolicyCounters* counters = gc_adaptive_policy_counters();
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
CMSGCStats* gc_stats_l = (CMSGCStats*) gc_stats();
|
||||
assert(gc_stats_l->kind() == GCStats::CMSGCStatsKind,
|
||||
"Wrong gc statistics type");
|
||||
counters->update_counters(gc_stats_l);
|
||||
}
|
||||
}
|
||||
|
||||
void ASConcurrentMarkSweepGeneration::update_counters(size_t used) {
|
||||
if (UsePerfData) {
|
||||
_space_counters->update_used(used);
|
||||
_space_counters->update_capacity();
|
||||
_gen_counters->update_all();
|
||||
|
||||
CMSGCAdaptivePolicyCounters* counters = gc_adaptive_policy_counters();
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
CMSGCStats* gc_stats_l = (CMSGCStats*) gc_stats();
|
||||
assert(gc_stats_l->kind() == GCStats::CMSGCStatsKind,
|
||||
"Wrong gc statistics type");
|
||||
counters->update_counters(gc_stats_l);
|
||||
}
|
||||
}
|
||||
|
||||
void ASConcurrentMarkSweepGeneration::shrink_by(size_t desired_bytes) {
|
||||
assert_locked_or_safepoint(Heap_lock);
|
||||
assert_lock_strong(freelistLock());
|
||||
HeapWord* old_end = _cmsSpace->end();
|
||||
HeapWord* unallocated_start = _cmsSpace->unallocated_block();
|
||||
assert(old_end >= unallocated_start, "Miscalculation of unallocated_start");
|
||||
FreeChunk* chunk_at_end = find_chunk_at_end();
|
||||
if (chunk_at_end == NULL) {
|
||||
// No room to shrink
|
||||
if (PrintGCDetails && Verbose) {
|
||||
gclog_or_tty->print_cr("No room to shrink: old_end "
|
||||
PTR_FORMAT " unallocated_start " PTR_FORMAT
|
||||
" chunk_at_end " PTR_FORMAT,
|
||||
old_end, unallocated_start, chunk_at_end);
|
||||
}
|
||||
return;
|
||||
} else {
|
||||
|
||||
// Find the chunk at the end of the space and determine
|
||||
// how much it can be shrunk.
|
||||
size_t shrinkable_size_in_bytes = chunk_at_end->size();
|
||||
size_t aligned_shrinkable_size_in_bytes =
|
||||
align_size_down(shrinkable_size_in_bytes, os::vm_page_size());
|
||||
assert(unallocated_start <= (HeapWord*) chunk_at_end->end(),
|
||||
"Inconsistent chunk at end of space");
|
||||
size_t bytes = MIN2(desired_bytes, aligned_shrinkable_size_in_bytes);
|
||||
size_t word_size_before = heap_word_size(_virtual_space.committed_size());
|
||||
|
||||
// Shrink the underlying space
|
||||
_virtual_space.shrink_by(bytes);
|
||||
if (PrintGCDetails && Verbose) {
|
||||
gclog_or_tty->print_cr("ConcurrentMarkSweepGeneration::shrink_by:"
|
||||
" desired_bytes " SIZE_FORMAT
|
||||
" shrinkable_size_in_bytes " SIZE_FORMAT
|
||||
" aligned_shrinkable_size_in_bytes " SIZE_FORMAT
|
||||
" bytes " SIZE_FORMAT,
|
||||
desired_bytes, shrinkable_size_in_bytes,
|
||||
aligned_shrinkable_size_in_bytes, bytes);
|
||||
gclog_or_tty->print_cr(" old_end " SIZE_FORMAT
|
||||
" unallocated_start " SIZE_FORMAT,
|
||||
old_end, unallocated_start);
|
||||
}
|
||||
|
||||
// If the space did shrink (shrinking is not guaranteed),
|
||||
// shrink the chunk at the end by the appropriate amount.
|
||||
if (((HeapWord*)_virtual_space.high()) < old_end) {
|
||||
size_t new_word_size =
|
||||
heap_word_size(_virtual_space.committed_size());
|
||||
|
||||
// Have to remove the chunk from the dictionary because it is changing
|
||||
// size and might be someplace elsewhere in the dictionary.
|
||||
|
||||
// Get the chunk at end, shrink it, and put it
|
||||
// back.
|
||||
_cmsSpace->removeChunkFromDictionary(chunk_at_end);
|
||||
size_t word_size_change = word_size_before - new_word_size;
|
||||
size_t chunk_at_end_old_size = chunk_at_end->size();
|
||||
assert(chunk_at_end_old_size >= word_size_change,
|
||||
"Shrink is too large");
|
||||
chunk_at_end->set_size(chunk_at_end_old_size -
|
||||
word_size_change);
|
||||
_cmsSpace->freed((HeapWord*) chunk_at_end->end(),
|
||||
word_size_change);
|
||||
|
||||
_cmsSpace->returnChunkToDictionary(chunk_at_end);
|
||||
|
||||
MemRegion mr(_cmsSpace->bottom(), new_word_size);
|
||||
_bts->resize(new_word_size); // resize the block offset shared array
|
||||
Universe::heap()->barrier_set()->resize_covered_region(mr);
|
||||
_cmsSpace->assert_locked();
|
||||
_cmsSpace->set_end((HeapWord*)_virtual_space.high());
|
||||
|
||||
NOT_PRODUCT(_cmsSpace->dictionary()->verify());
|
||||
|
||||
// update the space and generation capacity counters
|
||||
if (UsePerfData) {
|
||||
_space_counters->update_capacity();
|
||||
_gen_counters->update_all();
|
||||
}
|
||||
|
||||
if (Verbose && PrintGCDetails) {
|
||||
size_t new_mem_size = _virtual_space.committed_size();
|
||||
size_t old_mem_size = new_mem_size + bytes;
|
||||
gclog_or_tty->print_cr("Shrinking %s from " SIZE_FORMAT "K by " SIZE_FORMAT "K to " SIZE_FORMAT "K",
|
||||
name(), old_mem_size/K, bytes/K, new_mem_size/K);
|
||||
}
|
||||
}
|
||||
|
||||
assert(_cmsSpace->unallocated_block() <= _cmsSpace->end(),
|
||||
"Inconsistency at end of space");
|
||||
assert(chunk_at_end->end() == (uintptr_t*) _cmsSpace->end(),
|
||||
"Shrinking is inconsistent");
|
||||
return;
|
||||
}
|
||||
}
|
||||
// Transfer some number of overflown objects to usual marking
|
||||
// stack. Return true if some objects were transferred.
|
||||
bool MarkRefsIntoAndScanClosure::take_from_overflow_list() {
|
||||
|
@ -32,6 +32,7 @@
|
||||
#include "gc_implementation/shared/generationCounters.hpp"
|
||||
#include "memory/freeBlockDictionary.hpp"
|
||||
#include "memory/generation.hpp"
|
||||
#include "memory/iterator.hpp"
|
||||
#include "runtime/mutexLocker.hpp"
|
||||
#include "runtime/virtualspace.hpp"
|
||||
#include "services/memoryService.hpp"
|
||||
@ -52,7 +53,7 @@
|
||||
// Concurrent mode failures are currently handled by
|
||||
// means of a sliding mark-compact.
|
||||
|
||||
class CMSAdaptiveSizePolicy;
|
||||
class AdaptiveSizePolicy;
|
||||
class CMSConcMarkingTask;
|
||||
class CMSGCAdaptivePolicyCounters;
|
||||
class CMSTracer;
|
||||
@ -1009,8 +1010,7 @@ class CMSCollector: public CHeapObj<mtGC> {
|
||||
void icms_wait(); // Called at yield points.
|
||||
|
||||
// Adaptive size policy
|
||||
CMSAdaptiveSizePolicy* size_policy();
|
||||
CMSGCAdaptivePolicyCounters* gc_adaptive_policy_counters();
|
||||
AdaptiveSizePolicy* size_policy();
|
||||
|
||||
static void print_on_error(outputStream* st);
|
||||
|
||||
@ -1150,9 +1150,6 @@ class ConcurrentMarkSweepGeneration: public CardGeneration {
|
||||
|
||||
virtual Generation::Name kind() { return Generation::ConcurrentMarkSweep; }
|
||||
|
||||
// Adaptive size policy
|
||||
CMSAdaptiveSizePolicy* size_policy();
|
||||
|
||||
void set_did_compact(bool v) { _did_compact = v; }
|
||||
|
||||
bool refs_discovery_is_atomic() const { return false; }
|
||||
@ -1346,37 +1343,6 @@ class ConcurrentMarkSweepGeneration: public CardGeneration {
|
||||
void rotate_debug_collection_type();
|
||||
};
|
||||
|
||||
class ASConcurrentMarkSweepGeneration : public ConcurrentMarkSweepGeneration {
|
||||
|
||||
// Return the size policy from the heap's collector
|
||||
// policy casted to CMSAdaptiveSizePolicy*.
|
||||
CMSAdaptiveSizePolicy* cms_size_policy() const;
|
||||
|
||||
// Resize the generation based on the adaptive size
|
||||
// policy.
|
||||
void resize(size_t cur_promo, size_t desired_promo);
|
||||
|
||||
// Return the GC counters from the collector policy
|
||||
CMSGCAdaptivePolicyCounters* gc_adaptive_policy_counters();
|
||||
|
||||
virtual void shrink_by(size_t bytes);
|
||||
|
||||
public:
|
||||
ASConcurrentMarkSweepGeneration(ReservedSpace rs, size_t initial_byte_size,
|
||||
int level, CardTableRS* ct,
|
||||
bool use_adaptive_freelists,
|
||||
FreeBlockDictionary<FreeChunk>::DictionaryChoice
|
||||
dictionaryChoice) :
|
||||
ConcurrentMarkSweepGeneration(rs, initial_byte_size, level, ct,
|
||||
use_adaptive_freelists, dictionaryChoice) {}
|
||||
|
||||
virtual const char* short_name() const { return "ASCMS"; }
|
||||
virtual Generation::Name kind() { return Generation::ASConcurrentMarkSweep; }
|
||||
|
||||
virtual void update_counters();
|
||||
virtual void update_counters(size_t used);
|
||||
};
|
||||
|
||||
//
|
||||
// Closures of various sorts used by CMS to accomplish its work
|
||||
//
|
||||
|
@ -24,6 +24,7 @@
|
||||
|
||||
#include "precompiled.hpp"
|
||||
#include "classfile/symbolTable.hpp"
|
||||
#include "code/codeCache.hpp"
|
||||
#include "gc_implementation/g1/concurrentMark.inline.hpp"
|
||||
#include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
|
||||
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
|
||||
@ -39,6 +40,7 @@
|
||||
#include "gc_implementation/shared/gcTimer.hpp"
|
||||
#include "gc_implementation/shared/gcTrace.hpp"
|
||||
#include "gc_implementation/shared/gcTraceTime.hpp"
|
||||
#include "memory/allocation.hpp"
|
||||
#include "memory/genOopClosures.inline.hpp"
|
||||
#include "memory/referencePolicy.hpp"
|
||||
#include "memory/resourceArea.hpp"
|
||||
@ -58,8 +60,8 @@ CMBitMapRO::CMBitMapRO(int shifter) :
|
||||
_bmWordSize = 0;
|
||||
}
|
||||
|
||||
HeapWord* CMBitMapRO::getNextMarkedWordAddress(HeapWord* addr,
|
||||
HeapWord* limit) const {
|
||||
HeapWord* CMBitMapRO::getNextMarkedWordAddress(const HeapWord* addr,
|
||||
const HeapWord* limit) const {
|
||||
// First we must round addr *up* to a possible object boundary.
|
||||
addr = (HeapWord*)align_size_up((intptr_t)addr,
|
||||
HeapWordSize << _shifter);
|
||||
@ -76,8 +78,8 @@ HeapWord* CMBitMapRO::getNextMarkedWordAddress(HeapWord* addr,
|
||||
return nextAddr;
|
||||
}
|
||||
|
||||
HeapWord* CMBitMapRO::getNextUnmarkedWordAddress(HeapWord* addr,
|
||||
HeapWord* limit) const {
|
||||
HeapWord* CMBitMapRO::getNextUnmarkedWordAddress(const HeapWord* addr,
|
||||
const HeapWord* limit) const {
|
||||
size_t addrOffset = heapWordToOffset(addr);
|
||||
if (limit == NULL) {
|
||||
limit = _bmStartWord + _bmWordSize;
|
||||
@ -1223,6 +1225,9 @@ public:
|
||||
};
|
||||
|
||||
void ConcurrentMark::scanRootRegions() {
|
||||
// Start of concurrent marking.
|
||||
ClassLoaderDataGraph::clear_claimed_marks();
|
||||
|
||||
// scan_in_progress() will have been set to true only if there was
|
||||
// at least one root region to scan. So, if it's false, we
|
||||
// should not attempt to do any further work.
|
||||
@ -1271,7 +1276,7 @@ void ConcurrentMark::markFromRoots() {
|
||||
CMConcurrentMarkingTask markingTask(this, cmThread());
|
||||
if (use_parallel_marking_threads()) {
|
||||
_parallel_workers->set_active_workers((int)active_workers);
|
||||
// Don't set _n_par_threads because it affects MT in process_strong_roots()
|
||||
// Don't set _n_par_threads because it affects MT in process_roots()
|
||||
// and the decisions on that MT processing is made elsewhere.
|
||||
assert(_parallel_workers->active_workers() > 0, "Should have been set");
|
||||
_parallel_workers->run_task(&markingTask);
|
||||
@ -2142,23 +2147,29 @@ void ConcurrentMark::cleanup() {
|
||||
// Update the soft reference policy with the new heap occupancy.
|
||||
Universe::update_heap_info_at_gc();
|
||||
|
||||
// We need to make this be a "collection" so any collection pause that
|
||||
// races with it goes around and waits for completeCleanup to finish.
|
||||
g1h->increment_total_collections();
|
||||
|
||||
// We reclaimed old regions so we should calculate the sizes to make
|
||||
// sure we update the old gen/space data.
|
||||
g1h->g1mm()->update_sizes();
|
||||
|
||||
if (VerifyDuringGC) {
|
||||
HandleMark hm; // handle scope
|
||||
Universe::heap()->prepare_for_verify();
|
||||
Universe::verify(VerifyOption_G1UsePrevMarking,
|
||||
" VerifyDuringGC:(after)");
|
||||
}
|
||||
|
||||
g1h->check_bitmaps("Cleanup End");
|
||||
|
||||
g1h->verify_region_sets_optional();
|
||||
|
||||
// We need to make this be a "collection" so any collection pause that
|
||||
// races with it goes around and waits for completeCleanup to finish.
|
||||
g1h->increment_total_collections();
|
||||
|
||||
// Clean out dead classes and update Metaspace sizes.
|
||||
ClassLoaderDataGraph::purge();
|
||||
MetaspaceGC::compute_new_size();
|
||||
|
||||
// We reclaimed old regions so we should calculate the sizes to make
|
||||
// sure we update the old gen/space data.
|
||||
g1h->g1mm()->update_sizes();
|
||||
|
||||
g1h->trace_heap_after_concurrent_cycle();
|
||||
}
|
||||
|
||||
@ -2445,6 +2456,26 @@ void G1CMRefProcTaskExecutor::execute(EnqueueTask& enq_task) {
|
||||
_g1h->set_par_threads(0);
|
||||
}
|
||||
|
||||
void ConcurrentMark::weakRefsWorkParallelPart(BoolObjectClosure* is_alive, bool purged_classes) {
|
||||
G1CollectedHeap::heap()->parallel_cleaning(is_alive, true, true, purged_classes);
|
||||
}
|
||||
|
||||
// Helper class to get rid of some boilerplate code.
|
||||
class G1RemarkGCTraceTime : public GCTraceTime {
|
||||
static bool doit_and_prepend(bool doit) {
|
||||
if (doit) {
|
||||
gclog_or_tty->put(' ');
|
||||
}
|
||||
return doit;
|
||||
}
|
||||
|
||||
public:
|
||||
G1RemarkGCTraceTime(const char* title, bool doit)
|
||||
: GCTraceTime(title, doit_and_prepend(doit), false, G1CollectedHeap::heap()->gc_timer_cm(),
|
||||
G1CollectedHeap::heap()->concurrent_mark()->concurrent_gc_id()) {
|
||||
}
|
||||
};
|
||||
|
||||
void ConcurrentMark::weakRefsWork(bool clear_all_soft_refs) {
|
||||
if (has_overflown()) {
|
||||
// Skip processing the discovered references if we have
|
||||
@ -2557,9 +2588,28 @@ void ConcurrentMark::weakRefsWork(bool clear_all_soft_refs) {
|
||||
return;
|
||||
}
|
||||
|
||||
g1h->unlink_string_and_symbol_table(&g1_is_alive,
|
||||
/* process_strings */ false, // currently strings are always roots
|
||||
/* process_symbols */ true);
|
||||
assert(_markStack.isEmpty(), "Marking should have completed");
|
||||
|
||||
// Unload Klasses, String, Symbols, Code Cache, etc.
|
||||
|
||||
G1RemarkGCTraceTime trace("Unloading", G1Log::finer());
|
||||
|
||||
bool purged_classes;
|
||||
|
||||
{
|
||||
G1RemarkGCTraceTime trace("System Dictionary Unloading", G1Log::finest());
|
||||
purged_classes = SystemDictionary::do_unloading(&g1_is_alive);
|
||||
}
|
||||
|
||||
{
|
||||
G1RemarkGCTraceTime trace("Parallel Unloading", G1Log::finest());
|
||||
weakRefsWorkParallelPart(&g1_is_alive, purged_classes);
|
||||
}
|
||||
|
||||
if (G1StringDedup::is_enabled()) {
|
||||
G1RemarkGCTraceTime trace("String Deduplication Unlink", G1Log::finest());
|
||||
G1StringDedup::unlink(&g1_is_alive);
|
||||
}
|
||||
}
|
||||
|
||||
void ConcurrentMark::swapMarkBitMaps() {
|
||||
@ -2568,6 +2618,57 @@ void ConcurrentMark::swapMarkBitMaps() {
|
||||
_nextMarkBitMap = (CMBitMap*) temp;
|
||||
}
|
||||
|
||||
class CMObjectClosure;
|
||||
|
||||
// Closure for iterating over objects, currently only used for
|
||||
// processing SATB buffers.
|
||||
class CMObjectClosure : public ObjectClosure {
|
||||
private:
|
||||
CMTask* _task;
|
||||
|
||||
public:
|
||||
void do_object(oop obj) {
|
||||
_task->deal_with_reference(obj);
|
||||
}
|
||||
|
||||
CMObjectClosure(CMTask* task) : _task(task) { }
|
||||
};
|
||||
|
||||
class G1RemarkThreadsClosure : public ThreadClosure {
|
||||
CMObjectClosure _cm_obj;
|
||||
G1CMOopClosure _cm_cl;
|
||||
MarkingCodeBlobClosure _code_cl;
|
||||
int _thread_parity;
|
||||
bool _is_par;
|
||||
|
||||
public:
|
||||
G1RemarkThreadsClosure(G1CollectedHeap* g1h, CMTask* task, bool is_par) :
|
||||
_cm_obj(task), _cm_cl(g1h, g1h->concurrent_mark(), task), _code_cl(&_cm_cl, !CodeBlobToOopClosure::FixRelocations),
|
||||
_thread_parity(SharedHeap::heap()->strong_roots_parity()), _is_par(is_par) {}
|
||||
|
||||
void do_thread(Thread* thread) {
|
||||
if (thread->is_Java_thread()) {
|
||||
if (thread->claim_oops_do(_is_par, _thread_parity)) {
|
||||
JavaThread* jt = (JavaThread*)thread;
|
||||
|
||||
// In theory it should not be neccessary to explicitly walk the nmethods to find roots for concurrent marking
|
||||
// however the liveness of oops reachable from nmethods have very complex lifecycles:
|
||||
// * Alive if on the stack of an executing method
|
||||
// * Weakly reachable otherwise
|
||||
// Some objects reachable from nmethods, such as the class loader (or klass_holder) of the receiver should be
|
||||
// live by the SATB invariant but other oops recorded in nmethods may behave differently.
|
||||
jt->nmethods_do(&_code_cl);
|
||||
|
||||
jt->satb_mark_queue().apply_closure_and_empty(&_cm_obj);
|
||||
}
|
||||
} else if (thread->is_VM_thread()) {
|
||||
if (thread->claim_oops_do(_is_par, _thread_parity)) {
|
||||
JavaThread::satb_mark_queue_set().shared_satb_queue()->apply_closure_and_empty(&_cm_obj);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
class CMRemarkTask: public AbstractGangTask {
|
||||
private:
|
||||
ConcurrentMark* _cm;
|
||||
@ -2579,6 +2680,14 @@ public:
|
||||
if (worker_id < _cm->active_tasks()) {
|
||||
CMTask* task = _cm->task(worker_id);
|
||||
task->record_start_time();
|
||||
{
|
||||
ResourceMark rm;
|
||||
HandleMark hm;
|
||||
|
||||
G1RemarkThreadsClosure threads_f(G1CollectedHeap::heap(), task, !_is_serial);
|
||||
Threads::threads_do(&threads_f);
|
||||
}
|
||||
|
||||
do {
|
||||
task->do_marking_step(1000000000.0 /* something very large */,
|
||||
true /* do_termination */,
|
||||
@ -2601,6 +2710,8 @@ void ConcurrentMark::checkpointRootsFinalWork() {
|
||||
HandleMark hm;
|
||||
G1CollectedHeap* g1h = G1CollectedHeap::heap();
|
||||
|
||||
G1RemarkGCTraceTime trace("Finalize Marking", G1Log::finer());
|
||||
|
||||
g1h->ensure_parsability(false);
|
||||
|
||||
if (G1CollectedHeap::use_parallel_gc_threads()) {
|
||||
@ -3430,20 +3541,6 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
// Closure for iterating over objects, currently only used for
|
||||
// processing SATB buffers.
|
||||
class CMObjectClosure : public ObjectClosure {
|
||||
private:
|
||||
CMTask* _task;
|
||||
|
||||
public:
|
||||
void do_object(oop obj) {
|
||||
_task->deal_with_reference(obj);
|
||||
}
|
||||
|
||||
CMObjectClosure(CMTask* task) : _task(task) { }
|
||||
};
|
||||
|
||||
G1CMOopClosure::G1CMOopClosure(G1CollectedHeap* g1h,
|
||||
ConcurrentMark* cm,
|
||||
CMTask* task)
|
||||
@ -3908,15 +4005,6 @@ void CMTask::drain_satb_buffers() {
|
||||
}
|
||||
}
|
||||
|
||||
if (!concurrent() && !has_aborted()) {
|
||||
// We should only do this during remark.
|
||||
if (G1CollectedHeap::use_parallel_gc_threads()) {
|
||||
satb_mq_set.par_iterate_closure_all_threads(_worker_id);
|
||||
} else {
|
||||
satb_mq_set.iterate_closure_all_threads();
|
||||
}
|
||||
}
|
||||
|
||||
_draining_satb_buffers = false;
|
||||
|
||||
assert(has_aborted() ||
|
||||
|
@ -25,6 +25,7 @@
|
||||
#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_HPP
|
||||
#define SHARE_VM_GC_IMPLEMENTATION_G1_CONCURRENTMARK_HPP
|
||||
|
||||
#include "classfile/javaClasses.hpp"
|
||||
#include "gc_implementation/g1/heapRegionSet.hpp"
|
||||
#include "gc_implementation/shared/gcId.hpp"
|
||||
#include "utilities/taskqueue.hpp"
|
||||
@ -86,19 +87,19 @@ class CMBitMapRO VALUE_OBJ_CLASS_SPEC {
|
||||
// Return the address corresponding to the next marked bit at or after
|
||||
// "addr", and before "limit", if "limit" is non-NULL. If there is no
|
||||
// such bit, returns "limit" if that is non-NULL, or else "endWord()".
|
||||
HeapWord* getNextMarkedWordAddress(HeapWord* addr,
|
||||
HeapWord* limit = NULL) const;
|
||||
HeapWord* getNextMarkedWordAddress(const HeapWord* addr,
|
||||
const HeapWord* limit = NULL) const;
|
||||
// Return the address corresponding to the next unmarked bit at or after
|
||||
// "addr", and before "limit", if "limit" is non-NULL. If there is no
|
||||
// such bit, returns "limit" if that is non-NULL, or else "endWord()".
|
||||
HeapWord* getNextUnmarkedWordAddress(HeapWord* addr,
|
||||
HeapWord* limit = NULL) const;
|
||||
HeapWord* getNextUnmarkedWordAddress(const HeapWord* addr,
|
||||
const HeapWord* limit = NULL) const;
|
||||
|
||||
// conversion utilities
|
||||
HeapWord* offsetToHeapWord(size_t offset) const {
|
||||
return _bmStartWord + (offset << _shifter);
|
||||
}
|
||||
size_t heapWordToOffset(HeapWord* addr) const {
|
||||
size_t heapWordToOffset(const HeapWord* addr) const {
|
||||
return pointer_delta(addr, _bmStartWord) >> _shifter;
|
||||
}
|
||||
int heapWordDiffToOffsetDiff(size_t diff) const;
|
||||
@ -476,6 +477,7 @@ protected:
|
||||
ForceOverflowSettings _force_overflow_conc;
|
||||
ForceOverflowSettings _force_overflow_stw;
|
||||
|
||||
void weakRefsWorkParallelPart(BoolObjectClosure* is_alive, bool purged_classes);
|
||||
void weakRefsWork(bool clear_all_soft_refs);
|
||||
|
||||
void swapMarkBitMaps();
|
||||
|
@ -26,6 +26,7 @@
|
||||
#define SHARE_VM_GC_IMPLEMENTATION_G1_G1ALLOCREGION_INLINE_HPP
|
||||
|
||||
#include "gc_implementation/g1/g1AllocRegion.hpp"
|
||||
#include "gc_implementation/g1/heapRegion.inline.hpp"
|
||||
|
||||
inline HeapWord* G1AllocRegion::allocate(HeapRegion* alloc_region,
|
||||
size_t word_size,
|
||||
|
@ -426,7 +426,7 @@ G1BlockOffsetArray::forward_to_block_containing_addr_slow(HeapWord* q,
|
||||
q = n;
|
||||
oop obj = oop(q);
|
||||
if (obj->klass_or_null() == NULL) return q;
|
||||
n += obj->size();
|
||||
n += block_size(q);
|
||||
}
|
||||
assert(q <= next_boundary && n > next_boundary, "Consequence of loop");
|
||||
// [q, n) is the block that crosses the boundary.
|
||||
|
@ -26,7 +26,8 @@
|
||||
#define SHARE_VM_GC_IMPLEMENTATION_G1_G1BLOCKOFFSETTABLE_INLINE_HPP
|
||||
|
||||
#include "gc_implementation/g1/g1BlockOffsetTable.hpp"
|
||||
#include "gc_implementation/g1/heapRegion.hpp"
|
||||
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
|
||||
#include "gc_implementation/g1/heapRegion.inline.hpp"
|
||||
#include "memory/space.hpp"
|
||||
|
||||
inline HeapWord* G1BlockOffsetTable::block_start(const void* addr) {
|
||||
@ -112,7 +113,7 @@ forward_to_block_containing_addr_const(HeapWord* q, HeapWord* n,
|
||||
q = n;
|
||||
oop obj = oop(q);
|
||||
if (obj->klass_or_null() == NULL) return q;
|
||||
n += obj->size();
|
||||
n += block_size(q);
|
||||
}
|
||||
assert(q <= n, "wrong order for q and addr");
|
||||
assert(addr < n, "wrong order for addr and n");
|
||||
|
@ -30,23 +30,52 @@
|
||||
|
||||
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
|
||||
|
||||
G1CodeRootChunk::G1CodeRootChunk() : _top(NULL), _next(NULL), _prev(NULL) {
|
||||
G1CodeRootChunk::G1CodeRootChunk() : _top(NULL), _next(NULL), _prev(NULL), _free(NULL) {
|
||||
_top = bottom();
|
||||
}
|
||||
|
||||
void G1CodeRootChunk::reset() {
|
||||
_next = _prev = NULL;
|
||||
_free = NULL;
|
||||
_top = bottom();
|
||||
}
|
||||
|
||||
void G1CodeRootChunk::nmethods_do(CodeBlobClosure* cl) {
|
||||
nmethod** cur = bottom();
|
||||
NmethodOrLink* cur = bottom();
|
||||
while (cur != _top) {
|
||||
cl->do_code_blob(*cur);
|
||||
if (is_nmethod(cur)) {
|
||||
cl->do_code_blob(cur->_nmethod);
|
||||
}
|
||||
cur++;
|
||||
}
|
||||
}
|
||||
|
||||
bool G1CodeRootChunk::remove_lock_free(nmethod* method) {
|
||||
NmethodOrLink* cur = bottom();
|
||||
|
||||
for (NmethodOrLink* cur = bottom(); cur != _top; cur++) {
|
||||
if (cur->_nmethod == method) {
|
||||
bool result = Atomic::cmpxchg_ptr(NULL, &cur->_nmethod, method) == method;
|
||||
|
||||
if (!result) {
|
||||
// Someone else cleared out this entry.
|
||||
return false;
|
||||
}
|
||||
|
||||
// The method was cleared. Time to link it into the free list.
|
||||
NmethodOrLink* prev_free;
|
||||
do {
|
||||
prev_free = (NmethodOrLink*)_free;
|
||||
cur->_link = prev_free;
|
||||
} while (Atomic::cmpxchg_ptr(cur, &_free, prev_free) != prev_free);
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
G1CodeRootChunkManager::G1CodeRootChunkManager() : _free_list(), _num_chunks_handed_out(0) {
|
||||
_free_list.initialize();
|
||||
_free_list.set_size(G1CodeRootChunk::word_size());
|
||||
@ -140,34 +169,43 @@ G1CodeRootSet::~G1CodeRootSet() {
|
||||
|
||||
void G1CodeRootSet::add(nmethod* method) {
|
||||
if (!contains(method)) {
|
||||
// Try to add the nmethod. If there is not enough space, get a new chunk.
|
||||
if (_list.head() == NULL || _list.head()->is_full()) {
|
||||
G1CodeRootChunk* cur = new_chunk();
|
||||
// Find the first chunk thatisn't full.
|
||||
G1CodeRootChunk* cur = _list.head();
|
||||
while (cur != NULL) {
|
||||
if (!cur->is_full()) {
|
||||
break;
|
||||
}
|
||||
cur = cur->next();
|
||||
}
|
||||
|
||||
// All chunks are full, get a new chunk.
|
||||
if (cur == NULL) {
|
||||
cur = new_chunk();
|
||||
_list.return_chunk_at_head(cur);
|
||||
}
|
||||
bool result = _list.head()->add(method);
|
||||
|
||||
// Add the nmethod.
|
||||
bool result = cur->add(method);
|
||||
|
||||
guarantee(result, err_msg("Not able to add nmethod "PTR_FORMAT" to newly allocated chunk.", method));
|
||||
|
||||
_length++;
|
||||
}
|
||||
}
|
||||
|
||||
void G1CodeRootSet::remove(nmethod* method) {
|
||||
void G1CodeRootSet::remove_lock_free(nmethod* method) {
|
||||
G1CodeRootChunk* found = find(method);
|
||||
if (found != NULL) {
|
||||
bool result = found->remove(method);
|
||||
guarantee(result, err_msg("could not find nmethod "PTR_FORMAT" during removal although we previously found it", method));
|
||||
// eventually free completely emptied chunk
|
||||
if (found->is_empty()) {
|
||||
_list.remove_chunk(found);
|
||||
free(found);
|
||||
bool result = found->remove_lock_free(method);
|
||||
if (result) {
|
||||
Atomic::dec_ptr((volatile intptr_t*)&_length);
|
||||
}
|
||||
_length--;
|
||||
}
|
||||
assert(!contains(method), err_msg(PTR_FORMAT" still contains nmethod "PTR_FORMAT, this, method));
|
||||
}
|
||||
|
||||
nmethod* G1CodeRootSet::pop() {
|
||||
do {
|
||||
while (true) {
|
||||
G1CodeRootChunk* cur = _list.head();
|
||||
if (cur == NULL) {
|
||||
assert(_length == 0, "when there are no chunks, there should be no elements");
|
||||
@ -180,7 +218,7 @@ nmethod* G1CodeRootSet::pop() {
|
||||
} else {
|
||||
free(_list.get_chunk_at_head());
|
||||
}
|
||||
} while (true);
|
||||
}
|
||||
}
|
||||
|
||||
G1CodeRootChunk* G1CodeRootSet::find(nmethod* method) {
|
||||
|
@ -31,6 +31,14 @@
|
||||
|
||||
class CodeBlobClosure;
|
||||
|
||||
// The elements of the G1CodeRootChunk is either:
|
||||
// 1) nmethod pointers
|
||||
// 2) nodes in an internally chained free list
|
||||
typedef union {
|
||||
nmethod* _nmethod;
|
||||
void* _link;
|
||||
} NmethodOrLink;
|
||||
|
||||
class G1CodeRootChunk : public CHeapObj<mtGC> {
|
||||
private:
|
||||
static const int NUM_ENTRIES = 32;
|
||||
@ -38,16 +46,28 @@ class G1CodeRootChunk : public CHeapObj<mtGC> {
|
||||
G1CodeRootChunk* _next;
|
||||
G1CodeRootChunk* _prev;
|
||||
|
||||
nmethod** _top;
|
||||
NmethodOrLink* _top;
|
||||
// First free position within the chunk.
|
||||
volatile NmethodOrLink* _free;
|
||||
|
||||
nmethod* _data[NUM_ENTRIES];
|
||||
NmethodOrLink _data[NUM_ENTRIES];
|
||||
|
||||
nmethod** bottom() const {
|
||||
return (nmethod**) &(_data[0]);
|
||||
NmethodOrLink* bottom() const {
|
||||
return (NmethodOrLink*) &(_data[0]);
|
||||
}
|
||||
|
||||
nmethod** end() const {
|
||||
return (nmethod**) &(_data[NUM_ENTRIES]);
|
||||
NmethodOrLink* end() const {
|
||||
return (NmethodOrLink*) &(_data[NUM_ENTRIES]);
|
||||
}
|
||||
|
||||
bool is_link(NmethodOrLink* nmethod_or_link) {
|
||||
return nmethod_or_link->_link == NULL ||
|
||||
(bottom() <= nmethod_or_link->_link
|
||||
&& nmethod_or_link->_link < end());
|
||||
}
|
||||
|
||||
bool is_nmethod(NmethodOrLink* nmethod_or_link) {
|
||||
return !is_link(nmethod_or_link);
|
||||
}
|
||||
|
||||
public:
|
||||
@ -85,46 +105,55 @@ class G1CodeRootChunk : public CHeapObj<mtGC> {
|
||||
}
|
||||
|
||||
bool is_full() const {
|
||||
return _top == (nmethod**)end();
|
||||
return _top == end() && _free == NULL;
|
||||
}
|
||||
|
||||
bool contains(nmethod* method) {
|
||||
nmethod** cur = bottom();
|
||||
NmethodOrLink* cur = bottom();
|
||||
while (cur != _top) {
|
||||
if (*cur == method) return true;
|
||||
if (cur->_nmethod == method) return true;
|
||||
cur++;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool add(nmethod* method) {
|
||||
if (is_full()) return false;
|
||||
*_top = method;
|
||||
_top++;
|
||||
if (is_full()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (_free != NULL) {
|
||||
// Take from internally chained free list
|
||||
NmethodOrLink* first_free = (NmethodOrLink*)_free;
|
||||
_free = (NmethodOrLink*)_free->_link;
|
||||
first_free->_nmethod = method;
|
||||
} else {
|
||||
// Take from top.
|
||||
_top->_nmethod = method;
|
||||
_top++;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool remove(nmethod* method) {
|
||||
nmethod** cur = bottom();
|
||||
while (cur != _top) {
|
||||
if (*cur == method) {
|
||||
memmove(cur, cur + 1, (_top - (cur + 1)) * sizeof(nmethod**));
|
||||
_top--;
|
||||
return true;
|
||||
}
|
||||
cur++;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool remove_lock_free(nmethod* method);
|
||||
|
||||
void nmethods_do(CodeBlobClosure* blk);
|
||||
|
||||
nmethod* pop() {
|
||||
if (is_empty()) {
|
||||
return NULL;
|
||||
if (_free != NULL) {
|
||||
// Kill the free list.
|
||||
_free = NULL;
|
||||
}
|
||||
_top--;
|
||||
return *_top;
|
||||
|
||||
while (!is_empty()) {
|
||||
_top--;
|
||||
if (is_nmethod(_top)) {
|
||||
return _top->_nmethod;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
};
|
||||
|
||||
@ -193,7 +222,7 @@ class G1CodeRootSet VALUE_OBJ_CLASS_SPEC {
|
||||
// method is likely to be repeatedly called with the same nmethod.
|
||||
void add(nmethod* method);
|
||||
|
||||
void remove(nmethod* method);
|
||||
void remove_lock_free(nmethod* method);
|
||||
nmethod* pop();
|
||||
|
||||
bool contains(nmethod* method);
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -31,7 +31,6 @@
|
||||
#include "gc_implementation/g1/g1BiasedArray.hpp"
|
||||
#include "gc_implementation/g1/g1HRPrinter.hpp"
|
||||
#include "gc_implementation/g1/g1MonitoringSupport.hpp"
|
||||
#include "gc_implementation/g1/g1RemSet.hpp"
|
||||
#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
|
||||
#include "gc_implementation/g1/g1YCTypes.hpp"
|
||||
#include "gc_implementation/g1/heapRegionSeq.hpp"
|
||||
@ -211,6 +210,7 @@ class G1FastCSetBiasedMappedArray : public G1BiasedMappedArray<bool> {
|
||||
class RefineCardTableEntryClosure;
|
||||
|
||||
class G1CollectedHeap : public SharedHeap {
|
||||
friend class VM_CollectForMetadataAllocation;
|
||||
friend class VM_G1CollectForAllocation;
|
||||
friend class VM_G1CollectFull;
|
||||
friend class VM_G1IncCollectionPause;
|
||||
@ -220,7 +220,7 @@ class G1CollectedHeap : public SharedHeap {
|
||||
friend class OldGCAllocRegion;
|
||||
|
||||
// Closures used in implementation.
|
||||
template <G1Barrier barrier, bool do_mark_object>
|
||||
template <G1Barrier barrier, G1Mark do_mark_object>
|
||||
friend class G1ParCopyClosure;
|
||||
friend class G1IsAliveClosure;
|
||||
friend class G1EvacuateFollowersClosure;
|
||||
@ -347,6 +347,9 @@ private:
|
||||
// It initializes the GC alloc regions at the start of a GC.
|
||||
void init_gc_alloc_regions(EvacuationInfo& evacuation_info);
|
||||
|
||||
// Setup the retained old gc alloc region as the currrent old gc alloc region.
|
||||
void use_retained_old_gc_alloc_region(EvacuationInfo& evacuation_info);
|
||||
|
||||
// It releases the GC alloc regions at the end of a GC.
|
||||
void release_gc_alloc_regions(uint no_of_gc_workers, EvacuationInfo& evacuation_info);
|
||||
|
||||
@ -828,12 +831,13 @@ protected:
|
||||
// param is for use with parallel roots processing, and should be
|
||||
// the "i" of the calling parallel worker thread's work(i) function.
|
||||
// In the sequential case this param will be ignored.
|
||||
void g1_process_strong_roots(bool is_scavenging,
|
||||
ScanningOption so,
|
||||
OopClosure* scan_non_heap_roots,
|
||||
OopsInHeapRegionClosure* scan_rs,
|
||||
G1KlassScanClosure* scan_klasses,
|
||||
uint worker_i);
|
||||
void g1_process_roots(OopClosure* scan_non_heap_roots,
|
||||
OopClosure* scan_non_heap_weak_roots,
|
||||
OopsInHeapRegionClosure* scan_rs,
|
||||
CLDClosure* scan_strong_clds,
|
||||
CLDClosure* scan_weak_clds,
|
||||
CodeBlobClosure* scan_strong_code,
|
||||
uint worker_i);
|
||||
|
||||
// Notifies all the necessary spaces that the committed space has
|
||||
// been updated (either expanded or shrunk). It should be called
|
||||
@ -1026,7 +1030,7 @@ protected:
|
||||
// of G1CollectedHeap::_gc_time_stamp.
|
||||
unsigned int* _worker_cset_start_region_time_stamp;
|
||||
|
||||
enum G1H_process_strong_roots_tasks {
|
||||
enum G1H_process_roots_tasks {
|
||||
G1H_PS_filter_satb_buffers,
|
||||
G1H_PS_refProcessor_oops_do,
|
||||
// Leave this one last.
|
||||
@ -1608,10 +1612,6 @@ public:
|
||||
// Free up superfluous code root memory.
|
||||
void purge_code_root_memory();
|
||||
|
||||
// During an initial mark pause, mark all the code roots that
|
||||
// point into regions *not* in the collection set.
|
||||
void mark_strong_code_roots(uint worker_id);
|
||||
|
||||
// Rebuild the strong code root lists for each region
|
||||
// after a full GC.
|
||||
void rebuild_strong_code_roots();
|
||||
@ -1620,6 +1620,9 @@ public:
|
||||
// in symbol table, possibly in parallel.
|
||||
void unlink_string_and_symbol_table(BoolObjectClosure* is_alive, bool unlink_strings = true, bool unlink_symbols = true);
|
||||
|
||||
// Parallel phase of unloading/cleaning after G1 concurrent mark.
|
||||
void parallel_cleaning(BoolObjectClosure* is_alive, bool process_strings, bool process_symbols, bool class_unloading_occurred);
|
||||
|
||||
// Redirty logged cards in the refinement queue.
|
||||
void redirty_logged_cards();
|
||||
// Verification
|
||||
@ -1715,256 +1718,4 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
class G1ParScanThreadState : public StackObj {
|
||||
protected:
|
||||
G1CollectedHeap* _g1h;
|
||||
RefToScanQueue* _refs;
|
||||
DirtyCardQueue _dcq;
|
||||
G1SATBCardTableModRefBS* _ct_bs;
|
||||
G1RemSet* _g1_rem;
|
||||
|
||||
G1ParGCAllocBuffer _surviving_alloc_buffer;
|
||||
G1ParGCAllocBuffer _tenured_alloc_buffer;
|
||||
G1ParGCAllocBuffer* _alloc_buffers[GCAllocPurposeCount];
|
||||
ageTable _age_table;
|
||||
|
||||
G1ParScanClosure _scanner;
|
||||
|
||||
size_t _alloc_buffer_waste;
|
||||
size_t _undo_waste;
|
||||
|
||||
OopsInHeapRegionClosure* _evac_failure_cl;
|
||||
|
||||
int _hash_seed;
|
||||
uint _queue_num;
|
||||
|
||||
size_t _term_attempts;
|
||||
|
||||
double _start;
|
||||
double _start_strong_roots;
|
||||
double _strong_roots_time;
|
||||
double _start_term;
|
||||
double _term_time;
|
||||
|
||||
// Map from young-age-index (0 == not young, 1 is youngest) to
|
||||
// surviving words. base is what we get back from the malloc call
|
||||
size_t* _surviving_young_words_base;
|
||||
// this points into the array, as we use the first few entries for padding
|
||||
size_t* _surviving_young_words;
|
||||
|
||||
#define PADDING_ELEM_NUM (DEFAULT_CACHE_LINE_SIZE / sizeof(size_t))
|
||||
|
||||
void add_to_alloc_buffer_waste(size_t waste) { _alloc_buffer_waste += waste; }
|
||||
|
||||
void add_to_undo_waste(size_t waste) { _undo_waste += waste; }
|
||||
|
||||
DirtyCardQueue& dirty_card_queue() { return _dcq; }
|
||||
G1SATBCardTableModRefBS* ctbs() { return _ct_bs; }
|
||||
|
||||
template <class T> inline void immediate_rs_update(HeapRegion* from, T* p, int tid);
|
||||
|
||||
template <class T> void deferred_rs_update(HeapRegion* from, T* p, int tid) {
|
||||
// If the new value of the field points to the same region or
|
||||
// is the to-space, we don't need to include it in the Rset updates.
|
||||
if (!from->is_in_reserved(oopDesc::load_decode_heap_oop(p)) && !from->is_survivor()) {
|
||||
size_t card_index = ctbs()->index_for(p);
|
||||
// If the card hasn't been added to the buffer, do it.
|
||||
if (ctbs()->mark_card_deferred(card_index)) {
|
||||
dirty_card_queue().enqueue((jbyte*)ctbs()->byte_for_index(card_index));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num, ReferenceProcessor* rp);
|
||||
|
||||
~G1ParScanThreadState() {
|
||||
retire_alloc_buffers();
|
||||
FREE_C_HEAP_ARRAY(size_t, _surviving_young_words_base, mtGC);
|
||||
}
|
||||
|
||||
RefToScanQueue* refs() { return _refs; }
|
||||
ageTable* age_table() { return &_age_table; }
|
||||
|
||||
G1ParGCAllocBuffer* alloc_buffer(GCAllocPurpose purpose) {
|
||||
return _alloc_buffers[purpose];
|
||||
}
|
||||
|
||||
size_t alloc_buffer_waste() const { return _alloc_buffer_waste; }
|
||||
size_t undo_waste() const { return _undo_waste; }
|
||||
|
||||
#ifdef ASSERT
|
||||
bool verify_ref(narrowOop* ref) const;
|
||||
bool verify_ref(oop* ref) const;
|
||||
bool verify_task(StarTask ref) const;
|
||||
#endif // ASSERT
|
||||
|
||||
template <class T> void push_on_queue(T* ref) {
|
||||
assert(verify_ref(ref), "sanity");
|
||||
refs()->push(ref);
|
||||
}
|
||||
|
||||
template <class T> inline void update_rs(HeapRegion* from, T* p, int tid);
|
||||
|
||||
HeapWord* allocate_slow(GCAllocPurpose purpose, size_t word_sz) {
|
||||
HeapWord* obj = NULL;
|
||||
size_t gclab_word_size = _g1h->desired_plab_sz(purpose);
|
||||
if (word_sz * 100 < gclab_word_size * ParallelGCBufferWastePct) {
|
||||
G1ParGCAllocBuffer* alloc_buf = alloc_buffer(purpose);
|
||||
add_to_alloc_buffer_waste(alloc_buf->words_remaining());
|
||||
alloc_buf->retire(false /* end_of_gc */, false /* retain */);
|
||||
|
||||
HeapWord* buf = _g1h->par_allocate_during_gc(purpose, gclab_word_size);
|
||||
if (buf == NULL) return NULL; // Let caller handle allocation failure.
|
||||
// Otherwise.
|
||||
alloc_buf->set_word_size(gclab_word_size);
|
||||
alloc_buf->set_buf(buf);
|
||||
|
||||
obj = alloc_buf->allocate(word_sz);
|
||||
assert(obj != NULL, "buffer was definitely big enough...");
|
||||
} else {
|
||||
obj = _g1h->par_allocate_during_gc(purpose, word_sz);
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
HeapWord* allocate(GCAllocPurpose purpose, size_t word_sz) {
|
||||
HeapWord* obj = alloc_buffer(purpose)->allocate(word_sz);
|
||||
if (obj != NULL) return obj;
|
||||
return allocate_slow(purpose, word_sz);
|
||||
}
|
||||
|
||||
void undo_allocation(GCAllocPurpose purpose, HeapWord* obj, size_t word_sz) {
|
||||
if (alloc_buffer(purpose)->contains(obj)) {
|
||||
assert(alloc_buffer(purpose)->contains(obj + word_sz - 1),
|
||||
"should contain whole object");
|
||||
alloc_buffer(purpose)->undo_allocation(obj, word_sz);
|
||||
} else {
|
||||
CollectedHeap::fill_with_object(obj, word_sz);
|
||||
add_to_undo_waste(word_sz);
|
||||
}
|
||||
}
|
||||
|
||||
void set_evac_failure_closure(OopsInHeapRegionClosure* evac_failure_cl) {
|
||||
_evac_failure_cl = evac_failure_cl;
|
||||
}
|
||||
OopsInHeapRegionClosure* evac_failure_closure() {
|
||||
return _evac_failure_cl;
|
||||
}
|
||||
|
||||
int* hash_seed() { return &_hash_seed; }
|
||||
uint queue_num() { return _queue_num; }
|
||||
|
||||
size_t term_attempts() const { return _term_attempts; }
|
||||
void note_term_attempt() { _term_attempts++; }
|
||||
|
||||
void start_strong_roots() {
|
||||
_start_strong_roots = os::elapsedTime();
|
||||
}
|
||||
void end_strong_roots() {
|
||||
_strong_roots_time += (os::elapsedTime() - _start_strong_roots);
|
||||
}
|
||||
double strong_roots_time() const { return _strong_roots_time; }
|
||||
|
||||
void start_term_time() {
|
||||
note_term_attempt();
|
||||
_start_term = os::elapsedTime();
|
||||
}
|
||||
void end_term_time() {
|
||||
_term_time += (os::elapsedTime() - _start_term);
|
||||
}
|
||||
double term_time() const { return _term_time; }
|
||||
|
||||
double elapsed_time() const {
|
||||
return os::elapsedTime() - _start;
|
||||
}
|
||||
|
||||
static void
|
||||
print_termination_stats_hdr(outputStream* const st = gclog_or_tty);
|
||||
void
|
||||
print_termination_stats(int i, outputStream* const st = gclog_or_tty) const;
|
||||
|
||||
size_t* surviving_young_words() {
|
||||
// We add on to hide entry 0 which accumulates surviving words for
|
||||
// age -1 regions (i.e. non-young ones)
|
||||
return _surviving_young_words;
|
||||
}
|
||||
|
||||
private:
|
||||
void retire_alloc_buffers() {
|
||||
for (int ap = 0; ap < GCAllocPurposeCount; ++ap) {
|
||||
size_t waste = _alloc_buffers[ap]->words_remaining();
|
||||
add_to_alloc_buffer_waste(waste);
|
||||
_alloc_buffers[ap]->flush_stats_and_retire(_g1h->stats_for_purpose((GCAllocPurpose)ap),
|
||||
true /* end_of_gc */,
|
||||
false /* retain */);
|
||||
}
|
||||
}
|
||||
|
||||
#define G1_PARTIAL_ARRAY_MASK 0x2
|
||||
|
||||
inline bool has_partial_array_mask(oop* ref) const {
|
||||
return ((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) == G1_PARTIAL_ARRAY_MASK;
|
||||
}
|
||||
|
||||
// We never encode partial array oops as narrowOop*, so return false immediately.
|
||||
// This allows the compiler to create optimized code when popping references from
|
||||
// the work queue.
|
||||
inline bool has_partial_array_mask(narrowOop* ref) const {
|
||||
assert(((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) != G1_PARTIAL_ARRAY_MASK, "Partial array oop reference encoded as narrowOop*");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Only implement set_partial_array_mask() for regular oops, not for narrowOops.
|
||||
// We always encode partial arrays as regular oop, to allow the
|
||||
// specialization for has_partial_array_mask() for narrowOops above.
|
||||
// This means that unintentional use of this method with narrowOops are caught
|
||||
// by the compiler.
|
||||
inline oop* set_partial_array_mask(oop obj) const {
|
||||
assert(((uintptr_t)(void *)obj & G1_PARTIAL_ARRAY_MASK) == 0, "Information loss!");
|
||||
return (oop*) ((uintptr_t)(void *)obj | G1_PARTIAL_ARRAY_MASK);
|
||||
}
|
||||
|
||||
inline oop clear_partial_array_mask(oop* ref) const {
|
||||
return cast_to_oop((intptr_t)ref & ~G1_PARTIAL_ARRAY_MASK);
|
||||
}
|
||||
|
||||
inline void do_oop_partial_array(oop* p);
|
||||
|
||||
// This method is applied to the fields of the objects that have just been copied.
|
||||
template <class T> void do_oop_evac(T* p, HeapRegion* from) {
|
||||
assert(!oopDesc::is_null(oopDesc::load_decode_heap_oop(p)),
|
||||
"Reference should not be NULL here as such are never pushed to the task queue.");
|
||||
oop obj = oopDesc::load_decode_heap_oop_not_null(p);
|
||||
|
||||
// Although we never intentionally push references outside of the collection
|
||||
// set, due to (benign) races in the claim mechanism during RSet scanning more
|
||||
// than one thread might claim the same card. So the same card may be
|
||||
// processed multiple times. So redo this check.
|
||||
if (_g1h->in_cset_fast_test(obj)) {
|
||||
oop forwardee;
|
||||
if (obj->is_forwarded()) {
|
||||
forwardee = obj->forwardee();
|
||||
} else {
|
||||
forwardee = copy_to_survivor_space(obj);
|
||||
}
|
||||
assert(forwardee != NULL, "forwardee should not be NULL");
|
||||
oopDesc::encode_store_heap_oop(p, forwardee);
|
||||
}
|
||||
|
||||
assert(obj != NULL, "Must be");
|
||||
update_rs(from, p, queue_num());
|
||||
}
|
||||
public:
|
||||
|
||||
oop copy_to_survivor_space(oop const obj);
|
||||
|
||||
template <class T> inline void deal_with_reference(T* ref_to_scan);
|
||||
|
||||
inline void deal_with_reference(StarTask ref);
|
||||
|
||||
public:
|
||||
void trim_queue();
|
||||
};
|
||||
|
||||
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
|
||||
|
@ -29,7 +29,6 @@
|
||||
#include "gc_implementation/g1/g1CollectedHeap.hpp"
|
||||
#include "gc_implementation/g1/g1AllocRegion.inline.hpp"
|
||||
#include "gc_implementation/g1/g1CollectorPolicy.hpp"
|
||||
#include "gc_implementation/g1/g1RemSet.inline.hpp"
|
||||
#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
|
||||
#include "gc_implementation/g1/heapRegionSet.inline.hpp"
|
||||
#include "gc_implementation/g1/heapRegionSeq.inline.hpp"
|
||||
@ -289,89 +288,4 @@ inline bool G1CollectedHeap::is_obj_ill(const oop obj) const {
|
||||
return is_obj_ill(obj, heap_region_containing(obj));
|
||||
}
|
||||
|
||||
template <class T> inline void G1ParScanThreadState::immediate_rs_update(HeapRegion* from, T* p, int tid) {
|
||||
if (!from->is_survivor()) {
|
||||
_g1_rem->par_write_ref(from, p, tid);
|
||||
}
|
||||
}
|
||||
|
||||
template <class T> void G1ParScanThreadState::update_rs(HeapRegion* from, T* p, int tid) {
|
||||
if (G1DeferredRSUpdate) {
|
||||
deferred_rs_update(from, p, tid);
|
||||
} else {
|
||||
immediate_rs_update(from, p, tid);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
inline void G1ParScanThreadState::do_oop_partial_array(oop* p) {
|
||||
assert(has_partial_array_mask(p), "invariant");
|
||||
oop from_obj = clear_partial_array_mask(p);
|
||||
|
||||
assert(Universe::heap()->is_in_reserved(from_obj), "must be in heap.");
|
||||
assert(from_obj->is_objArray(), "must be obj array");
|
||||
objArrayOop from_obj_array = objArrayOop(from_obj);
|
||||
// The from-space object contains the real length.
|
||||
int length = from_obj_array->length();
|
||||
|
||||
assert(from_obj->is_forwarded(), "must be forwarded");
|
||||
oop to_obj = from_obj->forwardee();
|
||||
assert(from_obj != to_obj, "should not be chunking self-forwarded objects");
|
||||
objArrayOop to_obj_array = objArrayOop(to_obj);
|
||||
// We keep track of the next start index in the length field of the
|
||||
// to-space object.
|
||||
int next_index = to_obj_array->length();
|
||||
assert(0 <= next_index && next_index < length,
|
||||
err_msg("invariant, next index: %d, length: %d", next_index, length));
|
||||
|
||||
int start = next_index;
|
||||
int end = length;
|
||||
int remainder = end - start;
|
||||
// We'll try not to push a range that's smaller than ParGCArrayScanChunk.
|
||||
if (remainder > 2 * ParGCArrayScanChunk) {
|
||||
end = start + ParGCArrayScanChunk;
|
||||
to_obj_array->set_length(end);
|
||||
// Push the remainder before we process the range in case another
|
||||
// worker has run out of things to do and can steal it.
|
||||
oop* from_obj_p = set_partial_array_mask(from_obj);
|
||||
push_on_queue(from_obj_p);
|
||||
} else {
|
||||
assert(length == end, "sanity");
|
||||
// We'll process the final range for this object. Restore the length
|
||||
// so that the heap remains parsable in case of evacuation failure.
|
||||
to_obj_array->set_length(end);
|
||||
}
|
||||
_scanner.set_region(_g1h->heap_region_containing_raw(to_obj));
|
||||
// Process indexes [start,end). It will also process the header
|
||||
// along with the first chunk (i.e., the chunk with start == 0).
|
||||
// Note that at this point the length field of to_obj_array is not
|
||||
// correct given that we are using it to keep track of the next
|
||||
// start index. oop_iterate_range() (thankfully!) ignores the length
|
||||
// field and only relies on the start / end parameters. It does
|
||||
// however return the size of the object which will be incorrect. So
|
||||
// we have to ignore it even if we wanted to use it.
|
||||
to_obj_array->oop_iterate_range(&_scanner, start, end);
|
||||
}
|
||||
|
||||
template <class T> inline void G1ParScanThreadState::deal_with_reference(T* ref_to_scan) {
|
||||
if (!has_partial_array_mask(ref_to_scan)) {
|
||||
// Note: we can use "raw" versions of "region_containing" because
|
||||
// "obj_to_scan" is definitely in the heap, and is not in a
|
||||
// humongous region.
|
||||
HeapRegion* r = _g1h->heap_region_containing_raw(ref_to_scan);
|
||||
do_oop_evac(ref_to_scan, r);
|
||||
} else {
|
||||
do_oop_partial_array((oop*)ref_to_scan);
|
||||
}
|
||||
}
|
||||
|
||||
inline void G1ParScanThreadState::deal_with_reference(StarTask ref) {
|
||||
assert(verify_task(ref), "sanity");
|
||||
if (ref.is_narrow()) {
|
||||
deal_with_reference((narrowOop*)ref);
|
||||
} else {
|
||||
deal_with_reference((oop*)ref);
|
||||
}
|
||||
}
|
||||
|
||||
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_INLINE_HPP
|
||||
|
@ -71,6 +71,9 @@ private:
|
||||
bool _during_initial_mark;
|
||||
bool _during_conc_mark;
|
||||
uint _worker_id;
|
||||
HeapWord* _end_of_last_gap;
|
||||
HeapWord* _last_gap_threshold;
|
||||
HeapWord* _last_obj_threshold;
|
||||
|
||||
public:
|
||||
RemoveSelfForwardPtrObjClosure(G1CollectedHeap* g1, ConcurrentMark* cm,
|
||||
@ -83,7 +86,10 @@ public:
|
||||
_update_rset_cl(update_rset_cl),
|
||||
_during_initial_mark(during_initial_mark),
|
||||
_during_conc_mark(during_conc_mark),
|
||||
_worker_id(worker_id) { }
|
||||
_worker_id(worker_id),
|
||||
_end_of_last_gap(hr->bottom()),
|
||||
_last_gap_threshold(hr->bottom()),
|
||||
_last_obj_threshold(hr->bottom()) { }
|
||||
|
||||
size_t marked_bytes() { return _marked_bytes; }
|
||||
|
||||
@ -107,7 +113,12 @@ public:
|
||||
HeapWord* obj_addr = (HeapWord*) obj;
|
||||
assert(_hr->is_in(obj_addr), "sanity");
|
||||
size_t obj_size = obj->size();
|
||||
_hr->update_bot_for_object(obj_addr, obj_size);
|
||||
HeapWord* obj_end = obj_addr + obj_size;
|
||||
|
||||
if (_end_of_last_gap != obj_addr) {
|
||||
// there was a gap before obj_addr
|
||||
_last_gap_threshold = _hr->cross_threshold(_end_of_last_gap, obj_addr);
|
||||
}
|
||||
|
||||
if (obj->is_forwarded() && obj->forwardee() == obj) {
|
||||
// The object failed to move.
|
||||
@ -115,7 +126,9 @@ public:
|
||||
// We consider all objects that we find self-forwarded to be
|
||||
// live. What we'll do is that we'll update the prev marking
|
||||
// info so that they are all under PTAMS and explicitly marked.
|
||||
_cm->markPrev(obj);
|
||||
if (!_cm->isPrevMarked(obj)) {
|
||||
_cm->markPrev(obj);
|
||||
}
|
||||
if (_during_initial_mark) {
|
||||
// For the next marking info we'll only mark the
|
||||
// self-forwarded objects explicitly if we are during
|
||||
@ -145,13 +158,18 @@ public:
|
||||
// remembered set entries missing given that we skipped cards on
|
||||
// the collection set. So, we'll recreate such entries now.
|
||||
obj->oop_iterate(_update_rset_cl);
|
||||
assert(_cm->isPrevMarked(obj), "Should be marked!");
|
||||
} else {
|
||||
|
||||
// The object has been either evacuated or is dead. Fill it with a
|
||||
// dummy object.
|
||||
MemRegion mr((HeapWord*) obj, obj_size);
|
||||
MemRegion mr(obj_addr, obj_size);
|
||||
CollectedHeap::fill_with_object(mr);
|
||||
|
||||
// must nuke all dead objects which we skipped when iterating over the region
|
||||
_cm->clearRangePrevBitmap(MemRegion(_end_of_last_gap, obj_end));
|
||||
}
|
||||
_end_of_last_gap = obj_end;
|
||||
_last_obj_threshold = _hr->cross_threshold(obj_addr, obj_end);
|
||||
}
|
||||
};
|
||||
|
||||
@ -182,13 +200,6 @@ public:
|
||||
during_conc_mark,
|
||||
_worker_id);
|
||||
|
||||
MemRegion mr(hr->bottom(), hr->end());
|
||||
// We'll recreate the prev marking info so we'll first clear
|
||||
// the prev bitmap range for this region. We never mark any
|
||||
// CSet objects explicitly so the next bitmap range should be
|
||||
// cleared anyway.
|
||||
_cm->clearRangePrevBitmap(mr);
|
||||
|
||||
hr->note_self_forwarding_removal_start(during_initial_mark,
|
||||
during_conc_mark);
|
||||
_g1h->check_bitmaps("Self-Forwarding Ptr Removal", hr);
|
||||
|
@ -167,7 +167,6 @@ G1GCPhaseTimes::G1GCPhaseTimes(uint max_gc_threads) :
|
||||
_last_update_rs_processed_buffers(_max_gc_threads, "%d"),
|
||||
_last_scan_rs_times_ms(_max_gc_threads, "%.1lf"),
|
||||
_last_strong_code_root_scan_times_ms(_max_gc_threads, "%.1lf"),
|
||||
_last_strong_code_root_mark_times_ms(_max_gc_threads, "%.1lf"),
|
||||
_last_obj_copy_times_ms(_max_gc_threads, "%.1lf"),
|
||||
_last_termination_times_ms(_max_gc_threads, "%.1lf"),
|
||||
_last_termination_attempts(_max_gc_threads, SIZE_FORMAT),
|
||||
@ -194,7 +193,6 @@ void G1GCPhaseTimes::note_gc_start(uint active_gc_threads) {
|
||||
_last_update_rs_processed_buffers.reset();
|
||||
_last_scan_rs_times_ms.reset();
|
||||
_last_strong_code_root_scan_times_ms.reset();
|
||||
_last_strong_code_root_mark_times_ms.reset();
|
||||
_last_obj_copy_times_ms.reset();
|
||||
_last_termination_times_ms.reset();
|
||||
_last_termination_attempts.reset();
|
||||
@ -215,7 +213,6 @@ void G1GCPhaseTimes::note_gc_end() {
|
||||
_last_update_rs_processed_buffers.verify();
|
||||
_last_scan_rs_times_ms.verify();
|
||||
_last_strong_code_root_scan_times_ms.verify();
|
||||
_last_strong_code_root_mark_times_ms.verify();
|
||||
_last_obj_copy_times_ms.verify();
|
||||
_last_termination_times_ms.verify();
|
||||
_last_termination_attempts.verify();
|
||||
@ -230,7 +227,6 @@ void G1GCPhaseTimes::note_gc_end() {
|
||||
_last_update_rs_times_ms.get(i) +
|
||||
_last_scan_rs_times_ms.get(i) +
|
||||
_last_strong_code_root_scan_times_ms.get(i) +
|
||||
_last_strong_code_root_mark_times_ms.get(i) +
|
||||
_last_obj_copy_times_ms.get(i) +
|
||||
_last_termination_times_ms.get(i);
|
||||
|
||||
@ -302,9 +298,6 @@ void G1GCPhaseTimes::print(double pause_time_sec) {
|
||||
if (_last_satb_filtering_times_ms.sum() > 0.0) {
|
||||
_last_satb_filtering_times_ms.print(2, "SATB Filtering (ms)");
|
||||
}
|
||||
if (_last_strong_code_root_mark_times_ms.sum() > 0.0) {
|
||||
_last_strong_code_root_mark_times_ms.print(2, "Code Root Marking (ms)");
|
||||
}
|
||||
_last_update_rs_times_ms.print(2, "Update RS (ms)");
|
||||
_last_update_rs_processed_buffers.print(3, "Processed Buffers");
|
||||
_last_scan_rs_times_ms.print(2, "Scan RS (ms)");
|
||||
@ -322,9 +315,6 @@ void G1GCPhaseTimes::print(double pause_time_sec) {
|
||||
if (_last_satb_filtering_times_ms.sum() > 0.0) {
|
||||
_last_satb_filtering_times_ms.print(1, "SATB Filtering (ms)");
|
||||
}
|
||||
if (_last_strong_code_root_mark_times_ms.sum() > 0.0) {
|
||||
_last_strong_code_root_mark_times_ms.print(1, "Code Root Marking (ms)");
|
||||
}
|
||||
_last_update_rs_times_ms.print(1, "Update RS (ms)");
|
||||
_last_update_rs_processed_buffers.print(2, "Processed Buffers");
|
||||
_last_scan_rs_times_ms.print(1, "Scan RS (ms)");
|
||||
|
@ -120,7 +120,6 @@ class G1GCPhaseTimes : public CHeapObj<mtGC> {
|
||||
WorkerDataArray<int> _last_update_rs_processed_buffers;
|
||||
WorkerDataArray<double> _last_scan_rs_times_ms;
|
||||
WorkerDataArray<double> _last_strong_code_root_scan_times_ms;
|
||||
WorkerDataArray<double> _last_strong_code_root_mark_times_ms;
|
||||
WorkerDataArray<double> _last_obj_copy_times_ms;
|
||||
WorkerDataArray<double> _last_termination_times_ms;
|
||||
WorkerDataArray<size_t> _last_termination_attempts;
|
||||
@ -199,10 +198,6 @@ class G1GCPhaseTimes : public CHeapObj<mtGC> {
|
||||
_last_strong_code_root_scan_times_ms.set(worker_i, ms);
|
||||
}
|
||||
|
||||
void record_strong_code_root_mark_time(uint worker_i, double ms) {
|
||||
_last_strong_code_root_mark_times_ms.set(worker_i, ms);
|
||||
}
|
||||
|
||||
void record_obj_copy_time(uint worker_i, double ms) {
|
||||
_last_obj_copy_times_ms.set(worker_i, ms);
|
||||
}
|
||||
@ -369,10 +364,6 @@ class G1GCPhaseTimes : public CHeapObj<mtGC> {
|
||||
return _last_strong_code_root_scan_times_ms.average();
|
||||
}
|
||||
|
||||
double average_last_strong_code_root_mark_time(){
|
||||
return _last_strong_code_root_mark_times_ms.average();
|
||||
}
|
||||
|
||||
double average_last_obj_copy_time() {
|
||||
return _last_obj_copy_times_ms.average();
|
||||
}
|
||||
|
@ -129,13 +129,15 @@ void G1MarkSweep::mark_sweep_phase1(bool& marked_for_unloading,
|
||||
|
||||
SharedHeap* sh = SharedHeap::heap();
|
||||
|
||||
// Need cleared claim bits for the strong roots processing
|
||||
// Need cleared claim bits for the roots processing
|
||||
ClassLoaderDataGraph::clear_claimed_marks();
|
||||
|
||||
sh->process_strong_roots(true, // activate StrongRootsScope
|
||||
SharedHeap::SO_SystemClasses,
|
||||
MarkingCodeBlobClosure follow_code_closure(&GenMarkSweep::follow_root_closure, !CodeBlobToOopClosure::FixRelocations);
|
||||
sh->process_strong_roots(true, // activate StrongRootsScope
|
||||
SharedHeap::SO_None,
|
||||
&GenMarkSweep::follow_root_closure,
|
||||
&GenMarkSweep::follow_klass_closure);
|
||||
&GenMarkSweep::follow_cld_closure,
|
||||
&follow_code_closure);
|
||||
|
||||
// Process reference objects found during marking
|
||||
ReferenceProcessor* rp = GenMarkSweep::ref_processor();
|
||||
@ -304,13 +306,15 @@ void G1MarkSweep::mark_sweep_phase3() {
|
||||
|
||||
SharedHeap* sh = SharedHeap::heap();
|
||||
|
||||
// Need cleared claim bits for the strong roots processing
|
||||
// Need cleared claim bits for the roots processing
|
||||
ClassLoaderDataGraph::clear_claimed_marks();
|
||||
|
||||
sh->process_strong_roots(true, // activate StrongRootsScope
|
||||
SharedHeap::SO_AllClasses | SharedHeap::SO_Strings | SharedHeap::SO_AllCodeCache,
|
||||
&GenMarkSweep::adjust_pointer_closure,
|
||||
&GenMarkSweep::adjust_klass_closure);
|
||||
CodeBlobToOopClosure adjust_code_closure(&GenMarkSweep::adjust_pointer_closure, CodeBlobToOopClosure::FixRelocations);
|
||||
sh->process_all_roots(true, // activate StrongRootsScope
|
||||
SharedHeap::SO_AllCodeCache,
|
||||
&GenMarkSweep::adjust_pointer_closure,
|
||||
&GenMarkSweep::adjust_cld_closure,
|
||||
&adjust_code_closure);
|
||||
|
||||
assert(GenMarkSweep::ref_processor() == g1h->ref_processor_stw(), "Sanity");
|
||||
g1h->ref_processor_stw()->weak_oops_do(&GenMarkSweep::adjust_pointer_closure);
|
||||
|
@ -25,7 +25,28 @@
|
||||
#include "precompiled.hpp"
|
||||
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
|
||||
#include "gc_implementation/g1/g1OopClosures.inline.hpp"
|
||||
#include "gc_implementation/g1/g1ParScanThreadState.hpp"
|
||||
|
||||
G1ParCopyHelper::G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
|
||||
G1ParClosureSuper(g1, par_scan_state), _scanned_klass(NULL),
|
||||
_cm(_g1->concurrent_mark()) {}
|
||||
|
||||
G1ParClosureSuper::G1ParClosureSuper(G1CollectedHeap* g1) :
|
||||
_g1(g1), _par_scan_state(NULL), _worker_id(UINT_MAX) { }
|
||||
|
||||
G1ParClosureSuper::G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) :
|
||||
_g1(g1), _par_scan_state(NULL),
|
||||
_worker_id(UINT_MAX) {
|
||||
set_par_scan_thread_state(par_scan_state);
|
||||
}
|
||||
|
||||
void G1ParClosureSuper::set_par_scan_thread_state(G1ParScanThreadState* par_scan_state) {
|
||||
assert(_par_scan_state == NULL, "_par_scan_state must only be set once");
|
||||
assert(par_scan_state != NULL, "Must set par_scan_state to non-NULL.");
|
||||
|
||||
_par_scan_state = par_scan_state;
|
||||
_worker_id = par_scan_state->queue_num();
|
||||
|
||||
assert(_worker_id < MAX2((uint)ParallelGCThreads, 1u),
|
||||
err_msg("The given worker id %u must be less than the number of threads %u", _worker_id, MAX2((uint)ParallelGCThreads, 1u)));
|
||||
}
|
||||
|
@ -25,6 +25,8 @@
|
||||
#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP
|
||||
#define SHARE_VM_GC_IMPLEMENTATION_G1_G1OOPCLOSURES_HPP
|
||||
|
||||
#include "memory/iterator.hpp"
|
||||
|
||||
class HeapRegion;
|
||||
class G1CollectedHeap;
|
||||
class G1RemSet;
|
||||
@ -51,8 +53,13 @@ protected:
|
||||
G1ParScanThreadState* _par_scan_state;
|
||||
uint _worker_id;
|
||||
public:
|
||||
// Initializes the instance, leaving _par_scan_state uninitialized. Must be done
|
||||
// later using the set_par_scan_thread_state() method.
|
||||
G1ParClosureSuper(G1CollectedHeap* g1);
|
||||
G1ParClosureSuper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state);
|
||||
bool apply_to_weak_ref_discovered_field() { return true; }
|
||||
|
||||
void set_par_scan_thread_state(G1ParScanThreadState* par_scan_state);
|
||||
};
|
||||
|
||||
class G1ParPushHeapRSClosure : public G1ParClosureSuper {
|
||||
@ -68,9 +75,8 @@ public:
|
||||
|
||||
class G1ParScanClosure : public G1ParClosureSuper {
|
||||
public:
|
||||
G1ParScanClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, ReferenceProcessor* rp) :
|
||||
G1ParClosureSuper(g1, par_scan_state)
|
||||
{
|
||||
G1ParScanClosure(G1CollectedHeap* g1, ReferenceProcessor* rp) :
|
||||
G1ParClosureSuper(g1) {
|
||||
assert(_ref_processor == NULL, "sanity");
|
||||
_ref_processor = rp;
|
||||
}
|
||||
@ -102,7 +108,7 @@ protected:
|
||||
template <class T> void do_klass_barrier(T* p, oop new_obj);
|
||||
};
|
||||
|
||||
template <G1Barrier barrier, bool do_mark_object>
|
||||
template <G1Barrier barrier, G1Mark do_mark_object>
|
||||
class G1ParCopyClosure : public G1ParCopyHelper {
|
||||
private:
|
||||
template <class T> void do_oop_work(T* p);
|
||||
@ -117,19 +123,19 @@ public:
|
||||
template <class T> void do_oop_nv(T* p) { do_oop_work(p); }
|
||||
virtual void do_oop(oop* p) { do_oop_nv(p); }
|
||||
virtual void do_oop(narrowOop* p) { do_oop_nv(p); }
|
||||
|
||||
G1CollectedHeap* g1() { return _g1; };
|
||||
G1ParScanThreadState* pss() { return _par_scan_state; }
|
||||
ReferenceProcessor* rp() { return _ref_processor; };
|
||||
};
|
||||
|
||||
typedef G1ParCopyClosure<G1BarrierNone, false> G1ParScanExtRootClosure;
|
||||
typedef G1ParCopyClosure<G1BarrierKlass, false> G1ParScanMetadataClosure;
|
||||
|
||||
|
||||
typedef G1ParCopyClosure<G1BarrierNone, true> G1ParScanAndMarkExtRootClosure;
|
||||
typedef G1ParCopyClosure<G1BarrierKlass, true> G1ParScanAndMarkMetadataClosure;
|
||||
|
||||
typedef G1ParCopyClosure<G1BarrierNone, G1MarkNone> G1ParScanExtRootClosure;
|
||||
typedef G1ParCopyClosure<G1BarrierNone, G1MarkFromRoot> G1ParScanAndMarkExtRootClosure;
|
||||
typedef G1ParCopyClosure<G1BarrierNone, G1MarkPromotedFromRoot> G1ParScanAndMarkWeakExtRootClosure;
|
||||
// We use a separate closure to handle references during evacuation
|
||||
// failure processing.
|
||||
|
||||
typedef G1ParCopyClosure<G1BarrierEvac, false> G1ParScanHeapEvacFailureClosure;
|
||||
typedef G1ParCopyClosure<G1BarrierEvac, G1MarkNone> G1ParScanHeapEvacFailureClosure;
|
||||
|
||||
class FilterIntoCSClosure: public ExtendedOopClosure {
|
||||
G1CollectedHeap* _g1;
|
||||
@ -160,10 +166,11 @@ public:
|
||||
};
|
||||
|
||||
// Closure for iterating over object fields during concurrent marking
|
||||
class G1CMOopClosure : public ExtendedOopClosure {
|
||||
class G1CMOopClosure : public MetadataAwareOopClosure {
|
||||
protected:
|
||||
ConcurrentMark* _cm;
|
||||
private:
|
||||
G1CollectedHeap* _g1h;
|
||||
ConcurrentMark* _cm;
|
||||
CMTask* _task;
|
||||
public:
|
||||
G1CMOopClosure(G1CollectedHeap* g1h, ConcurrentMark* cm, CMTask* task);
|
||||
@ -173,7 +180,7 @@ public:
|
||||
};
|
||||
|
||||
// Closure to scan the root regions during concurrent marking
|
||||
class G1RootRegionScanClosure : public ExtendedOopClosure {
|
||||
class G1RootRegionScanClosure : public MetadataAwareOopClosure {
|
||||
private:
|
||||
G1CollectedHeap* _g1h;
|
||||
ConcurrentMark* _cm;
|
||||
|
@ -28,9 +28,11 @@
|
||||
#include "gc_implementation/g1/concurrentMark.inline.hpp"
|
||||
#include "gc_implementation/g1/g1CollectedHeap.hpp"
|
||||
#include "gc_implementation/g1/g1OopClosures.hpp"
|
||||
#include "gc_implementation/g1/g1ParScanThreadState.inline.hpp"
|
||||
#include "gc_implementation/g1/g1RemSet.hpp"
|
||||
#include "gc_implementation/g1/g1RemSet.inline.hpp"
|
||||
#include "gc_implementation/g1/heapRegionRemSet.hpp"
|
||||
#include "memory/iterator.inline.hpp"
|
||||
#include "runtime/prefetch.inline.hpp"
|
||||
|
||||
/*
|
||||
@ -107,10 +109,6 @@ inline void G1ParPushHeapRSClosure::do_oop_nv(T* p) {
|
||||
|
||||
template <class T>
|
||||
inline void G1CMOopClosure::do_oop_nv(T* p) {
|
||||
assert(_g1h->is_in_g1_reserved((HeapWord*) p), "invariant");
|
||||
assert(!_g1h->is_on_master_free_list(
|
||||
_g1h->heap_region_containing((HeapWord*) p)), "invariant");
|
||||
|
||||
oop obj = oopDesc::load_decode_heap_oop(p);
|
||||
if (_cm->verbose_high()) {
|
||||
gclog_or_tty->print_cr("[%u] we're looking at location "
|
||||
|
@ -0,0 +1,306 @@
|
||||
/*
|
||||
* Copyright (c) 2014, 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "precompiled.hpp"
|
||||
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
|
||||
#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)
|
||||
: _g1h(g1h),
|
||||
_refs(g1h->task_queue(queue_num)),
|
||||
_dcq(&g1h->dirty_card_queue_set()),
|
||||
_ct_bs(g1h->g1_barrier_set()),
|
||||
_g1_rem(g1h->g1_rem_set()),
|
||||
_hash_seed(17), _queue_num(queue_num),
|
||||
_term_attempts(0),
|
||||
_surviving_alloc_buffer(g1h->desired_plab_sz(GCAllocForSurvived)),
|
||||
_tenured_alloc_buffer(g1h->desired_plab_sz(GCAllocForTenured)),
|
||||
_age_table(false), _scanner(g1h, rp),
|
||||
_strong_roots_time(0), _term_time(0),
|
||||
_alloc_buffer_waste(0), _undo_waste(0) {
|
||||
_scanner.set_par_scan_thread_state(this);
|
||||
// we allocate G1YoungSurvRateNumRegions plus one entries, since
|
||||
// we "sacrifice" entry 0 to keep track of surviving bytes for
|
||||
// non-young regions (where the age is -1)
|
||||
// We also add a few elements at the beginning and at the end in
|
||||
// an attempt to eliminate cache contention
|
||||
uint real_length = 1 + _g1h->g1_policy()->young_cset_region_length();
|
||||
uint array_length = PADDING_ELEM_NUM +
|
||||
real_length +
|
||||
PADDING_ELEM_NUM;
|
||||
_surviving_young_words_base = NEW_C_HEAP_ARRAY(size_t, array_length, mtGC);
|
||||
if (_surviving_young_words_base == NULL)
|
||||
vm_exit_out_of_memory(array_length * sizeof(size_t), OOM_MALLOC_ERROR,
|
||||
"Not enough space for young surv histo.");
|
||||
_surviving_young_words = _surviving_young_words_base + PADDING_ELEM_NUM;
|
||||
memset(_surviving_young_words, 0, (size_t) real_length * sizeof(size_t));
|
||||
|
||||
_alloc_buffers[GCAllocForSurvived] = &_surviving_alloc_buffer;
|
||||
_alloc_buffers[GCAllocForTenured] = &_tenured_alloc_buffer;
|
||||
|
||||
_start = os::elapsedTime();
|
||||
}
|
||||
|
||||
G1ParScanThreadState::~G1ParScanThreadState() {
|
||||
retire_alloc_buffers();
|
||||
FREE_C_HEAP_ARRAY(size_t, _surviving_young_words_base, mtGC);
|
||||
}
|
||||
|
||||
void
|
||||
G1ParScanThreadState::print_termination_stats_hdr(outputStream* const st)
|
||||
{
|
||||
st->print_raw_cr("GC Termination Stats");
|
||||
st->print_raw_cr(" elapsed --strong roots-- -------termination-------"
|
||||
" ------waste (KiB)------");
|
||||
st->print_raw_cr("thr ms ms % ms % attempts"
|
||||
" total alloc undo");
|
||||
st->print_raw_cr("--- --------- --------- ------ --------- ------ --------"
|
||||
" ------- ------- -------");
|
||||
}
|
||||
|
||||
void
|
||||
G1ParScanThreadState::print_termination_stats(int i,
|
||||
outputStream* const st) const
|
||||
{
|
||||
const double elapsed_ms = elapsed_time() * 1000.0;
|
||||
const double s_roots_ms = strong_roots_time() * 1000.0;
|
||||
const double term_ms = term_time() * 1000.0;
|
||||
st->print_cr("%3d %9.2f %9.2f %6.2f "
|
||||
"%9.2f %6.2f " SIZE_FORMAT_W(8) " "
|
||||
SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7),
|
||||
i, elapsed_ms, s_roots_ms, s_roots_ms * 100 / elapsed_ms,
|
||||
term_ms, term_ms * 100 / elapsed_ms, term_attempts(),
|
||||
(alloc_buffer_waste() + undo_waste()) * HeapWordSize / K,
|
||||
alloc_buffer_waste() * HeapWordSize / K,
|
||||
undo_waste() * HeapWordSize / K);
|
||||
}
|
||||
|
||||
#ifdef ASSERT
|
||||
bool G1ParScanThreadState::verify_ref(narrowOop* ref) const {
|
||||
assert(ref != NULL, "invariant");
|
||||
assert(UseCompressedOops, "sanity");
|
||||
assert(!has_partial_array_mask(ref), err_msg("ref=" PTR_FORMAT, p2i(ref)));
|
||||
oop p = oopDesc::load_decode_heap_oop(ref);
|
||||
assert(_g1h->is_in_g1_reserved(p),
|
||||
err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, p2i(ref), p2i(p)));
|
||||
return true;
|
||||
}
|
||||
|
||||
bool G1ParScanThreadState::verify_ref(oop* ref) const {
|
||||
assert(ref != NULL, "invariant");
|
||||
if (has_partial_array_mask(ref)) {
|
||||
// Must be in the collection set--it's already been copied.
|
||||
oop p = clear_partial_array_mask(ref);
|
||||
assert(_g1h->obj_in_cs(p),
|
||||
err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, p2i(ref), p2i(p)));
|
||||
} else {
|
||||
oop p = oopDesc::load_decode_heap_oop(ref);
|
||||
assert(_g1h->is_in_g1_reserved(p),
|
||||
err_msg("ref=" PTR_FORMAT " p=" PTR_FORMAT, p2i(ref), p2i(p)));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool G1ParScanThreadState::verify_task(StarTask ref) const {
|
||||
if (ref.is_narrow()) {
|
||||
return verify_ref((narrowOop*) ref);
|
||||
} else {
|
||||
return verify_ref((oop*) ref);
|
||||
}
|
||||
}
|
||||
#endif // ASSERT
|
||||
|
||||
void G1ParScanThreadState::trim_queue() {
|
||||
assert(_evac_failure_cl != NULL, "not set");
|
||||
|
||||
StarTask ref;
|
||||
do {
|
||||
// Drain the overflow stack first, so other threads can steal.
|
||||
while (_refs->pop_overflow(ref)) {
|
||||
dispatch_reference(ref);
|
||||
}
|
||||
|
||||
while (_refs->pop_local(ref)) {
|
||||
dispatch_reference(ref);
|
||||
}
|
||||
} while (!_refs->is_empty());
|
||||
}
|
||||
|
||||
oop G1ParScanThreadState::copy_to_survivor_space(oop const old) {
|
||||
size_t word_sz = old->size();
|
||||
HeapRegion* from_region = _g1h->heap_region_containing_raw(old);
|
||||
// +1 to make the -1 indexes valid...
|
||||
int young_index = from_region->young_index_in_cset()+1;
|
||||
assert( (from_region->is_young() && young_index > 0) ||
|
||||
(!from_region->is_young() && young_index == 0), "invariant" );
|
||||
G1CollectorPolicy* g1p = _g1h->g1_policy();
|
||||
markOop m = old->mark();
|
||||
int age = m->has_displaced_mark_helper() ? m->displaced_mark_helper()->age()
|
||||
: m->age();
|
||||
GCAllocPurpose alloc_purpose = g1p->evacuation_destination(from_region, age,
|
||||
word_sz);
|
||||
HeapWord* obj_ptr = allocate(alloc_purpose, word_sz);
|
||||
#ifndef PRODUCT
|
||||
// Should this evacuation fail?
|
||||
if (_g1h->evacuation_should_fail()) {
|
||||
if (obj_ptr != NULL) {
|
||||
undo_allocation(alloc_purpose, obj_ptr, word_sz);
|
||||
obj_ptr = NULL;
|
||||
}
|
||||
}
|
||||
#endif // !PRODUCT
|
||||
|
||||
if (obj_ptr == NULL) {
|
||||
// This will either forward-to-self, or detect that someone else has
|
||||
// installed a forwarding pointer.
|
||||
return _g1h->handle_evacuation_failure_par(this, old);
|
||||
}
|
||||
|
||||
oop obj = oop(obj_ptr);
|
||||
|
||||
// We're going to allocate linearly, so might as well prefetch ahead.
|
||||
Prefetch::write(obj_ptr, PrefetchCopyIntervalInBytes);
|
||||
|
||||
oop forward_ptr = old->forward_to_atomic(obj);
|
||||
if (forward_ptr == NULL) {
|
||||
Copy::aligned_disjoint_words((HeapWord*) old, obj_ptr, word_sz);
|
||||
|
||||
// alloc_purpose is just a hint to allocate() above, recheck the type of region
|
||||
// we actually allocated from and update alloc_purpose accordingly
|
||||
HeapRegion* to_region = _g1h->heap_region_containing_raw(obj_ptr);
|
||||
alloc_purpose = to_region->is_young() ? GCAllocForSurvived : GCAllocForTenured;
|
||||
|
||||
if (g1p->track_object_age(alloc_purpose)) {
|
||||
// We could simply do obj->incr_age(). However, this causes a
|
||||
// performance issue. obj->incr_age() will first check whether
|
||||
// the object has a displaced mark by checking its mark word;
|
||||
// getting the mark word from the new location of the object
|
||||
// stalls. So, given that we already have the mark word and we
|
||||
// are about to install it anyway, it's better to increase the
|
||||
// age on the mark word, when the object does not have a
|
||||
// displaced mark word. We're not expecting many objects to have
|
||||
// a displaced marked word, so that case is not optimized
|
||||
// further (it could be...) and we simply call obj->incr_age().
|
||||
|
||||
if (m->has_displaced_mark_helper()) {
|
||||
// in this case, we have to install the mark word first,
|
||||
// otherwise obj looks to be forwarded (the old mark word,
|
||||
// which contains the forward pointer, was copied)
|
||||
obj->set_mark(m);
|
||||
obj->incr_age();
|
||||
} else {
|
||||
m = m->incr_age();
|
||||
obj->set_mark(m);
|
||||
}
|
||||
age_table()->add(obj, word_sz);
|
||||
} else {
|
||||
obj->set_mark(m);
|
||||
}
|
||||
|
||||
if (G1StringDedup::is_enabled()) {
|
||||
G1StringDedup::enqueue_from_evacuation(from_region->is_young(),
|
||||
to_region->is_young(),
|
||||
queue_num(),
|
||||
obj);
|
||||
}
|
||||
|
||||
size_t* surv_young_words = surviving_young_words();
|
||||
surv_young_words[young_index] += word_sz;
|
||||
|
||||
if (obj->is_objArray() && arrayOop(obj)->length() >= ParGCArrayScanChunk) {
|
||||
// We keep track of the next start index in the length field of
|
||||
// the to-space object. The actual length can be found in the
|
||||
// length field of the from-space object.
|
||||
arrayOop(obj)->set_length(0);
|
||||
oop* old_p = set_partial_array_mask(old);
|
||||
push_on_queue(old_p);
|
||||
} else {
|
||||
// No point in using the slower heap_region_containing() method,
|
||||
// given that we know obj is in the heap.
|
||||
_scanner.set_region(_g1h->heap_region_containing_raw(obj));
|
||||
obj->oop_iterate_backwards(&_scanner);
|
||||
}
|
||||
} else {
|
||||
undo_allocation(alloc_purpose, obj_ptr, word_sz);
|
||||
obj = forward_ptr;
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
HeapWord* G1ParScanThreadState::allocate_slow(GCAllocPurpose purpose, size_t word_sz) {
|
||||
HeapWord* obj = NULL;
|
||||
size_t gclab_word_size = _g1h->desired_plab_sz(purpose);
|
||||
if (word_sz * 100 < gclab_word_size * ParallelGCBufferWastePct) {
|
||||
G1ParGCAllocBuffer* alloc_buf = alloc_buffer(purpose);
|
||||
add_to_alloc_buffer_waste(alloc_buf->words_remaining());
|
||||
alloc_buf->retire(false /* end_of_gc */, false /* retain */);
|
||||
|
||||
HeapWord* buf = _g1h->par_allocate_during_gc(purpose, gclab_word_size);
|
||||
if (buf == NULL) {
|
||||
return NULL; // Let caller handle allocation failure.
|
||||
}
|
||||
// Otherwise.
|
||||
alloc_buf->set_word_size(gclab_word_size);
|
||||
alloc_buf->set_buf(buf);
|
||||
|
||||
obj = alloc_buf->allocate(word_sz);
|
||||
assert(obj != NULL, "buffer was definitely big enough...");
|
||||
} else {
|
||||
obj = _g1h->par_allocate_during_gc(purpose, word_sz);
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
void G1ParScanThreadState::undo_allocation(GCAllocPurpose purpose, HeapWord* obj, size_t word_sz) {
|
||||
if (alloc_buffer(purpose)->contains(obj)) {
|
||||
assert(alloc_buffer(purpose)->contains(obj + word_sz - 1),
|
||||
"should contain whole object");
|
||||
alloc_buffer(purpose)->undo_allocation(obj, word_sz);
|
||||
} else {
|
||||
CollectedHeap::fill_with_object(obj, word_sz);
|
||||
add_to_undo_waste(word_sz);
|
||||
}
|
||||
}
|
||||
|
||||
HeapWord* G1ParScanThreadState::allocate(GCAllocPurpose purpose, size_t word_sz) {
|
||||
HeapWord* obj = alloc_buffer(purpose)->allocate(word_sz);
|
||||
if (obj != NULL) {
|
||||
return obj;
|
||||
}
|
||||
return allocate_slow(purpose, word_sz);
|
||||
}
|
||||
|
||||
void G1ParScanThreadState::retire_alloc_buffers() {
|
||||
for (int ap = 0; ap < GCAllocPurposeCount; ++ap) {
|
||||
size_t waste = _alloc_buffers[ap]->words_remaining();
|
||||
add_to_alloc_buffer_waste(waste);
|
||||
_alloc_buffers[ap]->flush_stats_and_retire(_g1h->stats_for_purpose((GCAllocPurpose)ap),
|
||||
true /* end_of_gc */,
|
||||
false /* retain */);
|
||||
}
|
||||
}
|
@ -0,0 +1,227 @@
|
||||
/*
|
||||
* Copyright (c) 2014, 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1PARSCANTHREADSTATE_HPP
|
||||
#define SHARE_VM_GC_IMPLEMENTATION_G1_G1PARSCANTHREADSTATE_HPP
|
||||
|
||||
#include "gc_implementation/g1/dirtyCardQueue.hpp"
|
||||
#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
|
||||
#include "gc_implementation/g1/g1CollectedHeap.hpp"
|
||||
#include "gc_implementation/g1/g1CollectorPolicy.hpp"
|
||||
#include "gc_implementation/g1/g1OopClosures.hpp"
|
||||
#include "gc_implementation/g1/g1RemSet.hpp"
|
||||
#include "gc_implementation/shared/ageTable.hpp"
|
||||
#include "memory/allocation.hpp"
|
||||
#include "oops/oop.hpp"
|
||||
|
||||
class HeapRegion;
|
||||
class outputStream;
|
||||
|
||||
class G1ParScanThreadState : public StackObj {
|
||||
private:
|
||||
G1CollectedHeap* _g1h;
|
||||
RefToScanQueue* _refs;
|
||||
DirtyCardQueue _dcq;
|
||||
G1SATBCardTableModRefBS* _ct_bs;
|
||||
G1RemSet* _g1_rem;
|
||||
|
||||
G1ParGCAllocBuffer _surviving_alloc_buffer;
|
||||
G1ParGCAllocBuffer _tenured_alloc_buffer;
|
||||
G1ParGCAllocBuffer* _alloc_buffers[GCAllocPurposeCount];
|
||||
ageTable _age_table;
|
||||
|
||||
G1ParScanClosure _scanner;
|
||||
|
||||
size_t _alloc_buffer_waste;
|
||||
size_t _undo_waste;
|
||||
|
||||
OopsInHeapRegionClosure* _evac_failure_cl;
|
||||
|
||||
int _hash_seed;
|
||||
uint _queue_num;
|
||||
|
||||
size_t _term_attempts;
|
||||
|
||||
double _start;
|
||||
double _start_strong_roots;
|
||||
double _strong_roots_time;
|
||||
double _start_term;
|
||||
double _term_time;
|
||||
|
||||
// Map from young-age-index (0 == not young, 1 is youngest) to
|
||||
// surviving words. base is what we get back from the malloc call
|
||||
size_t* _surviving_young_words_base;
|
||||
// this points into the array, as we use the first few entries for padding
|
||||
size_t* _surviving_young_words;
|
||||
|
||||
#define PADDING_ELEM_NUM (DEFAULT_CACHE_LINE_SIZE / sizeof(size_t))
|
||||
|
||||
void add_to_alloc_buffer_waste(size_t waste) { _alloc_buffer_waste += waste; }
|
||||
|
||||
void add_to_undo_waste(size_t waste) { _undo_waste += waste; }
|
||||
|
||||
DirtyCardQueue& dirty_card_queue() { return _dcq; }
|
||||
G1SATBCardTableModRefBS* ctbs() { return _ct_bs; }
|
||||
|
||||
template <class T> inline void immediate_rs_update(HeapRegion* from, T* p, int tid);
|
||||
|
||||
template <class T> void deferred_rs_update(HeapRegion* from, T* p, int tid) {
|
||||
// If the new value of the field points to the same region or
|
||||
// is the to-space, we don't need to include it in the Rset updates.
|
||||
if (!from->is_in_reserved(oopDesc::load_decode_heap_oop(p)) && !from->is_survivor()) {
|
||||
size_t card_index = ctbs()->index_for(p);
|
||||
// If the card hasn't been added to the buffer, do it.
|
||||
if (ctbs()->mark_card_deferred(card_index)) {
|
||||
dirty_card_queue().enqueue((jbyte*)ctbs()->byte_for_index(card_index));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
||||
G1ParScanThreadState(G1CollectedHeap* g1h, uint queue_num, ReferenceProcessor* rp);
|
||||
~G1ParScanThreadState();
|
||||
|
||||
ageTable* age_table() { return &_age_table; }
|
||||
|
||||
G1ParGCAllocBuffer* alloc_buffer(GCAllocPurpose purpose) {
|
||||
return _alloc_buffers[purpose];
|
||||
}
|
||||
|
||||
size_t alloc_buffer_waste() const { return _alloc_buffer_waste; }
|
||||
size_t undo_waste() const { return _undo_waste; }
|
||||
|
||||
#ifdef ASSERT
|
||||
bool queue_is_empty() const { return _refs->is_empty(); }
|
||||
|
||||
bool verify_ref(narrowOop* ref) const;
|
||||
bool verify_ref(oop* ref) const;
|
||||
bool verify_task(StarTask ref) const;
|
||||
#endif // ASSERT
|
||||
|
||||
template <class T> void push_on_queue(T* ref) {
|
||||
assert(verify_ref(ref), "sanity");
|
||||
_refs->push(ref);
|
||||
}
|
||||
|
||||
template <class T> inline void update_rs(HeapRegion* from, T* p, int tid);
|
||||
|
||||
private:
|
||||
|
||||
inline HeapWord* allocate(GCAllocPurpose purpose, size_t word_sz);
|
||||
inline HeapWord* allocate_slow(GCAllocPurpose purpose, size_t word_sz);
|
||||
inline void undo_allocation(GCAllocPurpose purpose, HeapWord* obj, size_t word_sz);
|
||||
|
||||
public:
|
||||
|
||||
void set_evac_failure_closure(OopsInHeapRegionClosure* evac_failure_cl) {
|
||||
_evac_failure_cl = evac_failure_cl;
|
||||
}
|
||||
|
||||
OopsInHeapRegionClosure* evac_failure_closure() { return _evac_failure_cl; }
|
||||
|
||||
int* hash_seed() { return &_hash_seed; }
|
||||
uint queue_num() { return _queue_num; }
|
||||
|
||||
size_t term_attempts() const { return _term_attempts; }
|
||||
void note_term_attempt() { _term_attempts++; }
|
||||
|
||||
void start_strong_roots() {
|
||||
_start_strong_roots = os::elapsedTime();
|
||||
}
|
||||
void end_strong_roots() {
|
||||
_strong_roots_time += (os::elapsedTime() - _start_strong_roots);
|
||||
}
|
||||
double strong_roots_time() const { return _strong_roots_time; }
|
||||
|
||||
void start_term_time() {
|
||||
note_term_attempt();
|
||||
_start_term = os::elapsedTime();
|
||||
}
|
||||
void end_term_time() {
|
||||
_term_time += (os::elapsedTime() - _start_term);
|
||||
}
|
||||
double term_time() const { return _term_time; }
|
||||
|
||||
double elapsed_time() const {
|
||||
return os::elapsedTime() - _start;
|
||||
}
|
||||
|
||||
static void print_termination_stats_hdr(outputStream* const st = gclog_or_tty);
|
||||
void print_termination_stats(int i, outputStream* const st = gclog_or_tty) const;
|
||||
|
||||
size_t* surviving_young_words() {
|
||||
// We add on to hide entry 0 which accumulates surviving words for
|
||||
// age -1 regions (i.e. non-young ones)
|
||||
return _surviving_young_words;
|
||||
}
|
||||
|
||||
private:
|
||||
void retire_alloc_buffers();
|
||||
|
||||
#define G1_PARTIAL_ARRAY_MASK 0x2
|
||||
|
||||
inline bool has_partial_array_mask(oop* ref) const {
|
||||
return ((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) == G1_PARTIAL_ARRAY_MASK;
|
||||
}
|
||||
|
||||
// We never encode partial array oops as narrowOop*, so return false immediately.
|
||||
// This allows the compiler to create optimized code when popping references from
|
||||
// the work queue.
|
||||
inline bool has_partial_array_mask(narrowOop* ref) const {
|
||||
assert(((uintptr_t)ref & G1_PARTIAL_ARRAY_MASK) != G1_PARTIAL_ARRAY_MASK, "Partial array oop reference encoded as narrowOop*");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Only implement set_partial_array_mask() for regular oops, not for narrowOops.
|
||||
// We always encode partial arrays as regular oop, to allow the
|
||||
// specialization for has_partial_array_mask() for narrowOops above.
|
||||
// This means that unintentional use of this method with narrowOops are caught
|
||||
// by the compiler.
|
||||
inline oop* set_partial_array_mask(oop obj) const {
|
||||
assert(((uintptr_t)(void *)obj & G1_PARTIAL_ARRAY_MASK) == 0, "Information loss!");
|
||||
return (oop*) ((uintptr_t)(void *)obj | G1_PARTIAL_ARRAY_MASK);
|
||||
}
|
||||
|
||||
inline oop clear_partial_array_mask(oop* ref) const {
|
||||
return cast_to_oop((intptr_t)ref & ~G1_PARTIAL_ARRAY_MASK);
|
||||
}
|
||||
|
||||
inline void do_oop_partial_array(oop* p);
|
||||
|
||||
// This method is applied to the fields of the objects that have just been copied.
|
||||
template <class T> inline void do_oop_evac(T* p, HeapRegion* from);
|
||||
|
||||
template <class T> inline void deal_with_reference(T* ref_to_scan);
|
||||
|
||||
inline void dispatch_reference(StarTask ref);
|
||||
public:
|
||||
|
||||
oop copy_to_survivor_space(oop const obj);
|
||||
|
||||
void trim_queue();
|
||||
|
||||
inline void steal_and_trim_queue(RefToScanQueueSet *task_queues);
|
||||
};
|
||||
|
||||
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1PARSCANTHREADSTATE_HPP
|
@ -0,0 +1,154 @@
|
||||
/*
|
||||
* Copyright (c) 2014, 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1PARSCANTHREADSTATE_INLINE_HPP
|
||||
#define SHARE_VM_GC_IMPLEMENTATION_G1_G1PARSCANTHREADSTATE_INLINE_HPP
|
||||
|
||||
#include "gc_implementation/g1/g1ParScanThreadState.hpp"
|
||||
#include "gc_implementation/g1/g1RemSet.inline.hpp"
|
||||
#include "oops/oop.inline.hpp"
|
||||
|
||||
template <class T> inline void G1ParScanThreadState::immediate_rs_update(HeapRegion* from, T* p, int tid) {
|
||||
if (!from->is_survivor()) {
|
||||
_g1_rem->par_write_ref(from, p, tid);
|
||||
}
|
||||
}
|
||||
|
||||
template <class T> void G1ParScanThreadState::update_rs(HeapRegion* from, T* p, int tid) {
|
||||
if (G1DeferredRSUpdate) {
|
||||
deferred_rs_update(from, p, tid);
|
||||
} else {
|
||||
immediate_rs_update(from, p, tid);
|
||||
}
|
||||
}
|
||||
|
||||
template <class T> void G1ParScanThreadState::do_oop_evac(T* p, HeapRegion* from) {
|
||||
assert(!oopDesc::is_null(oopDesc::load_decode_heap_oop(p)),
|
||||
"Reference should not be NULL here as such are never pushed to the task queue.");
|
||||
oop obj = oopDesc::load_decode_heap_oop_not_null(p);
|
||||
|
||||
// Although we never intentionally push references outside of the collection
|
||||
// set, due to (benign) races in the claim mechanism during RSet scanning more
|
||||
// than one thread might claim the same card. So the same card may be
|
||||
// processed multiple times. So redo this check.
|
||||
if (_g1h->in_cset_fast_test(obj)) {
|
||||
oop forwardee;
|
||||
if (obj->is_forwarded()) {
|
||||
forwardee = obj->forwardee();
|
||||
} else {
|
||||
forwardee = copy_to_survivor_space(obj);
|
||||
}
|
||||
assert(forwardee != NULL, "forwardee should not be NULL");
|
||||
oopDesc::encode_store_heap_oop(p, forwardee);
|
||||
}
|
||||
|
||||
assert(obj != NULL, "Must be");
|
||||
update_rs(from, p, queue_num());
|
||||
}
|
||||
|
||||
inline void G1ParScanThreadState::do_oop_partial_array(oop* p) {
|
||||
assert(has_partial_array_mask(p), "invariant");
|
||||
oop from_obj = clear_partial_array_mask(p);
|
||||
|
||||
assert(Universe::heap()->is_in_reserved(from_obj), "must be in heap.");
|
||||
assert(from_obj->is_objArray(), "must be obj array");
|
||||
objArrayOop from_obj_array = objArrayOop(from_obj);
|
||||
// The from-space object contains the real length.
|
||||
int length = from_obj_array->length();
|
||||
|
||||
assert(from_obj->is_forwarded(), "must be forwarded");
|
||||
oop to_obj = from_obj->forwardee();
|
||||
assert(from_obj != to_obj, "should not be chunking self-forwarded objects");
|
||||
objArrayOop to_obj_array = objArrayOop(to_obj);
|
||||
// We keep track of the next start index in the length field of the
|
||||
// to-space object.
|
||||
int next_index = to_obj_array->length();
|
||||
assert(0 <= next_index && next_index < length,
|
||||
err_msg("invariant, next index: %d, length: %d", next_index, length));
|
||||
|
||||
int start = next_index;
|
||||
int end = length;
|
||||
int remainder = end - start;
|
||||
// We'll try not to push a range that's smaller than ParGCArrayScanChunk.
|
||||
if (remainder > 2 * ParGCArrayScanChunk) {
|
||||
end = start + ParGCArrayScanChunk;
|
||||
to_obj_array->set_length(end);
|
||||
// Push the remainder before we process the range in case another
|
||||
// worker has run out of things to do and can steal it.
|
||||
oop* from_obj_p = set_partial_array_mask(from_obj);
|
||||
push_on_queue(from_obj_p);
|
||||
} else {
|
||||
assert(length == end, "sanity");
|
||||
// We'll process the final range for this object. Restore the length
|
||||
// so that the heap remains parsable in case of evacuation failure.
|
||||
to_obj_array->set_length(end);
|
||||
}
|
||||
_scanner.set_region(_g1h->heap_region_containing_raw(to_obj));
|
||||
// Process indexes [start,end). It will also process the header
|
||||
// along with the first chunk (i.e., the chunk with start == 0).
|
||||
// Note that at this point the length field of to_obj_array is not
|
||||
// correct given that we are using it to keep track of the next
|
||||
// start index. oop_iterate_range() (thankfully!) ignores the length
|
||||
// field and only relies on the start / end parameters. It does
|
||||
// however return the size of the object which will be incorrect. So
|
||||
// we have to ignore it even if we wanted to use it.
|
||||
to_obj_array->oop_iterate_range(&_scanner, start, end);
|
||||
}
|
||||
|
||||
template <class T> inline void G1ParScanThreadState::deal_with_reference(T* ref_to_scan) {
|
||||
if (!has_partial_array_mask(ref_to_scan)) {
|
||||
// Note: we can use "raw" versions of "region_containing" because
|
||||
// "obj_to_scan" is definitely in the heap, and is not in a
|
||||
// humongous region.
|
||||
HeapRegion* r = _g1h->heap_region_containing_raw(ref_to_scan);
|
||||
do_oop_evac(ref_to_scan, r);
|
||||
} else {
|
||||
do_oop_partial_array((oop*)ref_to_scan);
|
||||
}
|
||||
}
|
||||
|
||||
inline void G1ParScanThreadState::dispatch_reference(StarTask ref) {
|
||||
assert(verify_task(ref), "sanity");
|
||||
if (ref.is_narrow()) {
|
||||
deal_with_reference((narrowOop*)ref);
|
||||
} else {
|
||||
deal_with_reference((oop*)ref);
|
||||
}
|
||||
}
|
||||
|
||||
void G1ParScanThreadState::steal_and_trim_queue(RefToScanQueueSet *task_queues) {
|
||||
StarTask stolen_task;
|
||||
while (task_queues->steal(queue_num(), hash_seed(), stolen_task)) {
|
||||
assert(verify_task(stolen_task), "sanity");
|
||||
dispatch_reference(stolen_task);
|
||||
|
||||
// We've just processed a reference and we might have made
|
||||
// available new entries on the queues. So we have to make sure
|
||||
// we drain the queues as necessary.
|
||||
trim_queue();
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* SHARE_VM_GC_IMPLEMENTATION_G1_G1PARSCANTHREADSTATE_INLINE_HPP */
|
||||
|
@ -26,6 +26,7 @@
|
||||
#define SHARE_VM_GC_IMPLEMENTATION_G1_G1REMSET_INLINE_HPP
|
||||
|
||||
#include "gc_implementation/g1/g1RemSet.hpp"
|
||||
#include "gc_implementation/g1/heapRegion.hpp"
|
||||
#include "gc_implementation/g1/heapRegionRemSet.hpp"
|
||||
#include "oops/oop.inline.hpp"
|
||||
|
||||
|
@ -66,6 +66,17 @@ G1SATBCardTableModRefBS::write_ref_array_pre_work(T* dst, int count) {
|
||||
}
|
||||
}
|
||||
|
||||
void G1SATBCardTableModRefBS::write_ref_array_pre(oop* dst, int count, bool dest_uninitialized) {
|
||||
if (!dest_uninitialized) {
|
||||
write_ref_array_pre_work(dst, count);
|
||||
}
|
||||
}
|
||||
void G1SATBCardTableModRefBS::write_ref_array_pre(narrowOop* dst, int count, bool dest_uninitialized) {
|
||||
if (!dest_uninitialized) {
|
||||
write_ref_array_pre_work(dst, count);
|
||||
}
|
||||
}
|
||||
|
||||
bool G1SATBCardTableModRefBS::mark_card_deferred(size_t card_index) {
|
||||
jbyte val = _byte_map[card_index];
|
||||
// It's already processed
|
||||
|
@ -86,16 +86,8 @@ public:
|
||||
}
|
||||
|
||||
template <class T> void write_ref_array_pre_work(T* dst, int count);
|
||||
virtual void write_ref_array_pre(oop* dst, int count, bool dest_uninitialized) {
|
||||
if (!dest_uninitialized) {
|
||||
write_ref_array_pre_work(dst, count);
|
||||
}
|
||||
}
|
||||
virtual void write_ref_array_pre(narrowOop* dst, int count, bool dest_uninitialized) {
|
||||
if (!dest_uninitialized) {
|
||||
write_ref_array_pre_work(dst, count);
|
||||
}
|
||||
}
|
||||
virtual void write_ref_array_pre(oop* dst, int count, bool dest_uninitialized);
|
||||
virtual void write_ref_array_pre(narrowOop* dst, int count, bool dest_uninitialized);
|
||||
|
||||
/*
|
||||
Claimed and deferred bits are used together in G1 during the evacuation
|
||||
|
@ -30,14 +30,21 @@
|
||||
// non-virtually, using a mechanism defined in this file. Extend these
|
||||
// macros in the obvious way to add specializations for new closures.
|
||||
|
||||
// Forward declarations.
|
||||
enum G1Barrier {
|
||||
G1BarrierNone,
|
||||
G1BarrierEvac,
|
||||
G1BarrierKlass
|
||||
};
|
||||
|
||||
template<G1Barrier barrier, bool do_mark_object>
|
||||
enum G1Mark {
|
||||
G1MarkNone,
|
||||
G1MarkFromRoot,
|
||||
G1MarkPromotedFromRoot
|
||||
};
|
||||
|
||||
// Forward declarations.
|
||||
|
||||
template<G1Barrier barrier, G1Mark do_mark_object>
|
||||
class G1ParCopyClosure;
|
||||
|
||||
class G1ParScanClosure;
|
||||
|
@ -30,6 +30,7 @@
|
||||
#include "gc_implementation/g1/heapRegion.inline.hpp"
|
||||
#include "gc_implementation/g1/heapRegionRemSet.hpp"
|
||||
#include "gc_implementation/g1/heapRegionSeq.inline.hpp"
|
||||
#include "gc_implementation/shared/liveRange.hpp"
|
||||
#include "memory/genOopClosures.inline.hpp"
|
||||
#include "memory/iterator.hpp"
|
||||
#include "memory/space.inline.hpp"
|
||||
@ -61,7 +62,7 @@ HeapWord* walk_mem_region_loop(ClosureType* cl, G1CollectedHeap* g1h,
|
||||
HeapRegion* hr,
|
||||
HeapWord* cur, HeapWord* top) {
|
||||
oop cur_oop = oop(cur);
|
||||
int oop_size = cur_oop->size();
|
||||
size_t oop_size = hr->block_size(cur);
|
||||
HeapWord* next_obj = cur + oop_size;
|
||||
while (next_obj < top) {
|
||||
// Keep filtering the remembered set.
|
||||
@ -72,7 +73,7 @@ HeapWord* walk_mem_region_loop(ClosureType* cl, G1CollectedHeap* g1h,
|
||||
}
|
||||
cur = next_obj;
|
||||
cur_oop = oop(cur);
|
||||
oop_size = cur_oop->size();
|
||||
oop_size = hr->block_size(cur);
|
||||
next_obj = cur + oop_size;
|
||||
}
|
||||
return cur;
|
||||
@ -82,7 +83,7 @@ void HeapRegionDCTOC::walk_mem_region(MemRegion mr,
|
||||
HeapWord* bottom,
|
||||
HeapWord* top) {
|
||||
G1CollectedHeap* g1h = _g1;
|
||||
int oop_size;
|
||||
size_t oop_size;
|
||||
ExtendedOopClosure* cl2 = NULL;
|
||||
|
||||
FilterIntoCSClosure intoCSFilt(this, g1h, _cl);
|
||||
@ -102,7 +103,7 @@ void HeapRegionDCTOC::walk_mem_region(MemRegion mr,
|
||||
if (!g1h->is_obj_dead(oop(bottom), _hr)) {
|
||||
oop_size = oop(bottom)->oop_iterate(cl2, mr);
|
||||
} else {
|
||||
oop_size = oop(bottom)->size();
|
||||
oop_size = _hr->block_size(bottom);
|
||||
}
|
||||
|
||||
bottom += oop_size;
|
||||
@ -374,7 +375,7 @@ HeapRegion::HeapRegion(uint hrs_index,
|
||||
// region.
|
||||
hr_clear(false /*par*/, false /*clear_space*/);
|
||||
set_top(bottom());
|
||||
set_saved_mark();
|
||||
record_top_and_timestamp();
|
||||
|
||||
assert(HeapRegionRemSet::num_par_rem_sets() > 0, "Invariant.");
|
||||
}
|
||||
@ -394,38 +395,11 @@ CompactibleSpace* HeapRegion::next_compaction_space() const {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void HeapRegion::save_marks() {
|
||||
set_saved_mark();
|
||||
}
|
||||
|
||||
void HeapRegion::oops_in_mr_iterate(MemRegion mr, ExtendedOopClosure* cl) {
|
||||
HeapWord* p = mr.start();
|
||||
HeapWord* e = mr.end();
|
||||
oop obj;
|
||||
while (p < e) {
|
||||
obj = oop(p);
|
||||
p += obj->oop_iterate(cl);
|
||||
}
|
||||
assert(p == e, "bad memregion: doesn't end on obj boundary");
|
||||
}
|
||||
|
||||
#define HeapRegion_OOP_SINCE_SAVE_MARKS_DEFN(OopClosureType, nv_suffix) \
|
||||
void HeapRegion::oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl) { \
|
||||
ContiguousSpace::oop_since_save_marks_iterate##nv_suffix(cl); \
|
||||
}
|
||||
SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(HeapRegion_OOP_SINCE_SAVE_MARKS_DEFN)
|
||||
|
||||
|
||||
void HeapRegion::oop_before_save_marks_iterate(ExtendedOopClosure* cl) {
|
||||
oops_in_mr_iterate(MemRegion(bottom(), saved_mark_word()), cl);
|
||||
}
|
||||
|
||||
void HeapRegion::note_self_forwarding_removal_start(bool during_initial_mark,
|
||||
bool during_conc_mark) {
|
||||
// We always recreate the prev marking info and we'll explicitly
|
||||
// mark all objects we find to be self-forwarded on the prev
|
||||
// bitmap. So all objects need to be below PTAMS.
|
||||
_prev_top_at_mark_start = top();
|
||||
_prev_marked_bytes = 0;
|
||||
|
||||
if (during_initial_mark) {
|
||||
@ -449,6 +423,7 @@ void HeapRegion::note_self_forwarding_removal_end(bool during_initial_mark,
|
||||
assert(0 <= marked_bytes && marked_bytes <= used(),
|
||||
err_msg("marked: "SIZE_FORMAT" used: "SIZE_FORMAT,
|
||||
marked_bytes, used()));
|
||||
_prev_top_at_mark_start = top();
|
||||
_prev_marked_bytes = marked_bytes;
|
||||
}
|
||||
|
||||
@ -476,7 +451,7 @@ HeapRegion::object_iterate_mem_careful(MemRegion mr,
|
||||
} else if (!g1h->is_obj_dead(obj)) {
|
||||
cl->do_object(obj);
|
||||
}
|
||||
cur += obj->size();
|
||||
cur += block_size(cur);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
@ -548,7 +523,7 @@ oops_on_card_seq_iterate_careful(MemRegion mr,
|
||||
return cur;
|
||||
}
|
||||
// Otherwise...
|
||||
next = (cur + obj->size());
|
||||
next = cur + block_size(cur);
|
||||
}
|
||||
|
||||
// If we finish the above loop...We have a parseable object that
|
||||
@ -556,10 +531,9 @@ oops_on_card_seq_iterate_careful(MemRegion mr,
|
||||
// inside or spans the entire region.
|
||||
|
||||
assert(obj == oop(cur), "sanity");
|
||||
assert(cur <= start &&
|
||||
obj->klass_or_null() != NULL &&
|
||||
(cur + obj->size()) > start,
|
||||
"Loop postcondition");
|
||||
assert(cur <= start, "Loop postcondition");
|
||||
assert(obj->klass_or_null() != NULL, "Loop postcondition");
|
||||
assert((cur + block_size(cur)) > start, "Loop postcondition");
|
||||
|
||||
if (!g1h->is_obj_dead(obj)) {
|
||||
obj->oop_iterate(cl, mr);
|
||||
@ -573,7 +547,7 @@ oops_on_card_seq_iterate_careful(MemRegion mr,
|
||||
};
|
||||
|
||||
// Otherwise:
|
||||
next = (cur + obj->size());
|
||||
next = cur + block_size(cur);
|
||||
|
||||
if (!g1h->is_obj_dead(obj)) {
|
||||
if (next < end || !obj->is_objArray()) {
|
||||
@ -928,10 +902,11 @@ void HeapRegion::verify(VerifyOption vo,
|
||||
size_t object_num = 0;
|
||||
while (p < top()) {
|
||||
oop obj = oop(p);
|
||||
size_t obj_size = obj->size();
|
||||
size_t obj_size = block_size(p);
|
||||
object_num += 1;
|
||||
|
||||
if (is_humongous != g1->isHumongous(obj_size)) {
|
||||
if (is_humongous != g1->isHumongous(obj_size) &&
|
||||
!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->isHumongous(obj_size) ? "" : "non-",
|
||||
@ -942,7 +917,9 @@ void HeapRegion::verify(VerifyOption vo,
|
||||
|
||||
// If it returns false, verify_for_object() will output the
|
||||
// appropriate messasge.
|
||||
if (do_bot_verify && !_offsets.verify_for_object(p, obj_size)) {
|
||||
if (do_bot_verify &&
|
||||
!g1->is_obj_dead(obj, this) &&
|
||||
!_offsets.verify_for_object(p, obj_size)) {
|
||||
*failures = true;
|
||||
return;
|
||||
}
|
||||
@ -950,7 +927,10 @@ void HeapRegion::verify(VerifyOption vo,
|
||||
if (!g1->is_obj_dead_cond(obj, this, vo)) {
|
||||
if (obj->is_oop()) {
|
||||
Klass* klass = obj->klass();
|
||||
if (!klass->is_metaspace_object()) {
|
||||
bool is_metaspace_object = Metaspace::contains(klass) ||
|
||||
(vo == VerifyOption_G1UsePrevMarking &&
|
||||
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);
|
||||
*failures = true;
|
||||
@ -1064,7 +1044,9 @@ void HeapRegion::verify() const {
|
||||
// away eventually.
|
||||
|
||||
void G1OffsetTableContigSpace::clear(bool mangle_space) {
|
||||
ContiguousSpace::clear(mangle_space);
|
||||
set_top(bottom());
|
||||
set_saved_mark_word(bottom());
|
||||
CompactibleSpace::clear(mangle_space);
|
||||
_offsets.zero_bottom_entry();
|
||||
_offsets.initialize_threshold();
|
||||
}
|
||||
@ -1102,10 +1084,10 @@ HeapWord* G1OffsetTableContigSpace::saved_mark_word() const {
|
||||
if (_gc_time_stamp < g1h->get_gc_time_stamp())
|
||||
return top();
|
||||
else
|
||||
return ContiguousSpace::saved_mark_word();
|
||||
return Space::saved_mark_word();
|
||||
}
|
||||
|
||||
void G1OffsetTableContigSpace::set_saved_mark() {
|
||||
void G1OffsetTableContigSpace::record_top_and_timestamp() {
|
||||
G1CollectedHeap* g1h = G1CollectedHeap::heap();
|
||||
unsigned curr_gc_time_stamp = g1h->get_gc_time_stamp();
|
||||
|
||||
@ -1117,7 +1099,7 @@ void G1OffsetTableContigSpace::set_saved_mark() {
|
||||
// of region. If it does so after _gc_time_stamp = ..., then it
|
||||
// will pick up the right saved_mark_word() as the high water mark
|
||||
// of the region. Either way, the behavior will be correct.
|
||||
ContiguousSpace::set_saved_mark();
|
||||
Space::set_saved_mark_word(top());
|
||||
OrderAccess::storestore();
|
||||
_gc_time_stamp = curr_gc_time_stamp;
|
||||
// No need to do another barrier to flush the writes above. If
|
||||
@ -1128,6 +1110,26 @@ void G1OffsetTableContigSpace::set_saved_mark() {
|
||||
}
|
||||
}
|
||||
|
||||
void G1OffsetTableContigSpace::safe_object_iterate(ObjectClosure* blk) {
|
||||
object_iterate(blk);
|
||||
}
|
||||
|
||||
void G1OffsetTableContigSpace::object_iterate(ObjectClosure* blk) {
|
||||
HeapWord* p = bottom();
|
||||
while (p < top()) {
|
||||
if (block_is_obj(p)) {
|
||||
blk->do_object(oop(p));
|
||||
}
|
||||
p += block_size(p);
|
||||
}
|
||||
}
|
||||
|
||||
#define block_is_always_obj(q) true
|
||||
void G1OffsetTableContigSpace::prepare_for_compaction(CompactPoint* cp) {
|
||||
SCAN_AND_FORWARD(cp, top, block_is_always_obj, block_size);
|
||||
}
|
||||
#undef block_is_always_obj
|
||||
|
||||
G1OffsetTableContigSpace::
|
||||
G1OffsetTableContigSpace(G1BlockOffsetSharedArray* sharedOffsetArray,
|
||||
MemRegion mr) :
|
||||
@ -1137,7 +1139,8 @@ G1OffsetTableContigSpace(G1BlockOffsetSharedArray* sharedOffsetArray,
|
||||
{
|
||||
_offsets.set_space(this);
|
||||
// false ==> we'll do the clearing if there's clearing to be done.
|
||||
ContiguousSpace::initialize(mr, false, SpaceDecorator::Mangle);
|
||||
CompactibleSpace::initialize(mr, false, SpaceDecorator::Mangle);
|
||||
_top = bottom();
|
||||
_offsets.zero_bottom_entry();
|
||||
_offsets.initialize_threshold();
|
||||
}
|
||||
|
@ -46,8 +46,6 @@
|
||||
// The solution is to remove this method from the definition
|
||||
// of a Space.
|
||||
|
||||
class CompactibleSpace;
|
||||
class ContiguousSpace;
|
||||
class HeapRegionRemSet;
|
||||
class HeapRegionRemSetIterator;
|
||||
class HeapRegion;
|
||||
@ -125,9 +123,9 @@ public:
|
||||
// the regions anyway) and at the end of a Full GC. The current scheme
|
||||
// that uses sequential unsigned ints will fail only if we have 4b
|
||||
// evacuation pauses between two cleanups, which is _highly_ unlikely.
|
||||
|
||||
class G1OffsetTableContigSpace: public ContiguousSpace {
|
||||
class G1OffsetTableContigSpace: public CompactibleSpace {
|
||||
friend class VMStructs;
|
||||
HeapWord* _top;
|
||||
protected:
|
||||
G1BlockOffsetArrayContigSpace _offsets;
|
||||
Mutex _par_alloc_lock;
|
||||
@ -144,11 +142,32 @@ class G1OffsetTableContigSpace: public ContiguousSpace {
|
||||
G1OffsetTableContigSpace(G1BlockOffsetSharedArray* sharedOffsetArray,
|
||||
MemRegion mr);
|
||||
|
||||
void set_top(HeapWord* value) { _top = value; }
|
||||
HeapWord* top() const { return _top; }
|
||||
|
||||
protected:
|
||||
HeapWord** top_addr() { return &_top; }
|
||||
// Allocation helpers (return NULL if full).
|
||||
inline HeapWord* allocate_impl(size_t word_size, HeapWord* end_value);
|
||||
inline HeapWord* par_allocate_impl(size_t word_size, HeapWord* end_value);
|
||||
|
||||
public:
|
||||
void reset_after_compaction() { set_top(compaction_top()); }
|
||||
|
||||
size_t used() const { return byte_size(bottom(), top()); }
|
||||
size_t free() const { return byte_size(top(), end()); }
|
||||
bool is_free_block(const HeapWord* p) const { return p >= top(); }
|
||||
|
||||
MemRegion used_region() const { return MemRegion(bottom(), top()); }
|
||||
|
||||
void object_iterate(ObjectClosure* blk);
|
||||
void safe_object_iterate(ObjectClosure* blk);
|
||||
|
||||
void set_bottom(HeapWord* value);
|
||||
void set_end(HeapWord* value);
|
||||
|
||||
virtual HeapWord* saved_mark_word() const;
|
||||
virtual void set_saved_mark();
|
||||
void record_top_and_timestamp();
|
||||
void reset_gc_time_stamp() { _gc_time_stamp = 0; }
|
||||
unsigned get_gc_time_stamp() { return _gc_time_stamp; }
|
||||
|
||||
@ -168,6 +187,8 @@ class G1OffsetTableContigSpace: public ContiguousSpace {
|
||||
HeapWord* block_start(const void* p);
|
||||
HeapWord* block_start_const(const void* p) const;
|
||||
|
||||
void prepare_for_compaction(CompactPoint* cp);
|
||||
|
||||
// Add offset table update.
|
||||
virtual HeapWord* allocate(size_t word_size);
|
||||
HeapWord* par_allocate(size_t word_size);
|
||||
@ -202,10 +223,6 @@ class HeapRegion: public G1OffsetTableContigSpace {
|
||||
ContinuesHumongous
|
||||
};
|
||||
|
||||
// Requires that the region "mr" be dense with objects, and begin and end
|
||||
// with an object.
|
||||
void oops_in_mr_iterate(MemRegion mr, ExtendedOopClosure* cl);
|
||||
|
||||
// The remembered set for this region.
|
||||
// (Might want to make this "inline" later, to avoid some alloc failure
|
||||
// issues.)
|
||||
@ -230,11 +247,9 @@ class HeapRegion: public G1OffsetTableContigSpace {
|
||||
bool _evacuation_failed;
|
||||
|
||||
// A heap region may be a member one of a number of special subsets, each
|
||||
// represented as linked lists through the field below. Currently, these
|
||||
// sets include:
|
||||
// represented as linked lists through the field below. Currently, there
|
||||
// is only one set:
|
||||
// The collection set.
|
||||
// The set of allocation regions used in a collection pause.
|
||||
// Spaces that may contain gray objects.
|
||||
HeapRegion* _next_in_special_set;
|
||||
|
||||
// next region in the young "generation" region set
|
||||
@ -353,14 +368,15 @@ class HeapRegion: public G1OffsetTableContigSpace {
|
||||
ParMarkRootClaimValue = 9
|
||||
};
|
||||
|
||||
inline HeapWord* par_allocate_no_bot_updates(size_t word_size) {
|
||||
assert(is_young(), "we can only skip BOT updates on young regions");
|
||||
return ContiguousSpace::par_allocate(word_size);
|
||||
}
|
||||
inline HeapWord* allocate_no_bot_updates(size_t word_size) {
|
||||
assert(is_young(), "we can only skip BOT updates on young regions");
|
||||
return ContiguousSpace::allocate(word_size);
|
||||
}
|
||||
// All allocated blocks are occupied by objects in a HeapRegion
|
||||
bool block_is_obj(const HeapWord* p) const;
|
||||
|
||||
// Returns the object size for all valid block starts
|
||||
// and the amount of unallocated words if called on top()
|
||||
size_t block_size(const HeapWord* p) const;
|
||||
|
||||
inline HeapWord* par_allocate_no_bot_updates(size_t word_size);
|
||||
inline HeapWord* allocate_no_bot_updates(size_t word_size);
|
||||
|
||||
// If this region is a member of a HeapRegionSeq, the index in that
|
||||
// sequence, otherwise -1.
|
||||
@ -569,9 +585,6 @@ class HeapRegion: public G1OffsetTableContigSpace {
|
||||
|
||||
HeapWord* orig_end() { return _orig_end; }
|
||||
|
||||
// Allows logical separation between objects allocated before and after.
|
||||
void save_marks();
|
||||
|
||||
// Reset HR stuff to default values.
|
||||
void hr_clear(bool par, bool clear_space, bool locked = false);
|
||||
void par_clear();
|
||||
@ -580,10 +593,6 @@ class HeapRegion: public G1OffsetTableContigSpace {
|
||||
HeapWord* prev_top_at_mark_start() const { return _prev_top_at_mark_start; }
|
||||
HeapWord* next_top_at_mark_start() const { return _next_top_at_mark_start; }
|
||||
|
||||
// Apply "cl->do_oop" to (the addresses of) all reference fields in objects
|
||||
// allocated in the current region before the last call to "save_mark".
|
||||
void oop_before_save_marks_iterate(ExtendedOopClosure* cl);
|
||||
|
||||
// Note the start or end of marking. This tells the heap region
|
||||
// that the collector is about to start or has finished (concurrently)
|
||||
// marking the heap.
|
||||
@ -769,10 +778,6 @@ class HeapRegion: public G1OffsetTableContigSpace {
|
||||
_predicted_bytes_to_copy = bytes;
|
||||
}
|
||||
|
||||
#define HeapRegion_OOP_SINCE_SAVE_MARKS_DECL(OopClosureType, nv_suffix) \
|
||||
virtual void oop_since_save_marks_iterate##nv_suffix(OopClosureType* cl);
|
||||
SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(HeapRegion_OOP_SINCE_SAVE_MARKS_DECL)
|
||||
|
||||
virtual CompactibleSpace* next_compaction_space() const;
|
||||
|
||||
virtual void reset_after_compaction();
|
||||
|
@ -26,9 +26,48 @@
|
||||
#define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGION_INLINE_HPP
|
||||
|
||||
#include "gc_implementation/g1/g1BlockOffsetTable.inline.hpp"
|
||||
#include "gc_implementation/g1/g1CollectedHeap.hpp"
|
||||
#include "gc_implementation/g1/heapRegion.hpp"
|
||||
#include "memory/space.hpp"
|
||||
#include "runtime/atomic.inline.hpp"
|
||||
|
||||
// This version requires locking.
|
||||
inline HeapWord* G1OffsetTableContigSpace::allocate_impl(size_t size,
|
||||
HeapWord* const end_value) {
|
||||
HeapWord* obj = top();
|
||||
if (pointer_delta(end_value, obj) >= size) {
|
||||
HeapWord* new_top = obj + size;
|
||||
set_top(new_top);
|
||||
assert(is_aligned(obj) && is_aligned(new_top), "checking alignment");
|
||||
return obj;
|
||||
} else {
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
// This version is lock-free.
|
||||
inline HeapWord* G1OffsetTableContigSpace::par_allocate_impl(size_t size,
|
||||
HeapWord* const end_value) {
|
||||
do {
|
||||
HeapWord* obj = top();
|
||||
if (pointer_delta(end_value, obj) >= size) {
|
||||
HeapWord* new_top = obj + size;
|
||||
HeapWord* result = (HeapWord*)Atomic::cmpxchg_ptr(new_top, top_addr(), obj);
|
||||
// result can be one of two:
|
||||
// the old top value: the exchange succeeded
|
||||
// otherwise: the new value of the top is returned.
|
||||
if (result == obj) {
|
||||
assert(is_aligned(obj) && is_aligned(new_top), "checking alignment");
|
||||
return obj;
|
||||
}
|
||||
} else {
|
||||
return NULL;
|
||||
}
|
||||
} while (true);
|
||||
}
|
||||
|
||||
inline HeapWord* G1OffsetTableContigSpace::allocate(size_t size) {
|
||||
HeapWord* res = ContiguousSpace::allocate(size);
|
||||
HeapWord* res = allocate_impl(size, end());
|
||||
if (res != NULL) {
|
||||
_offsets.alloc_block(res, size);
|
||||
}
|
||||
@ -40,12 +79,7 @@ inline HeapWord* G1OffsetTableContigSpace::allocate(size_t size) {
|
||||
// this is used for larger LAB allocations only.
|
||||
inline HeapWord* G1OffsetTableContigSpace::par_allocate(size_t size) {
|
||||
MutexLocker x(&_par_alloc_lock);
|
||||
// Given that we take the lock no need to use par_allocate() here.
|
||||
HeapWord* res = ContiguousSpace::allocate(size);
|
||||
if (res != NULL) {
|
||||
_offsets.alloc_block(res, size);
|
||||
}
|
||||
return res;
|
||||
return allocate(size);
|
||||
}
|
||||
|
||||
inline HeapWord* G1OffsetTableContigSpace::block_start(const void* p) {
|
||||
@ -57,6 +91,41 @@ G1OffsetTableContigSpace::block_start_const(const void* p) const {
|
||||
return _offsets.block_start_const(p);
|
||||
}
|
||||
|
||||
inline bool
|
||||
HeapRegion::block_is_obj(const HeapWord* p) const {
|
||||
G1CollectedHeap* g1h = G1CollectedHeap::heap();
|
||||
return !g1h->is_obj_dead(oop(p), this);
|
||||
}
|
||||
|
||||
inline size_t
|
||||
HeapRegion::block_size(const HeapWord *addr) const {
|
||||
// Old regions' dead objects may have dead classes
|
||||
// We need to find the next live object in some other
|
||||
// manner than getting the oop size
|
||||
G1CollectedHeap* g1h = G1CollectedHeap::heap();
|
||||
if (g1h->is_obj_dead(oop(addr), this)) {
|
||||
HeapWord* next = g1h->concurrent_mark()->prevMarkBitMap()->
|
||||
getNextMarkedWordAddress(addr, prev_top_at_mark_start());
|
||||
|
||||
assert(next > addr, "must get the next live object");
|
||||
|
||||
return pointer_delta(next, addr);
|
||||
} else if (addr == top()) {
|
||||
return pointer_delta(end(), addr);
|
||||
}
|
||||
return oop(addr)->size();
|
||||
}
|
||||
|
||||
inline HeapWord* HeapRegion::par_allocate_no_bot_updates(size_t word_size) {
|
||||
assert(is_young(), "we can only skip BOT updates on young regions");
|
||||
return par_allocate_impl(word_size, end());
|
||||
}
|
||||
|
||||
inline HeapWord* HeapRegion::allocate_no_bot_updates(size_t word_size) {
|
||||
assert(is_young(), "we can only skip BOT updates on young regions");
|
||||
return allocate_impl(word_size, end());
|
||||
}
|
||||
|
||||
inline void HeapRegion::note_start_of_marking() {
|
||||
_next_marked_bytes = 0;
|
||||
_next_top_at_mark_start = top();
|
||||
|
@ -931,7 +931,10 @@ void HeapRegionRemSet::add_strong_code_root(nmethod* nm) {
|
||||
|
||||
void HeapRegionRemSet::remove_strong_code_root(nmethod* nm) {
|
||||
assert(nm != NULL, "sanity");
|
||||
_code_roots.remove(nm);
|
||||
assert_locked_or_safepoint(CodeCache_lock);
|
||||
|
||||
_code_roots.remove_lock_free(nm);
|
||||
|
||||
// Check that there were no duplicates
|
||||
guarantee(!_code_roots.contains(nm), "duplicate entry found");
|
||||
}
|
||||
|
@ -285,37 +285,6 @@ void SATBMarkQueueSet::set_par_closure(int i, ObjectClosure* par_closure) {
|
||||
_par_closures[i] = par_closure;
|
||||
}
|
||||
|
||||
void SATBMarkQueueSet::iterate_closure_all_threads() {
|
||||
for(JavaThread* t = Threads::first(); t; t = t->next()) {
|
||||
t->satb_mark_queue().apply_closure_and_empty(_closure);
|
||||
}
|
||||
shared_satb_queue()->apply_closure_and_empty(_closure);
|
||||
}
|
||||
|
||||
void SATBMarkQueueSet::par_iterate_closure_all_threads(uint worker) {
|
||||
SharedHeap* sh = SharedHeap::heap();
|
||||
int parity = sh->strong_roots_parity();
|
||||
|
||||
for(JavaThread* t = Threads::first(); t; t = t->next()) {
|
||||
if (t->claim_oops_do(true, parity)) {
|
||||
t->satb_mark_queue().apply_closure_and_empty(_par_closures[worker]);
|
||||
}
|
||||
}
|
||||
|
||||
// We also need to claim the VMThread so that its parity is updated
|
||||
// otherwise the next call to Thread::possibly_parallel_oops_do inside
|
||||
// a StrongRootsScope might skip the VMThread because it has a stale
|
||||
// parity that matches the parity set by the StrongRootsScope
|
||||
//
|
||||
// Whichever worker succeeds in claiming the VMThread gets to do
|
||||
// the shared queue.
|
||||
|
||||
VMThread* vmt = VMThread::vm_thread();
|
||||
if (vmt->claim_oops_do(true, parity)) {
|
||||
shared_satb_queue()->apply_closure_and_empty(_par_closures[worker]);
|
||||
}
|
||||
}
|
||||
|
||||
bool SATBMarkQueueSet::apply_closure_to_completed_buffer_work(bool par,
|
||||
uint worker) {
|
||||
BufferNode* nd = NULL;
|
||||
|
@ -33,7 +33,9 @@ class SATBMarkQueueSet;
|
||||
|
||||
// A ptrQueue whose elements are "oops", pointers to object heads.
|
||||
class ObjPtrQueue: public PtrQueue {
|
||||
friend class Threads;
|
||||
friend class SATBMarkQueueSet;
|
||||
friend class G1RemarkThreadsClosure;
|
||||
|
||||
private:
|
||||
// Filter out unwanted entries from the buffer.
|
||||
@ -119,13 +121,6 @@ public:
|
||||
// closures, one for each parallel GC thread.
|
||||
void set_par_closure(int i, ObjectClosure* closure);
|
||||
|
||||
// Apply the registered closure to all entries on each
|
||||
// currently-active buffer and then empty the buffer. It should only
|
||||
// be called serially and at a safepoint.
|
||||
void iterate_closure_all_threads();
|
||||
// Parallel version of the above.
|
||||
void par_iterate_closure_all_threads(uint worker);
|
||||
|
||||
// If there exists some completed buffer, pop it, then apply the
|
||||
// registered closure to all its elements, and return true. If no
|
||||
// completed buffers exist, return false.
|
||||
|
@ -34,6 +34,8 @@
|
||||
static_field(HeapRegion, GrainBytes, size_t) \
|
||||
static_field(HeapRegion, LogOfHRGrainBytes, int) \
|
||||
\
|
||||
nonstatic_field(G1OffsetTableContigSpace, _top, HeapWord*) \
|
||||
\
|
||||
nonstatic_field(G1HeapRegionTable, _base, address) \
|
||||
nonstatic_field(G1HeapRegionTable, _length, size_t) \
|
||||
nonstatic_field(G1HeapRegionTable, _biased_base, address) \
|
||||
@ -69,7 +71,8 @@
|
||||
\
|
||||
declare_type(G1CollectedHeap, SharedHeap) \
|
||||
\
|
||||
declare_type(HeapRegion, ContiguousSpace) \
|
||||
declare_type(G1OffsetTableContigSpace, CompactibleSpace) \
|
||||
declare_type(HeapRegion, G1OffsetTableContigSpace) \
|
||||
declare_toplevel_type(HeapRegionSeq) \
|
||||
declare_toplevel_type(HeapRegionSetBase) \
|
||||
declare_toplevel_type(HeapRegionSetCount) \
|
||||
|
@ -1,657 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, 2014, 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#include "precompiled.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
|
||||
#include "gc_implementation/parNew/asParNewGeneration.hpp"
|
||||
#include "gc_implementation/parNew/parNewGeneration.hpp"
|
||||
#include "gc_implementation/shared/markSweep.inline.hpp"
|
||||
#include "gc_implementation/shared/spaceDecorator.hpp"
|
||||
#include "memory/defNewGeneration.inline.hpp"
|
||||
#include "memory/referencePolicy.hpp"
|
||||
#include "oops/markOop.inline.hpp"
|
||||
#include "oops/oop.pcgc.inline.hpp"
|
||||
|
||||
ASParNewGeneration::ASParNewGeneration(ReservedSpace rs,
|
||||
size_t initial_byte_size,
|
||||
size_t min_byte_size,
|
||||
int level) :
|
||||
ParNewGeneration(rs, initial_byte_size, level),
|
||||
_min_gen_size(min_byte_size) {}
|
||||
|
||||
const char* ASParNewGeneration::name() const {
|
||||
return "adaptive size par new generation";
|
||||
}
|
||||
|
||||
void ASParNewGeneration::adjust_desired_tenuring_threshold() {
|
||||
assert(UseAdaptiveSizePolicy,
|
||||
"Should only be used with UseAdaptiveSizePolicy");
|
||||
}
|
||||
|
||||
void ASParNewGeneration::resize(size_t eden_size, size_t survivor_size) {
|
||||
// Resize the generation if needed. If the generation resize
|
||||
// reports false, do not attempt to resize the spaces.
|
||||
if (resize_generation(eden_size, survivor_size)) {
|
||||
// Then we lay out the spaces inside the generation
|
||||
resize_spaces(eden_size, survivor_size);
|
||||
|
||||
space_invariants();
|
||||
|
||||
if (PrintAdaptiveSizePolicy && Verbose) {
|
||||
gclog_or_tty->print_cr("Young generation size: "
|
||||
"desired eden: " SIZE_FORMAT " survivor: " SIZE_FORMAT
|
||||
" used: " SIZE_FORMAT " capacity: " SIZE_FORMAT
|
||||
" gen limits: " SIZE_FORMAT " / " SIZE_FORMAT,
|
||||
eden_size, survivor_size, used(), capacity(),
|
||||
max_gen_size(), min_gen_size());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
size_t ASParNewGeneration::available_to_min_gen() {
|
||||
assert(virtual_space()->committed_size() >= min_gen_size(), "Invariant");
|
||||
return virtual_space()->committed_size() - min_gen_size();
|
||||
}
|
||||
|
||||
// This method assumes that from-space has live data and that
|
||||
// any shrinkage of the young gen is limited by location of
|
||||
// from-space.
|
||||
size_t ASParNewGeneration::available_to_live() const {
|
||||
#undef SHRINKS_AT_END_OF_EDEN
|
||||
#ifdef SHRINKS_AT_END_OF_EDEN
|
||||
size_t delta_in_survivor = 0;
|
||||
ParallelScavengeHeap* heap = (ParallelScavengeHeap*)Universe::heap();
|
||||
const size_t space_alignment = heap->intra_heap_alignment();
|
||||
const size_t gen_alignment = heap->object_heap_alignment();
|
||||
|
||||
MutableSpace* space_shrinking = NULL;
|
||||
if (from_space()->end() > to_space()->end()) {
|
||||
space_shrinking = from_space();
|
||||
} else {
|
||||
space_shrinking = to_space();
|
||||
}
|
||||
|
||||
// Include any space that is committed but not included in
|
||||
// the survivor spaces.
|
||||
assert(((HeapWord*)virtual_space()->high()) >= space_shrinking->end(),
|
||||
"Survivor space beyond high end");
|
||||
size_t unused_committed = pointer_delta(virtual_space()->high(),
|
||||
space_shrinking->end(), sizeof(char));
|
||||
|
||||
if (space_shrinking->is_empty()) {
|
||||
// Don't let the space shrink to 0
|
||||
assert(space_shrinking->capacity_in_bytes() >= space_alignment,
|
||||
"Space is too small");
|
||||
delta_in_survivor = space_shrinking->capacity_in_bytes() - space_alignment;
|
||||
} else {
|
||||
delta_in_survivor = pointer_delta(space_shrinking->end(),
|
||||
space_shrinking->top(),
|
||||
sizeof(char));
|
||||
}
|
||||
|
||||
size_t delta_in_bytes = unused_committed + delta_in_survivor;
|
||||
delta_in_bytes = align_size_down(delta_in_bytes, gen_alignment);
|
||||
return delta_in_bytes;
|
||||
#else
|
||||
// The only space available for shrinking is in to-space if it
|
||||
// is above from-space.
|
||||
if (to()->bottom() > from()->bottom()) {
|
||||
const size_t alignment = os::vm_page_size();
|
||||
if (to()->capacity() < alignment) {
|
||||
return 0;
|
||||
} else {
|
||||
return to()->capacity() - alignment;
|
||||
}
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
// Return the number of bytes available for resizing down the young
|
||||
// generation. This is the minimum of
|
||||
// input "bytes"
|
||||
// bytes to the minimum young gen size
|
||||
// bytes to the size currently being used + some small extra
|
||||
size_t ASParNewGeneration::limit_gen_shrink (size_t bytes) {
|
||||
// Allow shrinkage into the current eden but keep eden large enough
|
||||
// to maintain the minimum young gen size
|
||||
bytes = MIN3(bytes, available_to_min_gen(), available_to_live());
|
||||
return align_size_down(bytes, os::vm_page_size());
|
||||
}
|
||||
|
||||
// Note that the the alignment used is the OS page size as
|
||||
// opposed to an alignment associated with the virtual space
|
||||
// (as is done in the ASPSYoungGen/ASPSOldGen)
|
||||
bool ASParNewGeneration::resize_generation(size_t eden_size,
|
||||
size_t survivor_size) {
|
||||
const size_t alignment = os::vm_page_size();
|
||||
size_t orig_size = virtual_space()->committed_size();
|
||||
bool size_changed = false;
|
||||
|
||||
// There used to be this guarantee there.
|
||||
// guarantee ((eden_size + 2*survivor_size) <= _max_gen_size, "incorrect input arguments");
|
||||
// Code below forces this requirement. In addition the desired eden
|
||||
// size and desired survivor sizes are desired goals and may
|
||||
// exceed the total generation size.
|
||||
|
||||
assert(min_gen_size() <= orig_size && orig_size <= max_gen_size(),
|
||||
"just checking");
|
||||
|
||||
// Adjust new generation size
|
||||
const size_t eden_plus_survivors =
|
||||
align_size_up(eden_size + 2 * survivor_size, alignment);
|
||||
size_t desired_size = MAX2(MIN2(eden_plus_survivors, max_gen_size()),
|
||||
min_gen_size());
|
||||
assert(desired_size <= max_gen_size(), "just checking");
|
||||
|
||||
if (desired_size > orig_size) {
|
||||
// Grow the generation
|
||||
size_t change = desired_size - orig_size;
|
||||
assert(change % alignment == 0, "just checking");
|
||||
if (expand(change)) {
|
||||
return false; // Error if we fail to resize!
|
||||
}
|
||||
size_changed = true;
|
||||
} else if (desired_size < orig_size) {
|
||||
size_t desired_change = orig_size - desired_size;
|
||||
assert(desired_change % alignment == 0, "just checking");
|
||||
|
||||
desired_change = limit_gen_shrink(desired_change);
|
||||
|
||||
if (desired_change > 0) {
|
||||
virtual_space()->shrink_by(desired_change);
|
||||
reset_survivors_after_shrink();
|
||||
|
||||
size_changed = true;
|
||||
}
|
||||
} else {
|
||||
if (Verbose && PrintGC) {
|
||||
if (orig_size == max_gen_size()) {
|
||||
gclog_or_tty->print_cr("ASParNew generation size at maximum: "
|
||||
SIZE_FORMAT "K", orig_size/K);
|
||||
} else if (orig_size == min_gen_size()) {
|
||||
gclog_or_tty->print_cr("ASParNew generation size at minium: "
|
||||
SIZE_FORMAT "K", orig_size/K);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (size_changed) {
|
||||
MemRegion cmr((HeapWord*)virtual_space()->low(),
|
||||
(HeapWord*)virtual_space()->high());
|
||||
GenCollectedHeap::heap()->barrier_set()->resize_covered_region(cmr);
|
||||
|
||||
if (Verbose && PrintGC) {
|
||||
size_t current_size = virtual_space()->committed_size();
|
||||
gclog_or_tty->print_cr("ASParNew generation size changed: "
|
||||
SIZE_FORMAT "K->" SIZE_FORMAT "K",
|
||||
orig_size/K, current_size/K);
|
||||
}
|
||||
}
|
||||
|
||||
guarantee(eden_plus_survivors <= virtual_space()->committed_size() ||
|
||||
virtual_space()->committed_size() == max_gen_size(), "Sanity");
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void ASParNewGeneration::reset_survivors_after_shrink() {
|
||||
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
HeapWord* new_end = (HeapWord*)virtual_space()->high();
|
||||
|
||||
if (from()->end() > to()->end()) {
|
||||
assert(new_end >= from()->end(), "Shrinking past from-space");
|
||||
} else {
|
||||
assert(new_end >= to()->bottom(), "Shrink was too large");
|
||||
// Was there a shrink of the survivor space?
|
||||
if (new_end < to()->end()) {
|
||||
MemRegion mr(to()->bottom(), new_end);
|
||||
to()->initialize(mr,
|
||||
SpaceDecorator::DontClear,
|
||||
SpaceDecorator::DontMangle);
|
||||
}
|
||||
}
|
||||
}
|
||||
void ASParNewGeneration::resize_spaces(size_t requested_eden_size,
|
||||
size_t requested_survivor_size) {
|
||||
assert(UseAdaptiveSizePolicy, "sanity check");
|
||||
assert(requested_eden_size > 0 && requested_survivor_size > 0,
|
||||
"just checking");
|
||||
CollectedHeap* heap = Universe::heap();
|
||||
assert(heap->kind() == CollectedHeap::GenCollectedHeap, "Sanity");
|
||||
|
||||
|
||||
// We require eden and to space to be empty
|
||||
if ((!eden()->is_empty()) || (!to()->is_empty())) {
|
||||
return;
|
||||
}
|
||||
|
||||
size_t cur_eden_size = eden()->capacity();
|
||||
|
||||
if (PrintAdaptiveSizePolicy && Verbose) {
|
||||
gclog_or_tty->print_cr("ASParNew::resize_spaces(requested_eden_size: "
|
||||
SIZE_FORMAT
|
||||
", requested_survivor_size: " SIZE_FORMAT ")",
|
||||
requested_eden_size, requested_survivor_size);
|
||||
gclog_or_tty->print_cr(" eden: [" PTR_FORMAT ".." PTR_FORMAT ") "
|
||||
SIZE_FORMAT,
|
||||
p2i(eden()->bottom()),
|
||||
p2i(eden()->end()),
|
||||
pointer_delta(eden()->end(),
|
||||
eden()->bottom(),
|
||||
sizeof(char)));
|
||||
gclog_or_tty->print_cr(" from: [" PTR_FORMAT ".." PTR_FORMAT ") "
|
||||
SIZE_FORMAT,
|
||||
p2i(from()->bottom()),
|
||||
p2i(from()->end()),
|
||||
pointer_delta(from()->end(),
|
||||
from()->bottom(),
|
||||
sizeof(char)));
|
||||
gclog_or_tty->print_cr(" to: [" PTR_FORMAT ".." PTR_FORMAT ") "
|
||||
SIZE_FORMAT,
|
||||
p2i(to()->bottom()),
|
||||
p2i(to()->end()),
|
||||
pointer_delta( to()->end(),
|
||||
to()->bottom(),
|
||||
sizeof(char)));
|
||||
}
|
||||
|
||||
// There's nothing to do if the new sizes are the same as the current
|
||||
if (requested_survivor_size == to()->capacity() &&
|
||||
requested_survivor_size == from()->capacity() &&
|
||||
requested_eden_size == eden()->capacity()) {
|
||||
if (PrintAdaptiveSizePolicy && Verbose) {
|
||||
gclog_or_tty->print_cr(" capacities are the right sizes, returning");
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
char* eden_start = (char*)eden()->bottom();
|
||||
char* eden_end = (char*)eden()->end();
|
||||
char* from_start = (char*)from()->bottom();
|
||||
char* from_end = (char*)from()->end();
|
||||
char* to_start = (char*)to()->bottom();
|
||||
char* to_end = (char*)to()->end();
|
||||
|
||||
const size_t alignment = os::vm_page_size();
|
||||
const bool maintain_minimum =
|
||||
(requested_eden_size + 2 * requested_survivor_size) <= min_gen_size();
|
||||
|
||||
// Check whether from space is below to space
|
||||
if (from_start < to_start) {
|
||||
// Eden, from, to
|
||||
if (PrintAdaptiveSizePolicy && Verbose) {
|
||||
gclog_or_tty->print_cr(" Eden, from, to:");
|
||||
}
|
||||
|
||||
// Set eden
|
||||
// "requested_eden_size" is a goal for the size of eden
|
||||
// and may not be attainable. "eden_size" below is
|
||||
// calculated based on the location of from-space and
|
||||
// the goal for the size of eden. from-space is
|
||||
// fixed in place because it contains live data.
|
||||
// The calculation is done this way to avoid 32bit
|
||||
// overflow (i.e., eden_start + requested_eden_size
|
||||
// may too large for representation in 32bits).
|
||||
size_t eden_size;
|
||||
if (maintain_minimum) {
|
||||
// Only make eden larger than the requested size if
|
||||
// the minimum size of the generation has to be maintained.
|
||||
// This could be done in general but policy at a higher
|
||||
// level is determining a requested size for eden and that
|
||||
// should be honored unless there is a fundamental reason.
|
||||
eden_size = pointer_delta(from_start,
|
||||
eden_start,
|
||||
sizeof(char));
|
||||
} else {
|
||||
eden_size = MIN2(requested_eden_size,
|
||||
pointer_delta(from_start, eden_start, sizeof(char)));
|
||||
}
|
||||
|
||||
eden_size = align_size_down(eden_size, alignment);
|
||||
eden_end = eden_start + eden_size;
|
||||
assert(eden_end >= eden_start, "addition overflowed");
|
||||
|
||||
// To may resize into from space as long as it is clear of live data.
|
||||
// From space must remain page aligned, though, so we need to do some
|
||||
// extra calculations.
|
||||
|
||||
// First calculate an optimal to-space
|
||||
to_end = (char*)virtual_space()->high();
|
||||
to_start = (char*)pointer_delta(to_end, (char*)requested_survivor_size,
|
||||
sizeof(char));
|
||||
|
||||
// Does the optimal to-space overlap from-space?
|
||||
if (to_start < (char*)from()->end()) {
|
||||
// Calculate the minimum offset possible for from_end
|
||||
size_t from_size = pointer_delta(from()->top(), from_start, sizeof(char));
|
||||
|
||||
// Should we be in this method if from_space is empty? Why not the set_space method? FIX ME!
|
||||
if (from_size == 0) {
|
||||
from_size = alignment;
|
||||
} else {
|
||||
from_size = align_size_up(from_size, alignment);
|
||||
}
|
||||
|
||||
from_end = from_start + from_size;
|
||||
assert(from_end > from_start, "addition overflow or from_size problem");
|
||||
|
||||
guarantee(from_end <= (char*)from()->end(), "from_end moved to the right");
|
||||
|
||||
// Now update to_start with the new from_end
|
||||
to_start = MAX2(from_end, to_start);
|
||||
} else {
|
||||
// If shrinking, move to-space down to abut the end of from-space
|
||||
// so that shrinking will move to-space down. If not shrinking
|
||||
// to-space is moving up to allow for growth on the next expansion.
|
||||
if (requested_eden_size <= cur_eden_size) {
|
||||
to_start = from_end;
|
||||
if (to_start + requested_survivor_size > to_start) {
|
||||
to_end = to_start + requested_survivor_size;
|
||||
}
|
||||
}
|
||||
// else leave to_end pointing to the high end of the virtual space.
|
||||
}
|
||||
|
||||
guarantee(to_start != to_end, "to space is zero sized");
|
||||
|
||||
if (PrintAdaptiveSizePolicy && Verbose) {
|
||||
gclog_or_tty->print_cr(" [eden_start .. eden_end): "
|
||||
"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
|
||||
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,
|
||||
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,
|
||||
p2i(to_start),
|
||||
p2i(to_end),
|
||||
pointer_delta( to_end, to_start, sizeof(char)));
|
||||
}
|
||||
} else {
|
||||
// Eden, to, from
|
||||
if (PrintAdaptiveSizePolicy && Verbose) {
|
||||
gclog_or_tty->print_cr(" Eden, to, from:");
|
||||
}
|
||||
|
||||
// Calculate the to-space boundaries based on
|
||||
// the start of from-space.
|
||||
to_end = from_start;
|
||||
to_start = (char*)pointer_delta(from_start,
|
||||
(char*)requested_survivor_size,
|
||||
sizeof(char));
|
||||
// Calculate the ideal eden boundaries.
|
||||
// eden_end is already at the bottom of the generation
|
||||
assert(eden_start == virtual_space()->low(),
|
||||
"Eden is not starting at the low end of the virtual space");
|
||||
if (eden_start + requested_eden_size >= eden_start) {
|
||||
eden_end = eden_start + requested_eden_size;
|
||||
} else {
|
||||
eden_end = to_start;
|
||||
}
|
||||
|
||||
// Does eden intrude into to-space? to-space
|
||||
// gets priority but eden is not allowed to shrink
|
||||
// to 0.
|
||||
if (eden_end > to_start) {
|
||||
eden_end = to_start;
|
||||
}
|
||||
|
||||
// Don't let eden shrink down to 0 or less.
|
||||
eden_end = MAX2(eden_end, eden_start + alignment);
|
||||
assert(eden_start + alignment >= eden_start, "Overflow");
|
||||
|
||||
size_t eden_size;
|
||||
if (maintain_minimum) {
|
||||
// Use all the space available.
|
||||
eden_end = MAX2(eden_end, to_start);
|
||||
eden_size = pointer_delta(eden_end, eden_start, sizeof(char));
|
||||
eden_size = MIN2(eden_size, cur_eden_size);
|
||||
} else {
|
||||
eden_size = pointer_delta(eden_end, eden_start, sizeof(char));
|
||||
}
|
||||
eden_size = align_size_down(eden_size, alignment);
|
||||
assert(maintain_minimum || eden_size <= requested_eden_size,
|
||||
"Eden size is too large");
|
||||
assert(eden_size >= alignment, "Eden size is too small");
|
||||
eden_end = eden_start + eden_size;
|
||||
|
||||
// Move to-space down to eden.
|
||||
if (requested_eden_size < cur_eden_size) {
|
||||
to_start = eden_end;
|
||||
if (to_start + requested_survivor_size > to_start) {
|
||||
to_end = MIN2(from_start, to_start + requested_survivor_size);
|
||||
} else {
|
||||
to_end = from_start;
|
||||
}
|
||||
}
|
||||
|
||||
// eden_end may have moved so again make sure
|
||||
// the to-space and eden don't overlap.
|
||||
to_start = MAX2(eden_end, to_start);
|
||||
|
||||
// from-space
|
||||
size_t from_used = from()->used();
|
||||
if (requested_survivor_size > from_used) {
|
||||
if (from_start + requested_survivor_size >= from_start) {
|
||||
from_end = from_start + requested_survivor_size;
|
||||
}
|
||||
if (from_end > virtual_space()->high()) {
|
||||
from_end = virtual_space()->high();
|
||||
}
|
||||
}
|
||||
|
||||
assert(to_start >= eden_end, "to-space should be above eden");
|
||||
if (PrintAdaptiveSizePolicy && Verbose) {
|
||||
gclog_or_tty->print_cr(" [eden_start .. eden_end): "
|
||||
"[" PTR_FORMAT " .. " PTR_FORMAT ") " SIZE_FORMAT,
|
||||
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,
|
||||
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,
|
||||
p2i(from_start),
|
||||
p2i(from_end),
|
||||
pointer_delta(from_end, from_start, sizeof(char)));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
guarantee((HeapWord*)from_start <= from()->bottom(),
|
||||
"from start moved to the right");
|
||||
guarantee((HeapWord*)from_end >= from()->top(),
|
||||
"from end moved into live data");
|
||||
assert(is_object_aligned((intptr_t)eden_start), "checking alignment");
|
||||
assert(is_object_aligned((intptr_t)from_start), "checking alignment");
|
||||
assert(is_object_aligned((intptr_t)to_start), "checking alignment");
|
||||
|
||||
MemRegion edenMR((HeapWord*)eden_start, (HeapWord*)eden_end);
|
||||
MemRegion toMR ((HeapWord*)to_start, (HeapWord*)to_end);
|
||||
MemRegion fromMR((HeapWord*)from_start, (HeapWord*)from_end);
|
||||
|
||||
// Let's make sure the call to initialize doesn't reset "top"!
|
||||
HeapWord* old_from_top = from()->top();
|
||||
|
||||
// For PrintAdaptiveSizePolicy block below
|
||||
size_t old_from = from()->capacity();
|
||||
size_t old_to = to()->capacity();
|
||||
|
||||
// If not clearing the spaces, do some checking to verify that
|
||||
// the spaces are already mangled.
|
||||
|
||||
// Must check mangling before the spaces are reshaped. Otherwise,
|
||||
// the bottom or end of one space may have moved into another
|
||||
// a failure of the check may not correctly indicate which space
|
||||
// is not properly mangled.
|
||||
if (ZapUnusedHeapArea) {
|
||||
HeapWord* limit = (HeapWord*) virtual_space()->high();
|
||||
eden()->check_mangled_unused_area(limit);
|
||||
from()->check_mangled_unused_area(limit);
|
||||
to()->check_mangled_unused_area(limit);
|
||||
}
|
||||
|
||||
// The call to initialize NULL's the next compaction space
|
||||
eden()->initialize(edenMR,
|
||||
SpaceDecorator::Clear,
|
||||
SpaceDecorator::DontMangle);
|
||||
eden()->set_next_compaction_space(from());
|
||||
to()->initialize(toMR ,
|
||||
SpaceDecorator::Clear,
|
||||
SpaceDecorator::DontMangle);
|
||||
from()->initialize(fromMR,
|
||||
SpaceDecorator::DontClear,
|
||||
SpaceDecorator::DontMangle);
|
||||
|
||||
assert(from()->top() == old_from_top, "from top changed!");
|
||||
|
||||
if (PrintAdaptiveSizePolicy) {
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
assert(gch->kind() == CollectedHeap::GenCollectedHeap, "Sanity");
|
||||
|
||||
gclog_or_tty->print("AdaptiveSizePolicy::survivor space sizes: "
|
||||
"collection: %d "
|
||||
"(" SIZE_FORMAT ", " SIZE_FORMAT ") -> "
|
||||
"(" SIZE_FORMAT ", " SIZE_FORMAT ") ",
|
||||
gch->total_collections(),
|
||||
old_from, old_to,
|
||||
from()->capacity(),
|
||||
to()->capacity());
|
||||
gclog_or_tty->cr();
|
||||
}
|
||||
}
|
||||
|
||||
void ASParNewGeneration::compute_new_size() {
|
||||
GenCollectedHeap* gch = GenCollectedHeap::heap();
|
||||
assert(gch->kind() == CollectedHeap::GenCollectedHeap,
|
||||
"not a CMS generational heap");
|
||||
|
||||
|
||||
CMSAdaptiveSizePolicy* size_policy =
|
||||
(CMSAdaptiveSizePolicy*)gch->gen_policy()->size_policy();
|
||||
assert(size_policy->is_gc_cms_adaptive_size_policy(),
|
||||
"Wrong type of size policy");
|
||||
|
||||
size_t survived = from()->used();
|
||||
if (!survivor_overflow()) {
|
||||
// Keep running averages on how much survived
|
||||
size_policy->avg_survived()->sample(survived);
|
||||
} else {
|
||||
size_t promoted =
|
||||
(size_t) next_gen()->gc_stats()->avg_promoted()->last_sample();
|
||||
assert(promoted < gch->capacity(), "Conversion problem?");
|
||||
size_t survived_guess = survived + promoted;
|
||||
size_policy->avg_survived()->sample(survived_guess);
|
||||
}
|
||||
|
||||
size_t survivor_limit = max_survivor_size();
|
||||
_tenuring_threshold =
|
||||
size_policy->compute_survivor_space_size_and_threshold(
|
||||
_survivor_overflow,
|
||||
_tenuring_threshold,
|
||||
survivor_limit);
|
||||
size_policy->avg_young_live()->sample(used());
|
||||
size_policy->avg_eden_live()->sample(eden()->used());
|
||||
|
||||
size_policy->compute_eden_space_size(eden()->capacity(), max_gen_size());
|
||||
|
||||
resize(size_policy->calculated_eden_size_in_bytes(),
|
||||
size_policy->calculated_survivor_size_in_bytes());
|
||||
|
||||
if (UsePerfData) {
|
||||
CMSGCAdaptivePolicyCounters* counters =
|
||||
(CMSGCAdaptivePolicyCounters*) gch->collector_policy()->counters();
|
||||
assert(counters->kind() ==
|
||||
GCPolicyCounters::CMSGCAdaptivePolicyCountersKind,
|
||||
"Wrong kind of counters");
|
||||
counters->update_tenuring_threshold(_tenuring_threshold);
|
||||
counters->update_survivor_overflowed(_survivor_overflow);
|
||||
counters->update_young_capacity(capacity());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#ifndef PRODUCT
|
||||
// Changes from PSYoungGen version
|
||||
// value of "alignment"
|
||||
void ASParNewGeneration::space_invariants() {
|
||||
const size_t alignment = os::vm_page_size();
|
||||
|
||||
// Currently, our eden size cannot shrink to zero
|
||||
guarantee(eden()->capacity() >= alignment, "eden too small");
|
||||
guarantee(from()->capacity() >= alignment, "from too small");
|
||||
guarantee(to()->capacity() >= alignment, "to too small");
|
||||
|
||||
// Relationship of spaces to each other
|
||||
char* eden_start = (char*)eden()->bottom();
|
||||
char* eden_end = (char*)eden()->end();
|
||||
char* from_start = (char*)from()->bottom();
|
||||
char* from_end = (char*)from()->end();
|
||||
char* to_start = (char*)to()->bottom();
|
||||
char* to_end = (char*)to()->end();
|
||||
|
||||
guarantee(eden_start >= virtual_space()->low(), "eden bottom");
|
||||
guarantee(eden_start < eden_end, "eden space consistency");
|
||||
guarantee(from_start < from_end, "from space consistency");
|
||||
guarantee(to_start < to_end, "to space consistency");
|
||||
|
||||
// Check whether from space is below to space
|
||||
if (from_start < to_start) {
|
||||
// Eden, from, to
|
||||
guarantee(eden_end <= from_start, "eden/from boundary");
|
||||
guarantee(from_end <= to_start, "from/to boundary");
|
||||
guarantee(to_end <= virtual_space()->high(), "to end");
|
||||
} else {
|
||||
// Eden, to, from
|
||||
guarantee(eden_end <= to_start, "eden/to boundary");
|
||||
guarantee(to_end <= from_start, "to/from boundary");
|
||||
guarantee(from_end <= virtual_space()->high(), "from end");
|
||||
}
|
||||
|
||||
// More checks that the virtual space is consistent with the spaces
|
||||
assert(virtual_space()->committed_size() >=
|
||||
(eden()->capacity() +
|
||||
to()->capacity() +
|
||||
from()->capacity()), "Committed size is inconsistent");
|
||||
assert(virtual_space()->committed_size() <= virtual_space()->reserved_size(),
|
||||
"Space invariant");
|
||||
char* eden_top = (char*)eden()->top();
|
||||
char* from_top = (char*)from()->top();
|
||||
char* to_top = (char*)to()->top();
|
||||
assert(eden_top <= virtual_space()->high(), "eden top");
|
||||
assert(from_top <= virtual_space()->high(), "from top");
|
||||
assert(to_top <= virtual_space()->high(), "to top");
|
||||
}
|
||||
#endif
|
@ -1,98 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2005, 2010, 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.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef SHARE_VM_GC_IMPLEMENTATION_PARNEW_ASPARNEWGENERATION_HPP
|
||||
#define SHARE_VM_GC_IMPLEMENTATION_PARNEW_ASPARNEWGENERATION_HPP
|
||||
|
||||
#include "gc_implementation/parNew/parNewGeneration.hpp"
|
||||
#include "gc_implementation/shared/adaptiveSizePolicy.hpp"
|
||||
|
||||
// A Generation that does parallel young-gen collection extended
|
||||
// for adaptive size policy.
|
||||
|
||||
// Division of generation into spaces
|
||||
// done by DefNewGeneration::compute_space_boundaries()
|
||||
// +---------------+
|
||||
// | uncommitted |
|
||||
// |---------------|
|
||||
// | ss0 |
|
||||
// |---------------|
|
||||
// | ss1 |
|
||||
// |---------------|
|
||||
// | |
|
||||
// | eden |
|
||||
// | |
|
||||
// +---------------+ <-- low end of VirtualSpace
|
||||
//
|
||||
class ASParNewGeneration: public ParNewGeneration {
|
||||
|
||||
size_t _min_gen_size;
|
||||
|
||||
// Resize the generation based on the desired sizes of
|
||||
// the constituent spaces.
|
||||
bool resize_generation(size_t eden_size, size_t survivor_size);
|
||||
// Resize the spaces based on their desired sizes but
|
||||
// respecting the maximum size of the generation.
|
||||
void resize_spaces(size_t eden_size, size_t survivor_size);
|
||||
// Return the byte size remaining to the minimum generation size.
|
||||
size_t available_to_min_gen();
|
||||
// Return the byte size remaining to the live data in the generation.
|
||||
size_t available_to_live() const;
|
||||
// Return the byte size that the generation is allowed to shrink.
|
||||
size_t limit_gen_shrink(size_t bytes);
|
||||
// Reset the size of the spaces after a shrink of the generation.
|
||||
void reset_survivors_after_shrink();
|
||||
|
||||
// Accessor
|
||||
VirtualSpace* virtual_space() { return &_virtual_space; }
|
||||
|
||||
virtual void adjust_desired_tenuring_threshold();
|
||||
|
||||
public:
|
||||
|
||||
ASParNewGeneration(ReservedSpace rs,
|
||||
size_t initial_byte_size,
|
||||
size_t min_byte_size,
|
||||
int level);
|
||||
|
||||
virtual const char* short_name() const { return "ASParNew"; }
|
||||
virtual const char* name() const;
|
||||
virtual Generation::Name kind() { return ASParNew; }
|
||||
|
||||
// Change the sizes of eden and the survivor spaces in
|
||||
// the generation. The parameters are desired sizes
|
||||
// and are not guaranteed to be met. For example, if
|
||||
// the total is larger than the generation.
|
||||
void resize(size_t eden_size, size_t survivor_size);
|
||||
|
||||
virtual void compute_new_size();
|
||||
|
||||
size_t max_gen_size() { return _reserved.byte_size(); }
|
||||
size_t min_gen_size() const { return _min_gen_size; }
|
||||
|
||||
// Space boundary invariant checker
|
||||
void space_invariants() PRODUCT_RETURN;
|
||||
};
|
||||
|
||||
#endif // SHARE_VM_GC_IMPLEMENTATION_PARNEW_ASPARNEWGENERATION_HPP
|
@ -614,18 +614,21 @@ void ParNewGenTask::work(uint worker_id) {
|
||||
|
||||
KlassScanClosure klass_scan_closure(&par_scan_state.to_space_root_closure(),
|
||||
gch->rem_set()->klass_rem_set());
|
||||
|
||||
int so = SharedHeap::SO_AllClasses | SharedHeap::SO_Strings | SharedHeap::SO_ScavengeCodeCache;
|
||||
CLDToKlassAndOopClosure cld_scan_closure(&klass_scan_closure,
|
||||
&par_scan_state.to_space_root_closure(),
|
||||
false);
|
||||
|
||||
par_scan_state.start_strong_roots();
|
||||
gch->gen_process_strong_roots(_gen->level(),
|
||||
true, // Process younger gens, if any,
|
||||
// as strong roots.
|
||||
false, // no scope; this is parallel code
|
||||
SharedHeap::ScanningOption(so),
|
||||
&par_scan_state.to_space_root_closure(),
|
||||
&par_scan_state.older_gen_closure(),
|
||||
&klass_scan_closure);
|
||||
gch->gen_process_roots(_gen->level(),
|
||||
true, // Process younger gens, if any,
|
||||
// as strong roots.
|
||||
false, // no scope; this is parallel code
|
||||
SharedHeap::SO_ScavengeCodeCache,
|
||||
GenCollectedHeap::StrongAndWeakRoots,
|
||||
&par_scan_state.to_space_root_closure(),
|
||||
&par_scan_state.older_gen_closure(),
|
||||
&cld_scan_closure);
|
||||
|
||||
par_scan_state.end_strong_roots();
|
||||
|
||||
// "evacuate followers".
|
||||
|
@ -69,7 +69,7 @@ class ParScanThreadState {
|
||||
ParScanWithoutBarrierClosure _to_space_closure; // scan_without_gc_barrier
|
||||
ParScanWithBarrierClosure _old_gen_closure; // scan_with_gc_barrier
|
||||
ParRootScanWithoutBarrierClosure _to_space_root_closure; // scan_root_without_gc_barrier
|
||||
// One of these two will be passed to process_strong_roots, which will
|
||||
// One of these two will be passed to process_roots, which will
|
||||
// set its generation. The first is for two-gen configs where the
|
||||
// old gen collects the perm gen; the second is for arbitrary configs.
|
||||
// The second isn't used right now (it used to be used for the train, an
|
||||
|
@ -59,7 +59,7 @@ void ThreadRootsMarkingTask::do_it(GCTaskManager* manager, uint which) {
|
||||
|
||||
PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
|
||||
CLDToOopClosure mark_and_push_from_clds(&mark_and_push_closure, true);
|
||||
CodeBlobToOopClosure mark_and_push_in_blobs(&mark_and_push_closure, /*do_marking=*/ true);
|
||||
MarkingCodeBlobClosure mark_and_push_in_blobs(&mark_and_push_closure, !CodeBlobToOopClosure::FixRelocations);
|
||||
|
||||
if (_java_thread != NULL)
|
||||
_java_thread->oops_do(
|
||||
@ -100,7 +100,7 @@ void MarkFromRootsTask::do_it(GCTaskManager* manager, uint which) {
|
||||
case threads:
|
||||
{
|
||||
ResourceMark rm;
|
||||
CodeBlobToOopClosure each_active_code_blob(&mark_and_push_closure, /*do_marking=*/ true);
|
||||
MarkingCodeBlobClosure each_active_code_blob(&mark_and_push_closure, !CodeBlobToOopClosure::FixRelocations);
|
||||
CLDToOopClosure mark_and_push_from_cld(&mark_and_push_closure);
|
||||
Threads::oops_do(&mark_and_push_closure, &mark_and_push_from_cld, &each_active_code_blob);
|
||||
}
|
||||
|
@ -536,14 +536,14 @@ void PSMarkSweep::mark_sweep_phase1(bool clear_all_softrefs) {
|
||||
Universe::oops_do(mark_and_push_closure());
|
||||
JNIHandles::oops_do(mark_and_push_closure()); // Global (strong) JNI handles
|
||||
CLDToOopClosure mark_and_push_from_cld(mark_and_push_closure());
|
||||
CodeBlobToOopClosure each_active_code_blob(mark_and_push_closure(), /*do_marking=*/ true);
|
||||
MarkingCodeBlobClosure each_active_code_blob(mark_and_push_closure(), !CodeBlobToOopClosure::FixRelocations);
|
||||
Threads::oops_do(mark_and_push_closure(), &mark_and_push_from_cld, &each_active_code_blob);
|
||||
ObjectSynchronizer::oops_do(mark_and_push_closure());
|
||||
FlatProfiler::oops_do(mark_and_push_closure());
|
||||
Management::oops_do(mark_and_push_closure());
|
||||
JvmtiExport::oops_do(mark_and_push_closure());
|
||||
SystemDictionary::always_strong_oops_do(mark_and_push_closure());
|
||||
ClassLoaderDataGraph::always_strong_oops_do(mark_and_push_closure(), follow_klass_closure(), true);
|
||||
ClassLoaderDataGraph::always_strong_cld_do(follow_cld_closure());
|
||||
// Do not treat nmethods as strong roots for mark/sweep, since we can unload them.
|
||||
//CodeCache::scavenge_root_nmethods_do(CodeBlobToOopClosure(mark_and_push_closure()));
|
||||
}
|
||||
@ -633,16 +633,16 @@ void PSMarkSweep::mark_sweep_phase3() {
|
||||
FlatProfiler::oops_do(adjust_pointer_closure());
|
||||
Management::oops_do(adjust_pointer_closure());
|
||||
JvmtiExport::oops_do(adjust_pointer_closure());
|
||||
// SO_AllClasses
|
||||
SystemDictionary::oops_do(adjust_pointer_closure());
|
||||
ClassLoaderDataGraph::oops_do(adjust_pointer_closure(), adjust_klass_closure(), true);
|
||||
ClassLoaderDataGraph::cld_do(adjust_cld_closure());
|
||||
|
||||
// Now adjust pointers in remaining weak roots. (All of which should
|
||||
// have been cleared if they pointed to non-surviving objects.)
|
||||
// Global (weak) JNI handles
|
||||
JNIHandles::weak_oops_do(&always_true, adjust_pointer_closure());
|
||||
|
||||
CodeCache::oops_do(adjust_pointer_closure());
|
||||
CodeBlobToOopClosure adjust_from_blobs(adjust_pointer_closure(), CodeBlobToOopClosure::FixRelocations);
|
||||
CodeCache::blobs_do(&adjust_from_blobs);
|
||||
StringTable::oops_do(adjust_pointer_closure());
|
||||
ref_processor()->weak_oops_do(adjust_pointer_closure());
|
||||
PSScavenge::reference_processor()->weak_oops_do(adjust_pointer_closure());
|
||||
|
@ -40,11 +40,11 @@ class PSMarkSweep : public MarkSweep {
|
||||
static CollectorCounters* _counters;
|
||||
|
||||
// Closure accessors
|
||||
static OopClosure* mark_and_push_closure() { return &MarkSweep::mark_and_push_closure; }
|
||||
static KlassClosure* follow_klass_closure() { return &MarkSweep::follow_klass_closure; }
|
||||
static VoidClosure* follow_stack_closure() { return (VoidClosure*)&MarkSweep::follow_stack_closure; }
|
||||
static OopClosure* adjust_pointer_closure() { return (OopClosure*)&MarkSweep::adjust_pointer_closure; }
|
||||
static KlassClosure* adjust_klass_closure() { return &MarkSweep::adjust_klass_closure; }
|
||||
static OopClosure* mark_and_push_closure() { return &MarkSweep::mark_and_push_closure; }
|
||||
static VoidClosure* follow_stack_closure() { return (VoidClosure*)&MarkSweep::follow_stack_closure; }
|
||||
static CLDClosure* follow_cld_closure() { return &MarkSweep::follow_cld_closure; }
|
||||
static OopClosure* adjust_pointer_closure() { return (OopClosure*)&MarkSweep::adjust_pointer_closure; }
|
||||
static CLDClosure* adjust_cld_closure() { return &MarkSweep::adjust_cld_closure; }
|
||||
static BoolObjectClosure* is_alive_closure() { return (BoolObjectClosure*)&MarkSweep::is_alive; }
|
||||
|
||||
debug_only(public:) // Used for PSParallelCompact debugging
|
||||
|
@ -2474,7 +2474,6 @@ void PSParallelCompact::adjust_roots() {
|
||||
FlatProfiler::oops_do(adjust_pointer_closure());
|
||||
Management::oops_do(adjust_pointer_closure());
|
||||
JvmtiExport::oops_do(adjust_pointer_closure());
|
||||
// SO_AllClasses
|
||||
SystemDictionary::oops_do(adjust_pointer_closure());
|
||||
ClassLoaderDataGraph::oops_do(adjust_pointer_closure(), adjust_klass_closure(), true);
|
||||
|
||||
@ -2483,7 +2482,8 @@ void PSParallelCompact::adjust_roots() {
|
||||
// Global (weak) JNI handles
|
||||
JNIHandles::weak_oops_do(&always_true, adjust_pointer_closure());
|
||||
|
||||
CodeCache::oops_do(adjust_pointer_closure());
|
||||
CodeBlobToOopClosure adjust_from_blobs(adjust_pointer_closure(), CodeBlobToOopClosure::FixRelocations);
|
||||
CodeCache::blobs_do(&adjust_from_blobs);
|
||||
StringTable::oops_do(adjust_pointer_closure());
|
||||
ref_processor()->weak_oops_do(adjust_pointer_closure());
|
||||
// Roots were visited so references into the young gen in roots
|
||||
|
@ -100,7 +100,7 @@ void ScavengeRootsTask::do_it(GCTaskManager* manager, uint which) {
|
||||
|
||||
case code_cache:
|
||||
{
|
||||
CodeBlobToOopClosure each_scavengable_code_blob(&roots_to_old_closure, /*do_marking=*/ true);
|
||||
MarkingCodeBlobClosure each_scavengable_code_blob(&roots_to_old_closure, CodeBlobToOopClosure::FixRelocations);
|
||||
CodeCache::scavenge_root_nmethods_do(&each_scavengable_code_blob);
|
||||
}
|
||||
break;
|
||||
@ -123,7 +123,7 @@ void ThreadRootsTask::do_it(GCTaskManager* manager, uint which) {
|
||||
PSPromotionManager* pm = PSPromotionManager::gc_thread_promotion_manager(which);
|
||||
PSScavengeRootsClosure roots_closure(pm);
|
||||
CLDClosure* roots_from_clds = NULL; // Not needed. All CLDs are already visited.
|
||||
CodeBlobToOopClosure roots_in_blobs(&roots_closure, /*do_marking=*/ true);
|
||||
MarkingCodeBlobClosure roots_in_blobs(&roots_closure, CodeBlobToOopClosure::FixRelocations);
|
||||
|
||||
if (_java_thread != NULL)
|
||||
_java_thread->oops_do(&roots_closure, roots_from_clds, &roots_in_blobs);
|
||||
|
@ -507,7 +507,7 @@ class AdaptiveSizePolicyOutput : StackObj {
|
||||
// always fail (never do the print based on the interval test).
|
||||
return PrintGCDetails &&
|
||||
UseAdaptiveSizePolicy &&
|
||||
(UseParallelGC || UseConcMarkSweepGC) &&
|
||||
UseParallelGC &&
|
||||
(AdaptiveSizePolicyOutputInterval > 0) &&
|
||||
((count == 0) ||
|
||||
((count % AdaptiveSizePolicyOutputInterval) == 0));
|
||||
|
@ -216,16 +216,4 @@ class LinearLeastSquareFit : public CHeapObj<mtGC> {
|
||||
bool increment_will_decrease();
|
||||
};
|
||||
|
||||
class GCPauseTimer : StackObj {
|
||||
elapsedTimer* _timer;
|
||||
public:
|
||||
GCPauseTimer(elapsedTimer* timer) {
|
||||
_timer = timer;
|
||||
_timer->stop();
|
||||
}
|
||||
~GCPauseTimer() {
|
||||
_timer->start();
|
||||
}
|
||||
};
|
||||
|
||||
#endif // SHARE_VM_GC_IMPLEMENTATION_SHARED_GCUTIL_HPP
|
||||
|
@ -54,21 +54,14 @@ void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); }
|
||||
void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); }
|
||||
|
||||
MarkSweep::MarkAndPushClosure MarkSweep::mark_and_push_closure;
|
||||
MarkSweep::FollowKlassClosure MarkSweep::follow_klass_closure;
|
||||
MarkSweep::AdjustKlassClosure MarkSweep::adjust_klass_closure;
|
||||
CLDToOopClosure MarkSweep::follow_cld_closure(&mark_and_push_closure);
|
||||
CLDToOopClosure MarkSweep::adjust_cld_closure(&adjust_pointer_closure);
|
||||
|
||||
void MarkSweep::MarkAndPushClosure::do_oop(oop* p) { mark_and_push(p); }
|
||||
void MarkSweep::MarkAndPushClosure::do_oop(narrowOop* p) { mark_and_push(p); }
|
||||
|
||||
void MarkSweep::FollowKlassClosure::do_klass(Klass* klass) {
|
||||
klass->oops_do(&MarkSweep::mark_and_push_closure);
|
||||
}
|
||||
void MarkSweep::AdjustKlassClosure::do_klass(Klass* klass) {
|
||||
klass->oops_do(&MarkSweep::adjust_pointer_closure);
|
||||
}
|
||||
|
||||
void MarkSweep::follow_class_loader(ClassLoaderData* cld) {
|
||||
cld->oops_do(&MarkSweep::mark_and_push_closure, &MarkSweep::follow_klass_closure, true);
|
||||
MarkSweep::follow_cld_closure.do_cld(cld);
|
||||
}
|
||||
|
||||
void MarkSweep::follow_stack() {
|
||||
|
@ -65,17 +65,6 @@ class MarkSweep : AllStatic {
|
||||
virtual void do_oop(narrowOop* p);
|
||||
};
|
||||
|
||||
// The one and only place to start following the classes.
|
||||
// Should only be applied to the ClassLoaderData klasses list.
|
||||
class FollowKlassClosure : public KlassClosure {
|
||||
public:
|
||||
void do_klass(Klass* klass);
|
||||
};
|
||||
class AdjustKlassClosure : public KlassClosure {
|
||||
public:
|
||||
void do_klass(Klass* klass);
|
||||
};
|
||||
|
||||
class FollowStackClosure: public VoidClosure {
|
||||
public:
|
||||
virtual void do_void();
|
||||
@ -144,10 +133,10 @@ class MarkSweep : AllStatic {
|
||||
static IsAliveClosure is_alive;
|
||||
static FollowRootClosure follow_root_closure;
|
||||
static MarkAndPushClosure mark_and_push_closure;
|
||||
static FollowKlassClosure follow_klass_closure;
|
||||
static FollowStackClosure follow_stack_closure;
|
||||
static CLDToOopClosure follow_cld_closure;
|
||||
static AdjustPointerClosure adjust_pointer_closure;
|
||||
static AdjustKlassClosure adjust_klass_closure;
|
||||
static CLDToOopClosure adjust_cld_closure;
|
||||
|
||||
// Accessors
|
||||
static uint total_invocations() { return _total_invocations; }
|
||||
|
@ -195,6 +195,43 @@ void VM_GenCollectFull::doit() {
|
||||
gch->do_full_collection(gch->must_clear_all_soft_refs(), _max_level);
|
||||
}
|
||||
|
||||
bool VM_CollectForMetadataAllocation::initiate_concurrent_GC() {
|
||||
#if INCLUDE_ALL_GCS
|
||||
if (UseConcMarkSweepGC || UseG1GC) {
|
||||
if (UseConcMarkSweepGC && CMSClassUnloadingEnabled) {
|
||||
MetaspaceGC::set_should_concurrent_collect(true);
|
||||
} else if (UseG1GC) {
|
||||
G1CollectedHeap* g1h = G1CollectedHeap::heap();
|
||||
g1h->g1_policy()->set_initiate_conc_mark_if_possible();
|
||||
|
||||
GCCauseSetter x(g1h, _gc_cause);
|
||||
|
||||
// At this point we are supposed to start a concurrent cycle. We
|
||||
// will do so if one is not already in progress.
|
||||
bool should_start = g1h->g1_policy()->force_initial_mark_if_outside_cycle(_gc_cause);
|
||||
|
||||
if (should_start) {
|
||||
double pause_target = g1h->g1_policy()->max_pause_time_ms();
|
||||
g1h->do_collection_pause_at_safepoint(pause_target);
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
return false;
|
||||
}
|
||||
|
||||
static void log_metaspace_alloc_failure_for_concurrent_GC() {
|
||||
if (Verbose && PrintGCDetails) {
|
||||
if (UseConcMarkSweepGC) {
|
||||
gclog_or_tty->print_cr("\nCMS full GC for Metaspace");
|
||||
} else if (UseG1GC) {
|
||||
gclog_or_tty->print_cr("\nG1 full GC for Metaspace");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void VM_CollectForMetadataAllocation::doit() {
|
||||
SvcGCMarker sgcm(SvcGCMarker::FULL);
|
||||
|
||||
@ -206,54 +243,57 @@ void VM_CollectForMetadataAllocation::doit() {
|
||||
// a GC that freed space for the allocation.
|
||||
if (!MetadataAllocationFailALot) {
|
||||
_result = _loader_data->metaspace_non_null()->allocate(_size, _mdtype);
|
||||
}
|
||||
|
||||
if (_result == NULL) {
|
||||
if (UseConcMarkSweepGC) {
|
||||
if (CMSClassUnloadingEnabled) {
|
||||
MetaspaceGC::set_should_concurrent_collect(true);
|
||||
}
|
||||
// For CMS expand since the collection is going to be concurrent.
|
||||
_result =
|
||||
_loader_data->metaspace_non_null()->expand_and_allocate(_size, _mdtype);
|
||||
}
|
||||
if (_result == NULL) {
|
||||
// Don't clear the soft refs yet.
|
||||
if (Verbose && PrintGCDetails && UseConcMarkSweepGC) {
|
||||
gclog_or_tty->print_cr("\nCMS full GC for Metaspace");
|
||||
}
|
||||
heap->collect_as_vm_thread(GCCause::_metadata_GC_threshold);
|
||||
// After a GC try to allocate without expanding. Could fail
|
||||
// and expansion will be tried below.
|
||||
_result =
|
||||
_loader_data->metaspace_non_null()->allocate(_size, _mdtype);
|
||||
}
|
||||
if (_result == NULL) {
|
||||
// If still failing, allow the Metaspace to expand.
|
||||
// See delta_capacity_until_GC() for explanation of the
|
||||
// amount of the expansion.
|
||||
// This should work unless there really is no more space
|
||||
// or a MaxMetaspaceSize has been specified on the command line.
|
||||
_result =
|
||||
_loader_data->metaspace_non_null()->expand_and_allocate(_size, _mdtype);
|
||||
if (_result == NULL) {
|
||||
// If expansion failed, do a last-ditch collection and try allocating
|
||||
// again. A last-ditch collection will clear softrefs. This
|
||||
// behavior is similar to the last-ditch collection done for perm
|
||||
// gen when it was full and a collection for failed allocation
|
||||
// did not free perm gen space.
|
||||
heap->collect_as_vm_thread(GCCause::_last_ditch_collection);
|
||||
_result =
|
||||
_loader_data->metaspace_non_null()->allocate(_size, _mdtype);
|
||||
}
|
||||
}
|
||||
if (Verbose && PrintGCDetails && _result == NULL) {
|
||||
gclog_or_tty->print_cr("\nAfter Metaspace GC failed to allocate size "
|
||||
SIZE_FORMAT, _size);
|
||||
if (_result != NULL) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (_result == NULL && GC_locker::is_active_and_needs_gc()) {
|
||||
if (initiate_concurrent_GC()) {
|
||||
// For CMS and G1 expand since the collection is going to be concurrent.
|
||||
_result = _loader_data->metaspace_non_null()->expand_and_allocate(_size, _mdtype);
|
||||
if (_result != NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
log_metaspace_alloc_failure_for_concurrent_GC();
|
||||
}
|
||||
|
||||
// Don't clear the soft refs yet.
|
||||
heap->collect_as_vm_thread(GCCause::_metadata_GC_threshold);
|
||||
// After a GC try to allocate without expanding. Could fail
|
||||
// and expansion will be tried below.
|
||||
_result = _loader_data->metaspace_non_null()->allocate(_size, _mdtype);
|
||||
if (_result != NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
// If still failing, allow the Metaspace to expand.
|
||||
// See delta_capacity_until_GC() for explanation of the
|
||||
// amount of the expansion.
|
||||
// This should work unless there really is no more space
|
||||
// or a MaxMetaspaceSize has been specified on the command line.
|
||||
_result = _loader_data->metaspace_non_null()->expand_and_allocate(_size, _mdtype);
|
||||
if (_result != NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
// If expansion failed, do a last-ditch collection and try allocating
|
||||
// again. A last-ditch collection will clear softrefs. This
|
||||
// behavior is similar to the last-ditch collection done for perm
|
||||
// gen when it was full and a collection for failed allocation
|
||||
// did not free perm gen space.
|
||||
heap->collect_as_vm_thread(GCCause::_last_ditch_collection);
|
||||
_result = _loader_data->metaspace_non_null()->allocate(_size, _mdtype);
|
||||
if (_result != NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Verbose && PrintGCDetails) {
|
||||
gclog_or_tty->print_cr("\nAfter Metaspace GC failed to allocate size "
|
||||
SIZE_FORMAT, _size);
|
||||
}
|
||||
|
||||
if (GC_locker::is_active_and_needs_gc()) {
|
||||
set_gc_locked();
|
||||
}
|
||||
}
|
||||
|
@ -217,6 +217,8 @@ class VM_CollectForMetadataAllocation: public VM_GC_Operation {
|
||||
virtual VMOp_Type type() const { return VMOp_CollectForMetadataAllocation; }
|
||||
virtual void doit();
|
||||
MetaWord* result() const { return _result; }
|
||||
|
||||
bool initiate_concurrent_GC();
|
||||
};
|
||||
|
||||
class SvcGCMarker : public StackObj {
|
||||
|
@ -429,7 +429,7 @@ void CardTableModRefBS::non_clean_card_iterate_possibly_parallel(Space* sp,
|
||||
OopsInGenClosure* cl,
|
||||
CardTableRS* ct) {
|
||||
if (!mr.is_empty()) {
|
||||
// Caller (process_strong_roots()) claims that all GC threads
|
||||
// Caller (process_roots()) claims that all GC threads
|
||||
// execute this call. With UseDynamicNumberOfGCThreads now all
|
||||
// active GC threads execute this call. The number of active GC
|
||||
// threads needs to be passed to par_non_clean_card_iterate_work()
|
||||
@ -438,7 +438,7 @@ void CardTableModRefBS::non_clean_card_iterate_possibly_parallel(Space* sp,
|
||||
// This is an example of where n_par_threads() is used instead
|
||||
// of workers()->active_workers(). n_par_threads can be set to 0 to
|
||||
// turn off parallelism. For example when this code is called as
|
||||
// part of verification and SharedHeap::process_strong_roots() is being
|
||||
// part of verification and SharedHeap::process_roots() is being
|
||||
// used, then n_par_threads() may have been set to 0. active_workers
|
||||
// is not overloaded with the meaning that it is a switch to disable
|
||||
// parallelism and so keeps the meaning of the number of
|
||||
|
@ -40,10 +40,6 @@
|
||||
#include "runtime/thread.inline.hpp"
|
||||
#include "runtime/vmThread.hpp"
|
||||
#include "utilities/macros.hpp"
|
||||
#if INCLUDE_ALL_GCS
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
|
||||
#endif // INCLUDE_ALL_GCS
|
||||
|
||||
// CollectorPolicy methods
|
||||
|
||||
|
@ -115,7 +115,6 @@ class CollectorPolicy : public CHeapObj<mtGC> {
|
||||
CollectorPolicyKind,
|
||||
GenCollectorPolicyKind,
|
||||
ConcurrentMarkSweepPolicyKind,
|
||||
ASConcurrentMarkSweepPolicyKind,
|
||||
G1CollectorPolicyKind
|
||||
};
|
||||
|
||||
|
@ -614,6 +614,9 @@ void DefNewGeneration::collect(bool full,
|
||||
|
||||
KlassScanClosure klass_scan_closure(&fsc_with_no_gc_barrier,
|
||||
gch->rem_set()->klass_rem_set());
|
||||
CLDToKlassAndOopClosure cld_scan_closure(&klass_scan_closure,
|
||||
&fsc_with_no_gc_barrier,
|
||||
false);
|
||||
|
||||
set_promo_failure_scan_stack_closure(&fsc_with_no_gc_barrier);
|
||||
FastEvacuateFollowersClosure evacuate_followers(gch, _level, this,
|
||||
@ -623,16 +626,15 @@ void DefNewGeneration::collect(bool full,
|
||||
assert(gch->no_allocs_since_save_marks(0),
|
||||
"save marks have not been newly set.");
|
||||
|
||||
int so = SharedHeap::SO_AllClasses | SharedHeap::SO_Strings | SharedHeap::SO_ScavengeCodeCache;
|
||||
|
||||
gch->gen_process_strong_roots(_level,
|
||||
true, // Process younger gens, if any,
|
||||
// as strong roots.
|
||||
true, // activate StrongRootsScope
|
||||
SharedHeap::ScanningOption(so),
|
||||
&fsc_with_no_gc_barrier,
|
||||
&fsc_with_gc_barrier,
|
||||
&klass_scan_closure);
|
||||
gch->gen_process_roots(_level,
|
||||
true, // Process younger gens, if any,
|
||||
// as strong roots.
|
||||
true, // activate StrongRootsScope
|
||||
SharedHeap::SO_ScavengeCodeCache,
|
||||
GenCollectedHeap::StrongAndWeakRoots,
|
||||
&fsc_with_no_gc_barrier,
|
||||
&fsc_with_gc_barrier,
|
||||
&cld_scan_closure);
|
||||
|
||||
// "evacuate followers".
|
||||
evacuate_followers.do_void();
|
||||
|
@ -61,8 +61,8 @@
|
||||
GenCollectedHeap* GenCollectedHeap::_gch;
|
||||
NOT_PRODUCT(size_t GenCollectedHeap::_skip_header_HeapWords = 0;)
|
||||
|
||||
// The set of potentially parallel tasks in strong root scanning.
|
||||
enum GCH_process_strong_roots_tasks {
|
||||
// The set of potentially parallel tasks in root scanning.
|
||||
enum GCH_strong_roots_tasks {
|
||||
// We probably want to parallelize both of these internally, but for now...
|
||||
GCH_PS_younger_gens,
|
||||
// Leave this one last.
|
||||
@ -72,11 +72,11 @@ enum GCH_process_strong_roots_tasks {
|
||||
GenCollectedHeap::GenCollectedHeap(GenCollectorPolicy *policy) :
|
||||
SharedHeap(policy),
|
||||
_gen_policy(policy),
|
||||
_gen_process_strong_tasks(new SubTasksDone(GCH_PS_NumElements)),
|
||||
_gen_process_roots_tasks(new SubTasksDone(GCH_PS_NumElements)),
|
||||
_full_collections_completed(0)
|
||||
{
|
||||
if (_gen_process_strong_tasks == NULL ||
|
||||
!_gen_process_strong_tasks->valid()) {
|
||||
if (_gen_process_roots_tasks == NULL ||
|
||||
!_gen_process_roots_tasks->valid()) {
|
||||
vm_exit_during_initialization("Failed necessary allocation.");
|
||||
}
|
||||
assert(policy != NULL, "Sanity check");
|
||||
@ -202,13 +202,11 @@ void GenCollectedHeap::post_initialize() {
|
||||
guarantee(policy->is_generation_policy(), "Illegal policy type");
|
||||
DefNewGeneration* def_new_gen = (DefNewGeneration*) get_gen(0);
|
||||
assert(def_new_gen->kind() == Generation::DefNew ||
|
||||
def_new_gen->kind() == Generation::ParNew ||
|
||||
def_new_gen->kind() == Generation::ASParNew,
|
||||
def_new_gen->kind() == Generation::ParNew,
|
||||
"Wrong generation kind");
|
||||
|
||||
Generation* old_gen = get_gen(1);
|
||||
assert(old_gen->kind() == Generation::ConcurrentMarkSweep ||
|
||||
old_gen->kind() == Generation::ASConcurrentMarkSweep ||
|
||||
old_gen->kind() == Generation::MarkSweepCompact,
|
||||
"Wrong generation kind");
|
||||
|
||||
@ -573,9 +571,6 @@ void GenCollectedHeap::do_collection(bool full,
|
||||
}
|
||||
}
|
||||
|
||||
AdaptiveSizePolicy* sp = gen_policy()->size_policy();
|
||||
AdaptiveSizePolicyOutput(sp, total_collections());
|
||||
|
||||
print_heap_after_gc();
|
||||
|
||||
#ifdef TRACESPINNING
|
||||
@ -589,24 +584,29 @@ HeapWord* GenCollectedHeap::satisfy_failed_allocation(size_t size, bool is_tlab)
|
||||
|
||||
void GenCollectedHeap::set_par_threads(uint t) {
|
||||
SharedHeap::set_par_threads(t);
|
||||
_gen_process_strong_tasks->set_n_threads(t);
|
||||
_gen_process_roots_tasks->set_n_threads(t);
|
||||
}
|
||||
|
||||
void GenCollectedHeap::
|
||||
gen_process_strong_roots(int level,
|
||||
bool younger_gens_as_roots,
|
||||
bool activate_scope,
|
||||
SharedHeap::ScanningOption so,
|
||||
OopsInGenClosure* not_older_gens,
|
||||
OopsInGenClosure* older_gens,
|
||||
KlassClosure* klass_closure) {
|
||||
// General strong roots.
|
||||
gen_process_roots(int level,
|
||||
bool younger_gens_as_roots,
|
||||
bool activate_scope,
|
||||
SharedHeap::ScanningOption so,
|
||||
OopsInGenClosure* not_older_gens,
|
||||
OopsInGenClosure* weak_roots,
|
||||
OopsInGenClosure* older_gens,
|
||||
CLDClosure* cld_closure,
|
||||
CLDClosure* weak_cld_closure,
|
||||
CodeBlobClosure* code_closure) {
|
||||
|
||||
SharedHeap::process_strong_roots(activate_scope, so,
|
||||
not_older_gens, klass_closure);
|
||||
// General roots.
|
||||
SharedHeap::process_roots(activate_scope, so,
|
||||
not_older_gens, weak_roots,
|
||||
cld_closure, weak_cld_closure,
|
||||
code_closure);
|
||||
|
||||
if (younger_gens_as_roots) {
|
||||
if (!_gen_process_strong_tasks->is_task_claimed(GCH_PS_younger_gens)) {
|
||||
if (!_gen_process_roots_tasks->is_task_claimed(GCH_PS_younger_gens)) {
|
||||
for (int i = 0; i < level; i++) {
|
||||
not_older_gens->set_generation(_gens[i]);
|
||||
_gens[i]->oop_iterate(not_older_gens);
|
||||
@ -622,7 +622,38 @@ gen_process_strong_roots(int level,
|
||||
older_gens->reset_generation();
|
||||
}
|
||||
|
||||
_gen_process_strong_tasks->all_tasks_completed();
|
||||
_gen_process_roots_tasks->all_tasks_completed();
|
||||
}
|
||||
|
||||
void GenCollectedHeap::
|
||||
gen_process_roots(int level,
|
||||
bool younger_gens_as_roots,
|
||||
bool activate_scope,
|
||||
SharedHeap::ScanningOption so,
|
||||
bool only_strong_roots,
|
||||
OopsInGenClosure* not_older_gens,
|
||||
OopsInGenClosure* older_gens,
|
||||
CLDClosure* cld_closure) {
|
||||
|
||||
const bool is_adjust_phase = !only_strong_roots && !younger_gens_as_roots;
|
||||
|
||||
bool is_moving_collection = false;
|
||||
if (level == 0 || is_adjust_phase) {
|
||||
// young collections are always moving
|
||||
is_moving_collection = true;
|
||||
}
|
||||
|
||||
MarkingCodeBlobClosure mark_code_closure(not_older_gens, is_moving_collection);
|
||||
CodeBlobClosure* code_closure = &mark_code_closure;
|
||||
|
||||
gen_process_roots(level,
|
||||
younger_gens_as_roots,
|
||||
activate_scope, so,
|
||||
not_older_gens, only_strong_roots ? NULL : not_older_gens,
|
||||
older_gens,
|
||||
cld_closure, only_strong_roots ? NULL : cld_closure,
|
||||
code_closure);
|
||||
|
||||
}
|
||||
|
||||
void GenCollectedHeap::gen_process_weak_roots(OopClosure* root_closure) {
|
||||
@ -724,8 +755,7 @@ void GenCollectedHeap::collect_locked(GCCause::Cause cause, int max_level) {
|
||||
#if INCLUDE_ALL_GCS
|
||||
bool GenCollectedHeap::create_cms_collector() {
|
||||
|
||||
assert(((_gens[1]->kind() == Generation::ConcurrentMarkSweep) ||
|
||||
(_gens[1]->kind() == Generation::ASConcurrentMarkSweep)),
|
||||
assert(_gens[1]->kind() == Generation::ConcurrentMarkSweep,
|
||||
"Unexpected generation kinds");
|
||||
// Skip two header words in the block content verification
|
||||
NOT_PRODUCT(_skip_header_HeapWords = CMSCollector::skip_header_HeapWords();)
|
||||
|
@ -78,9 +78,9 @@ public:
|
||||
unsigned int _full_collections_completed;
|
||||
|
||||
// Data structure for claiming the (potentially) parallel tasks in
|
||||
// (gen-specific) strong roots processing.
|
||||
SubTasksDone* _gen_process_strong_tasks;
|
||||
SubTasksDone* gen_process_strong_tasks() { return _gen_process_strong_tasks; }
|
||||
// (gen-specific) roots processing.
|
||||
SubTasksDone* _gen_process_roots_tasks;
|
||||
SubTasksDone* gen_process_roots_tasks() { return _gen_process_roots_tasks; }
|
||||
|
||||
// In block contents verification, the number of header words to skip
|
||||
NOT_PRODUCT(static size_t _skip_header_HeapWords;)
|
||||
@ -403,18 +403,30 @@ public:
|
||||
// The "so" argument determines which of the roots
|
||||
// the closure is applied to:
|
||||
// "SO_None" does none;
|
||||
// "SO_AllClasses" applies the closure to all entries in the SystemDictionary;
|
||||
// "SO_SystemClasses" to all the "system" classes and loaders;
|
||||
// "SO_Strings" applies the closure to all entries in the StringTable.
|
||||
void gen_process_strong_roots(int level,
|
||||
bool younger_gens_as_roots,
|
||||
// The remaining arguments are in an order
|
||||
// consistent with SharedHeap::process_strong_roots:
|
||||
bool activate_scope,
|
||||
SharedHeap::ScanningOption so,
|
||||
OopsInGenClosure* not_older_gens,
|
||||
OopsInGenClosure* older_gens,
|
||||
KlassClosure* klass_closure);
|
||||
private:
|
||||
void gen_process_roots(int level,
|
||||
bool younger_gens_as_roots,
|
||||
bool activate_scope,
|
||||
SharedHeap::ScanningOption so,
|
||||
OopsInGenClosure* not_older_gens,
|
||||
OopsInGenClosure* weak_roots,
|
||||
OopsInGenClosure* older_gens,
|
||||
CLDClosure* cld_closure,
|
||||
CLDClosure* weak_cld_closure,
|
||||
CodeBlobClosure* code_closure);
|
||||
|
||||
public:
|
||||
static const bool StrongAndWeakRoots = false;
|
||||
static const bool StrongRootsOnly = true;
|
||||
|
||||
void gen_process_roots(int level,
|
||||
bool younger_gens_as_roots,
|
||||
bool activate_scope,
|
||||
SharedHeap::ScanningOption so,
|
||||
bool only_strong_roots,
|
||||
OopsInGenClosure* not_older_gens,
|
||||
OopsInGenClosure* older_gens,
|
||||
CLDClosure* cld_closure);
|
||||
|
||||
// Apply "root_closure" to all the weak roots of the system.
|
||||
// These include JNI weak roots, string table,
|
||||
|
@ -207,13 +207,14 @@ void GenMarkSweep::mark_sweep_phase1(int level,
|
||||
// Need new claim bits before marking starts.
|
||||
ClassLoaderDataGraph::clear_claimed_marks();
|
||||
|
||||
gch->gen_process_strong_roots(level,
|
||||
false, // Younger gens are not roots.
|
||||
true, // activate StrongRootsScope
|
||||
SharedHeap::SO_SystemClasses,
|
||||
&follow_root_closure,
|
||||
&follow_root_closure,
|
||||
&follow_klass_closure);
|
||||
gch->gen_process_roots(level,
|
||||
false, // Younger gens are not roots.
|
||||
true, // activate StrongRootsScope
|
||||
SharedHeap::SO_None,
|
||||
GenCollectedHeap::StrongRootsOnly,
|
||||
&follow_root_closure,
|
||||
&follow_root_closure,
|
||||
&follow_cld_closure);
|
||||
|
||||
// Process reference objects found during marking
|
||||
{
|
||||
@ -291,13 +292,14 @@ void GenMarkSweep::mark_sweep_phase3(int level) {
|
||||
// are run.
|
||||
adjust_pointer_closure.set_orig_generation(gch->get_gen(level));
|
||||
|
||||
gch->gen_process_strong_roots(level,
|
||||
false, // Younger gens are not roots.
|
||||
true, // activate StrongRootsScope
|
||||
SharedHeap::SO_AllClasses | SharedHeap::SO_Strings | SharedHeap::SO_AllCodeCache,
|
||||
&adjust_pointer_closure,
|
||||
&adjust_pointer_closure,
|
||||
&adjust_klass_closure);
|
||||
gch->gen_process_roots(level,
|
||||
false, // Younger gens are not roots.
|
||||
true, // activate StrongRootsScope
|
||||
SharedHeap::SO_AllCodeCache,
|
||||
GenCollectedHeap::StrongAndWeakRoots,
|
||||
&adjust_pointer_closure,
|
||||
&adjust_pointer_closure,
|
||||
&adjust_cld_closure);
|
||||
|
||||
gch->gen_process_weak_roots(&adjust_pointer_closure);
|
||||
|
||||
|
@ -154,8 +154,7 @@ bool Generation::is_in(const void* p) const {
|
||||
|
||||
DefNewGeneration* Generation::as_DefNewGeneration() {
|
||||
assert((kind() == Generation::DefNew) ||
|
||||
(kind() == Generation::ParNew) ||
|
||||
(kind() == Generation::ASParNew),
|
||||
(kind() == Generation::ParNew),
|
||||
"Wrong youngest generation type");
|
||||
return (DefNewGeneration*) this;
|
||||
}
|
||||
|
@ -131,8 +131,6 @@ class Generation: public CHeapObj<mtGC> {
|
||||
public:
|
||||
// The set of possible generation kinds.
|
||||
enum Name {
|
||||
ASParNew,
|
||||
ASConcurrentMarkSweep,
|
||||
DefNew,
|
||||
ParNew,
|
||||
MarkSweepCompact,
|
||||
|
@ -32,7 +32,6 @@
|
||||
#include "runtime/java.hpp"
|
||||
#include "utilities/macros.hpp"
|
||||
#if INCLUDE_ALL_GCS
|
||||
#include "gc_implementation/parNew/asParNewGeneration.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"
|
||||
#include "gc_implementation/parNew/parNewGeneration.hpp"
|
||||
#endif // INCLUDE_ALL_GCS
|
||||
@ -50,12 +49,6 @@ Generation* GenerationSpec::init(ReservedSpace rs, int level,
|
||||
case Generation::ParNew:
|
||||
return new ParNewGeneration(rs, init_size(), level);
|
||||
|
||||
case Generation::ASParNew:
|
||||
return new ASParNewGeneration(rs,
|
||||
init_size(),
|
||||
init_size() /* min size */,
|
||||
level);
|
||||
|
||||
case Generation::ConcurrentMarkSweep: {
|
||||
assert(UseConcMarkSweepGC, "UseConcMarkSweepGC should be set");
|
||||
CardTableRS* ctrs = remset->as_CardTableRS();
|
||||
@ -75,26 +68,6 @@ Generation* GenerationSpec::init(ReservedSpace rs, int level,
|
||||
|
||||
return g;
|
||||
}
|
||||
|
||||
case Generation::ASConcurrentMarkSweep: {
|
||||
assert(UseConcMarkSweepGC, "UseConcMarkSweepGC should be set");
|
||||
CardTableRS* ctrs = remset->as_CardTableRS();
|
||||
if (ctrs == NULL) {
|
||||
vm_exit_during_initialization("Rem set incompatibility.");
|
||||
}
|
||||
// Otherwise
|
||||
// The constructor creates the CMSCollector if needed,
|
||||
// else registers with an existing CMSCollector
|
||||
|
||||
ASConcurrentMarkSweepGeneration* g = NULL;
|
||||
g = new ASConcurrentMarkSweepGeneration(rs,
|
||||
init_size(), level, ctrs, UseCMSAdaptiveFreeLists,
|
||||
(FreeBlockDictionary<FreeChunk>::DictionaryChoice)CMSDictionaryChoice);
|
||||
|
||||
g->initialize_performance_counters();
|
||||
|
||||
return g;
|
||||
}
|
||||
#endif // INCLUDE_ALL_GCS
|
||||
|
||||
default:
|
||||
|
@ -35,6 +35,10 @@ void CLDToOopClosure::do_cld(ClassLoaderData* cld) {
|
||||
cld->oops_do(_oop_closure, &_klass_closure, _must_claim_cld);
|
||||
}
|
||||
|
||||
void CLDToKlassAndOopClosure::do_cld(ClassLoaderData* cld) {
|
||||
cld->oops_do(_oop_closure, _klass_closure, _must_claim_cld);
|
||||
}
|
||||
|
||||
void ObjectToOopClosure::do_object(oop obj) {
|
||||
obj->oop_iterate(_cl);
|
||||
}
|
||||
@ -43,6 +47,20 @@ void VoidClosure::do_void() {
|
||||
ShouldNotCallThis();
|
||||
}
|
||||
|
||||
void CodeBlobToOopClosure::do_nmethod(nmethod* nm) {
|
||||
nm->oops_do(_cl);
|
||||
if (_fix_relocations) {
|
||||
nm->fix_oop_relocations();
|
||||
}
|
||||
}
|
||||
|
||||
void CodeBlobToOopClosure::do_code_blob(CodeBlob* cb) {
|
||||
nmethod* nm = cb->as_nmethod_or_null();
|
||||
if (nm != NULL) {
|
||||
do_nmethod(nm);
|
||||
}
|
||||
}
|
||||
|
||||
MarkingCodeBlobClosure::MarkScope::MarkScope(bool activate)
|
||||
: _active(activate)
|
||||
{
|
||||
@ -55,32 +73,7 @@ MarkingCodeBlobClosure::MarkScope::~MarkScope() {
|
||||
|
||||
void MarkingCodeBlobClosure::do_code_blob(CodeBlob* cb) {
|
||||
nmethod* nm = cb->as_nmethod_or_null();
|
||||
if (nm == NULL) return;
|
||||
if (!nm->test_set_oops_do_mark()) {
|
||||
NOT_PRODUCT(if (TraceScavenge) nm->print_on(tty, "oops_do, 1st visit\n"));
|
||||
do_newly_marked_nmethod(nm);
|
||||
} else {
|
||||
NOT_PRODUCT(if (TraceScavenge) nm->print_on(tty, "oops_do, skipped on 2nd visit\n"));
|
||||
if (nm != NULL && !nm->test_set_oops_do_mark()) {
|
||||
do_nmethod(nm);
|
||||
}
|
||||
}
|
||||
|
||||
void CodeBlobToOopClosure::do_newly_marked_nmethod(nmethod* nm) {
|
||||
nm->oops_do(_cl, /*allow_zombie=*/ false);
|
||||
}
|
||||
|
||||
void CodeBlobToOopClosure::do_code_blob(CodeBlob* cb) {
|
||||
if (!_do_marking) {
|
||||
nmethod* nm = cb->as_nmethod_or_null();
|
||||
NOT_PRODUCT(if (TraceScavenge && Verbose && nm != NULL) nm->print_on(tty, "oops_do, unmarked visit\n"));
|
||||
// This assert won't work, since there are lots of mini-passes
|
||||
// (mostly in debug mode) that co-exist with marking phases.
|
||||
//assert(!(cb->is_nmethod() && ((nmethod*)cb)->test_oops_do_mark()), "found marked nmethod during mark-free phase");
|
||||
if (nm != NULL) {
|
||||
nm->oops_do(_cl);
|
||||
}
|
||||
} else {
|
||||
MarkingCodeBlobClosure::do_code_blob(cb);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
@ -70,8 +70,8 @@ class ExtendedOopClosure : public OopClosure {
|
||||
//
|
||||
// Providing default implementations of the _nv functions unfortunately
|
||||
// removes the compile-time safeness, but reduces the clutter for the
|
||||
// ExtendedOopClosures that don't need to walk the metadata. Currently,
|
||||
// only CMS needs these.
|
||||
// ExtendedOopClosures that don't need to walk the metadata.
|
||||
// Currently, only CMS and G1 need these.
|
||||
|
||||
virtual bool do_metadata() { return do_metadata_nv(); }
|
||||
bool do_metadata_v() { return do_metadata(); }
|
||||
@ -126,15 +126,16 @@ class KlassToOopClosure : public KlassClosure {
|
||||
_oop_closure = oop_closure;
|
||||
}
|
||||
|
||||
public:
|
||||
public:
|
||||
KlassToOopClosure(OopClosure* oop_closure = NULL) : _oop_closure(oop_closure) {}
|
||||
|
||||
virtual void do_klass(Klass* k);
|
||||
};
|
||||
|
||||
class CLDToOopClosure : public CLDClosure {
|
||||
OopClosure* _oop_closure;
|
||||
OopClosure* _oop_closure;
|
||||
KlassToOopClosure _klass_closure;
|
||||
bool _must_claim_cld;
|
||||
bool _must_claim_cld;
|
||||
|
||||
public:
|
||||
CLDToOopClosure(OopClosure* oop_closure, bool must_claim_cld = true) :
|
||||
@ -145,6 +146,23 @@ class CLDToOopClosure : public CLDClosure {
|
||||
void do_cld(ClassLoaderData* cld);
|
||||
};
|
||||
|
||||
class CLDToKlassAndOopClosure : public CLDClosure {
|
||||
friend class SharedHeap;
|
||||
friend class G1CollectedHeap;
|
||||
protected:
|
||||
OopClosure* _oop_closure;
|
||||
KlassClosure* _klass_closure;
|
||||
bool _must_claim_cld;
|
||||
public:
|
||||
CLDToKlassAndOopClosure(KlassClosure* klass_closure,
|
||||
OopClosure* oop_closure,
|
||||
bool must_claim_cld) :
|
||||
_oop_closure(oop_closure),
|
||||
_klass_closure(klass_closure),
|
||||
_must_claim_cld(must_claim_cld) {}
|
||||
void do_cld(ClassLoaderData* cld);
|
||||
};
|
||||
|
||||
// The base class for all concurrent marking closures,
|
||||
// that participates in class unloading.
|
||||
// It's used to proxy through the metadata to the oops defined in them.
|
||||
@ -246,14 +264,26 @@ class CodeBlobClosure : public Closure {
|
||||
virtual void do_code_blob(CodeBlob* cb) = 0;
|
||||
};
|
||||
|
||||
|
||||
class MarkingCodeBlobClosure : public CodeBlobClosure {
|
||||
// Applies an oop closure to all ref fields in code blobs
|
||||
// iterated over in an object iteration.
|
||||
class CodeBlobToOopClosure : public CodeBlobClosure {
|
||||
OopClosure* _cl;
|
||||
bool _fix_relocations;
|
||||
protected:
|
||||
void do_nmethod(nmethod* nm);
|
||||
public:
|
||||
CodeBlobToOopClosure(OopClosure* cl, bool fix_relocations) : _cl(cl), _fix_relocations(fix_relocations) {}
|
||||
virtual void do_code_blob(CodeBlob* cb);
|
||||
|
||||
const static bool FixRelocations = true;
|
||||
};
|
||||
|
||||
class MarkingCodeBlobClosure : public CodeBlobToOopClosure {
|
||||
public:
|
||||
MarkingCodeBlobClosure(OopClosure* cl, bool fix_relocations) : CodeBlobToOopClosure(cl, fix_relocations) {}
|
||||
// Called for each code blob, but at most once per unique blob.
|
||||
virtual void do_newly_marked_nmethod(nmethod* nm) = 0;
|
||||
|
||||
virtual void do_code_blob(CodeBlob* cb);
|
||||
// = { if (!nmethod(cb)->test_set_oops_do_mark()) do_newly_marked_nmethod(cb); }
|
||||
|
||||
class MarkScope : public StackObj {
|
||||
protected:
|
||||
@ -266,23 +296,6 @@ class MarkingCodeBlobClosure : public CodeBlobClosure {
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
// Applies an oop closure to all ref fields in code blobs
|
||||
// iterated over in an object iteration.
|
||||
class CodeBlobToOopClosure: public MarkingCodeBlobClosure {
|
||||
OopClosure* _cl;
|
||||
bool _do_marking;
|
||||
public:
|
||||
virtual void do_newly_marked_nmethod(nmethod* cb);
|
||||
// = { cb->oops_do(_cl); }
|
||||
virtual void do_code_blob(CodeBlob* cb);
|
||||
// = { if (_do_marking) super::do_code_blob(cb); else cb->oops_do(_cl); }
|
||||
CodeBlobToOopClosure(OopClosure* cl, bool do_marking)
|
||||
: _cl(cl), _do_marking(do_marking) {}
|
||||
};
|
||||
|
||||
|
||||
|
||||
// MonitorClosure is used for iterating over monitors in the monitors cache
|
||||
|
||||
class ObjectMonitor;
|
||||
|
@ -25,6 +25,7 @@
|
||||
#ifndef SHARE_VM_MEMORY_METADATAFACTORY_HPP
|
||||
#define SHARE_VM_MEMORY_METADATAFACTORY_HPP
|
||||
|
||||
#include "classfile/classLoaderData.hpp"
|
||||
#include "utilities/array.hpp"
|
||||
#include "utilities/exceptions.hpp"
|
||||
#include "utilities/globalDefinitions.hpp"
|
||||
|
@ -29,6 +29,7 @@
|
||||
#include "gc_interface/collectedHeap.inline.hpp"
|
||||
#include "memory/sharedHeap.hpp"
|
||||
#include "oops/oop.inline.hpp"
|
||||
#include "runtime/atomic.inline.hpp"
|
||||
#include "runtime/fprofiler.hpp"
|
||||
#include "runtime/java.hpp"
|
||||
#include "services/management.hpp"
|
||||
@ -39,8 +40,8 @@ PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
|
||||
|
||||
SharedHeap* SharedHeap::_sh;
|
||||
|
||||
// The set of potentially parallel tasks in strong root scanning.
|
||||
enum SH_process_strong_roots_tasks {
|
||||
// The set of potentially parallel tasks in root scanning.
|
||||
enum SH_process_roots_tasks {
|
||||
SH_PS_Universe_oops_do,
|
||||
SH_PS_JNIHandles_oops_do,
|
||||
SH_PS_ObjectSynchronizer_oops_do,
|
||||
@ -58,6 +59,7 @@ SharedHeap::SharedHeap(CollectorPolicy* policy_) :
|
||||
CollectedHeap(),
|
||||
_collector_policy(policy_),
|
||||
_rem_set(NULL),
|
||||
_strong_roots_scope(NULL),
|
||||
_strong_roots_parity(0),
|
||||
_process_strong_tasks(new SubTasksDone(SH_PS_NumElements)),
|
||||
_workers(NULL)
|
||||
@ -114,6 +116,19 @@ public:
|
||||
static AssertNonScavengableClosure assert_is_non_scavengable_closure;
|
||||
#endif
|
||||
|
||||
SharedHeap::StrongRootsScope* SharedHeap::active_strong_roots_scope() const {
|
||||
return _strong_roots_scope;
|
||||
}
|
||||
void SharedHeap::register_strong_roots_scope(SharedHeap::StrongRootsScope* scope) {
|
||||
assert(_strong_roots_scope == NULL, "Should only have one StrongRootsScope active");
|
||||
assert(scope != NULL, "Illegal argument");
|
||||
_strong_roots_scope = scope;
|
||||
}
|
||||
void SharedHeap::unregister_strong_roots_scope(SharedHeap::StrongRootsScope* scope) {
|
||||
assert(_strong_roots_scope == scope, "Wrong scope unregistered");
|
||||
_strong_roots_scope = NULL;
|
||||
}
|
||||
|
||||
void SharedHeap::change_strong_roots_parity() {
|
||||
// Also set the new collection parity.
|
||||
assert(_strong_roots_parity >= 0 && _strong_roots_parity <= 2,
|
||||
@ -124,112 +139,161 @@ void SharedHeap::change_strong_roots_parity() {
|
||||
"Not in range.");
|
||||
}
|
||||
|
||||
SharedHeap::StrongRootsScope::StrongRootsScope(SharedHeap* outer, bool activate)
|
||||
: MarkScope(activate)
|
||||
SharedHeap::StrongRootsScope::StrongRootsScope(SharedHeap* heap, bool activate)
|
||||
: MarkScope(activate), _sh(heap), _n_workers_done_with_threads(0)
|
||||
{
|
||||
if (_active) {
|
||||
outer->change_strong_roots_parity();
|
||||
_sh->register_strong_roots_scope(this);
|
||||
_sh->change_strong_roots_parity();
|
||||
// Zero the claimed high water mark in the StringTable
|
||||
StringTable::clear_parallel_claimed_index();
|
||||
}
|
||||
}
|
||||
|
||||
SharedHeap::StrongRootsScope::~StrongRootsScope() {
|
||||
// nothing particular
|
||||
if (_active) {
|
||||
_sh->unregister_strong_roots_scope(this);
|
||||
}
|
||||
}
|
||||
|
||||
void SharedHeap::process_strong_roots(bool activate_scope,
|
||||
ScanningOption so,
|
||||
OopClosure* roots,
|
||||
KlassClosure* klass_closure) {
|
||||
Monitor* SharedHeap::StrongRootsScope::_lock = new Monitor(Mutex::leaf, "StrongRootsScope lock", false);
|
||||
|
||||
void SharedHeap::StrongRootsScope::mark_worker_done_with_threads(uint n_workers) {
|
||||
// The Thread work barrier is only needed by G1.
|
||||
// No need to use the barrier if this is single-threaded code.
|
||||
if (UseG1GC && n_workers > 0) {
|
||||
uint new_value = (uint)Atomic::add(1, &_n_workers_done_with_threads);
|
||||
if (new_value == n_workers) {
|
||||
// This thread is last. Notify the others.
|
||||
MonitorLockerEx ml(_lock, Mutex::_no_safepoint_check_flag);
|
||||
_lock->notify_all();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void SharedHeap::StrongRootsScope::wait_until_all_workers_done_with_threads(uint n_workers) {
|
||||
// No need to use the barrier if this is single-threaded code.
|
||||
if (n_workers > 0 && (uint)_n_workers_done_with_threads != n_workers) {
|
||||
MonitorLockerEx ml(_lock, Mutex::_no_safepoint_check_flag);
|
||||
while ((uint)_n_workers_done_with_threads != n_workers) {
|
||||
_lock->wait(Mutex::_no_safepoint_check_flag, 0, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void SharedHeap::process_roots(bool activate_scope,
|
||||
ScanningOption so,
|
||||
OopClosure* strong_roots,
|
||||
OopClosure* weak_roots,
|
||||
CLDClosure* strong_cld_closure,
|
||||
CLDClosure* weak_cld_closure,
|
||||
CodeBlobClosure* code_roots) {
|
||||
StrongRootsScope srs(this, activate_scope);
|
||||
|
||||
// General strong roots.
|
||||
// General roots.
|
||||
assert(_strong_roots_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
|
||||
// could be trying to change the termination condition while the task
|
||||
// is executing in another GC worker.
|
||||
|
||||
// Iterating over the CLDG and the Threads are done early to allow G1 to
|
||||
// first process the strong CLDs and nmethods and then, after a barrier,
|
||||
// let the thread process the weak CLDs and nmethods.
|
||||
|
||||
if (!_process_strong_tasks->is_task_claimed(SH_PS_ClassLoaderDataGraph_oops_do)) {
|
||||
ClassLoaderDataGraph::roots_cld_do(strong_cld_closure, weak_cld_closure);
|
||||
}
|
||||
|
||||
// Some CLDs contained in the thread frames should be considered strong.
|
||||
// Don't process them if they will be processed during the ClassLoaderDataGraph phase.
|
||||
CLDClosure* roots_from_clds_p = (strong_cld_closure != weak_cld_closure) ? strong_cld_closure : NULL;
|
||||
// Only process code roots from thread stacks if we aren't visiting the entire CodeCache anyway
|
||||
CodeBlobClosure* roots_from_code_p = (so & SO_AllCodeCache) ? NULL : code_roots;
|
||||
|
||||
Threads::possibly_parallel_oops_do(strong_roots, roots_from_clds_p, roots_from_code_p);
|
||||
|
||||
// This is the point where this worker thread will not find more strong CLDs/nmethods.
|
||||
// Report this so G1 can synchronize the strong and weak CLDs/nmethods processing.
|
||||
active_strong_roots_scope()->mark_worker_done_with_threads(n_par_threads());
|
||||
|
||||
if (!_process_strong_tasks->is_task_claimed(SH_PS_Universe_oops_do)) {
|
||||
Universe::oops_do(roots);
|
||||
Universe::oops_do(strong_roots);
|
||||
}
|
||||
// Global (strong) JNI handles
|
||||
if (!_process_strong_tasks->is_task_claimed(SH_PS_JNIHandles_oops_do))
|
||||
JNIHandles::oops_do(roots);
|
||||
|
||||
CodeBlobToOopClosure code_roots(roots, true);
|
||||
|
||||
CLDToOopClosure roots_from_clds(roots);
|
||||
// If we limit class scanning to SO_SystemClasses we need to apply a CLD closure to
|
||||
// CLDs which are strongly reachable from the thread stacks.
|
||||
CLDToOopClosure* roots_from_clds_p = ((so & SO_SystemClasses) ? &roots_from_clds : NULL);
|
||||
// All threads execute this; the individual threads are task groups.
|
||||
if (CollectedHeap::use_parallel_gc_threads()) {
|
||||
Threads::possibly_parallel_oops_do(roots, roots_from_clds_p, &code_roots);
|
||||
} else {
|
||||
Threads::oops_do(roots, roots_from_clds_p, &code_roots);
|
||||
}
|
||||
JNIHandles::oops_do(strong_roots);
|
||||
|
||||
if (!_process_strong_tasks-> is_task_claimed(SH_PS_ObjectSynchronizer_oops_do))
|
||||
ObjectSynchronizer::oops_do(roots);
|
||||
ObjectSynchronizer::oops_do(strong_roots);
|
||||
if (!_process_strong_tasks->is_task_claimed(SH_PS_FlatProfiler_oops_do))
|
||||
FlatProfiler::oops_do(roots);
|
||||
FlatProfiler::oops_do(strong_roots);
|
||||
if (!_process_strong_tasks->is_task_claimed(SH_PS_Management_oops_do))
|
||||
Management::oops_do(roots);
|
||||
Management::oops_do(strong_roots);
|
||||
if (!_process_strong_tasks->is_task_claimed(SH_PS_jvmti_oops_do))
|
||||
JvmtiExport::oops_do(roots);
|
||||
JvmtiExport::oops_do(strong_roots);
|
||||
|
||||
if (!_process_strong_tasks->is_task_claimed(SH_PS_SystemDictionary_oops_do)) {
|
||||
if (so & SO_AllClasses) {
|
||||
SystemDictionary::oops_do(roots);
|
||||
} else if (so & SO_SystemClasses) {
|
||||
SystemDictionary::always_strong_oops_do(roots);
|
||||
} else {
|
||||
fatal("We should always have selected either SO_AllClasses or SO_SystemClasses");
|
||||
}
|
||||
}
|
||||
|
||||
if (!_process_strong_tasks->is_task_claimed(SH_PS_ClassLoaderDataGraph_oops_do)) {
|
||||
if (so & SO_AllClasses) {
|
||||
ClassLoaderDataGraph::oops_do(roots, klass_closure, /* must_claim */ false);
|
||||
} else if (so & SO_SystemClasses) {
|
||||
ClassLoaderDataGraph::always_strong_oops_do(roots, klass_closure, /* must_claim */ true);
|
||||
}
|
||||
SystemDictionary::roots_oops_do(strong_roots, weak_roots);
|
||||
}
|
||||
|
||||
// All threads execute the following. A specific chunk of buckets
|
||||
// from the StringTable are the individual tasks.
|
||||
if (so & SO_Strings) {
|
||||
if (weak_roots != NULL) {
|
||||
if (CollectedHeap::use_parallel_gc_threads()) {
|
||||
StringTable::possibly_parallel_oops_do(roots);
|
||||
StringTable::possibly_parallel_oops_do(weak_roots);
|
||||
} else {
|
||||
StringTable::oops_do(roots);
|
||||
StringTable::oops_do(weak_roots);
|
||||
}
|
||||
}
|
||||
|
||||
if (!_process_strong_tasks->is_task_claimed(SH_PS_CodeCache_oops_do)) {
|
||||
if (so & SO_ScavengeCodeCache) {
|
||||
assert(&code_roots != NULL, "must supply closure for code cache");
|
||||
assert(code_roots != NULL, "must supply closure for code cache");
|
||||
|
||||
// We only visit parts of the CodeCache when scavenging.
|
||||
CodeCache::scavenge_root_nmethods_do(&code_roots);
|
||||
CodeCache::scavenge_root_nmethods_do(code_roots);
|
||||
}
|
||||
if (so & SO_AllCodeCache) {
|
||||
assert(&code_roots != NULL, "must supply closure for code cache");
|
||||
assert(code_roots != NULL, "must supply closure for code cache");
|
||||
|
||||
// CMSCollector uses this to do intermediate-strength collections.
|
||||
// We scan the entire code cache, since CodeCache::do_unloading is not called.
|
||||
CodeCache::blobs_do(&code_roots);
|
||||
CodeCache::blobs_do(code_roots);
|
||||
}
|
||||
// Verify that the code cache contents are not subject to
|
||||
// movement by a scavenging collection.
|
||||
DEBUG_ONLY(CodeBlobToOopClosure assert_code_is_non_scavengable(&assert_is_non_scavengable_closure, /*do_marking=*/ false));
|
||||
DEBUG_ONLY(CodeBlobToOopClosure assert_code_is_non_scavengable(&assert_is_non_scavengable_closure, !CodeBlobToOopClosure::FixRelocations));
|
||||
DEBUG_ONLY(CodeCache::asserted_non_scavengable_nmethods_do(&assert_code_is_non_scavengable));
|
||||
}
|
||||
|
||||
_process_strong_tasks->all_tasks_completed();
|
||||
}
|
||||
|
||||
void SharedHeap::process_all_roots(bool activate_scope,
|
||||
ScanningOption so,
|
||||
OopClosure* roots,
|
||||
CLDClosure* cld_closure,
|
||||
CodeBlobClosure* code_closure) {
|
||||
process_roots(activate_scope, so,
|
||||
roots, roots,
|
||||
cld_closure, cld_closure,
|
||||
code_closure);
|
||||
}
|
||||
|
||||
void SharedHeap::process_strong_roots(bool activate_scope,
|
||||
ScanningOption so,
|
||||
OopClosure* roots,
|
||||
CLDClosure* cld_closure,
|
||||
CodeBlobClosure* code_closure) {
|
||||
process_roots(activate_scope, so,
|
||||
roots, NULL,
|
||||
cld_closure, NULL,
|
||||
code_closure);
|
||||
}
|
||||
|
||||
|
||||
class AlwaysTrueClosure: public BoolObjectClosure {
|
||||
public:
|
||||
bool do_object_b(oop p) { return true; }
|
||||
|
@ -69,14 +69,10 @@ class KlassClosure;
|
||||
// number of active GC workers. CompactibleFreeListSpace and Space
|
||||
// have SequentialSubTasksDone's.
|
||||
// Example of using SubTasksDone and SequentialSubTasksDone
|
||||
// G1CollectedHeap::g1_process_strong_roots() calls
|
||||
// process_strong_roots(false, // no scoping; this is parallel code
|
||||
// is_scavenging, so,
|
||||
// &buf_scan_non_heap_roots,
|
||||
// &eager_scan_code_roots);
|
||||
// which delegates to SharedHeap::process_strong_roots() and uses
|
||||
// G1CollectedHeap::g1_process_roots()
|
||||
// to SharedHeap::process_roots() and uses
|
||||
// SubTasksDone* _process_strong_tasks to claim tasks.
|
||||
// process_strong_roots() calls
|
||||
// process_roots() calls
|
||||
// rem_set()->younger_refs_iterate()
|
||||
// to scan the card table and which eventually calls down into
|
||||
// CardTableModRefBS::par_non_clean_card_iterate_work(). This method
|
||||
@ -182,12 +178,12 @@ public:
|
||||
// task. (This also means that a parallel thread may only call
|
||||
// process_strong_roots once.)
|
||||
//
|
||||
// For calls to process_strong_roots by sequential code, the parity is
|
||||
// For calls to process_roots by sequential code, the parity is
|
||||
// updated automatically.
|
||||
//
|
||||
// The idea is that objects representing fine-grained tasks, such as
|
||||
// threads, will contain a "parity" field. A task will is claimed in the
|
||||
// current "process_strong_roots" call only if its parity field is the
|
||||
// current "process_roots" call only if its parity field is the
|
||||
// same as the "strong_roots_parity"; task claiming is accomplished by
|
||||
// updating the parity field to the strong_roots_parity with a CAS.
|
||||
//
|
||||
@ -198,27 +194,44 @@ public:
|
||||
// c) to never return a distinguished value (zero) with which such
|
||||
// task-claiming variables may be initialized, to indicate "never
|
||||
// claimed".
|
||||
private:
|
||||
void change_strong_roots_parity();
|
||||
public:
|
||||
int strong_roots_parity() { return _strong_roots_parity; }
|
||||
|
||||
// Call these in sequential code around process_strong_roots.
|
||||
// Call these in sequential code around process_roots.
|
||||
// strong_roots_prologue calls change_strong_roots_parity, if
|
||||
// parallel tasks are enabled.
|
||||
class StrongRootsScope : public MarkingCodeBlobClosure::MarkScope {
|
||||
public:
|
||||
StrongRootsScope(SharedHeap* outer, bool activate = true);
|
||||
// Used to implement the Thread work barrier.
|
||||
static Monitor* _lock;
|
||||
|
||||
SharedHeap* _sh;
|
||||
volatile jint _n_workers_done_with_threads;
|
||||
|
||||
public:
|
||||
StrongRootsScope(SharedHeap* heap, bool activate = true);
|
||||
~StrongRootsScope();
|
||||
|
||||
// Mark that this thread is done with the Threads work.
|
||||
void mark_worker_done_with_threads(uint n_workers);
|
||||
// Wait until all n_workers are done with the Threads work.
|
||||
void wait_until_all_workers_done_with_threads(uint n_workers);
|
||||
};
|
||||
friend class StrongRootsScope;
|
||||
|
||||
// The current active StrongRootScope
|
||||
StrongRootsScope* _strong_roots_scope;
|
||||
|
||||
StrongRootsScope* active_strong_roots_scope() const;
|
||||
|
||||
private:
|
||||
void register_strong_roots_scope(StrongRootsScope* scope);
|
||||
void unregister_strong_roots_scope(StrongRootsScope* scope);
|
||||
void change_strong_roots_parity();
|
||||
|
||||
public:
|
||||
enum ScanningOption {
|
||||
SO_None = 0x0,
|
||||
SO_AllClasses = 0x1,
|
||||
SO_SystemClasses = 0x2,
|
||||
SO_Strings = 0x4,
|
||||
SO_AllCodeCache = 0x8,
|
||||
SO_None = 0x0,
|
||||
SO_AllCodeCache = 0x8,
|
||||
SO_ScavengeCodeCache = 0x10
|
||||
};
|
||||
|
||||
@ -227,15 +240,26 @@ public:
|
||||
// Invoke the "do_oop" method the closure "roots" on all root locations.
|
||||
// The "so" argument determines which roots the closure is applied to:
|
||||
// "SO_None" does none;
|
||||
// "SO_AllClasses" applies the closure to all entries in the SystemDictionary;
|
||||
// "SO_SystemClasses" to all the "system" classes and loaders;
|
||||
// "SO_Strings" applies the closure to all entries in StringTable;
|
||||
// "SO_AllCodeCache" applies the closure to all elements of the CodeCache.
|
||||
// "SO_ScavengeCodeCache" applies the closure to elements on the scavenge root list in the CodeCache.
|
||||
void process_roots(bool activate_scope,
|
||||
ScanningOption so,
|
||||
OopClosure* strong_roots,
|
||||
OopClosure* weak_roots,
|
||||
CLDClosure* strong_cld_closure,
|
||||
CLDClosure* weak_cld_closure,
|
||||
CodeBlobClosure* code_roots);
|
||||
void process_all_roots(bool activate_scope,
|
||||
ScanningOption so,
|
||||
OopClosure* roots,
|
||||
CLDClosure* cld_closure,
|
||||
CodeBlobClosure* code_roots);
|
||||
void process_strong_roots(bool activate_scope,
|
||||
ScanningOption so,
|
||||
OopClosure* roots,
|
||||
KlassClosure* klass_closure);
|
||||
CLDClosure* cld_closure,
|
||||
CodeBlobClosure* code_roots);
|
||||
|
||||
|
||||
// Apply "root_closure" to the JNI weak roots..
|
||||
void process_weak_roots(OopClosure* root_closure);
|
||||
@ -251,7 +275,7 @@ public:
|
||||
virtual void gc_epilogue(bool full) = 0;
|
||||
|
||||
// Sets the number of parallel threads that will be doing tasks
|
||||
// (such as process strong roots) subsequently.
|
||||
// (such as process roots) subsequently.
|
||||
virtual void set_par_threads(uint t);
|
||||
|
||||
int n_termination();
|
||||
|
@ -685,14 +685,8 @@ size_t ContiguousSpace::block_size(const HeapWord* p) const {
|
||||
// This version requires locking.
|
||||
inline HeapWord* ContiguousSpace::allocate_impl(size_t size,
|
||||
HeapWord* const end_value) {
|
||||
// In G1 there are places where a GC worker can allocates into a
|
||||
// region using this serial allocation code without being prone to a
|
||||
// race with other GC workers (we ensure that no other GC worker can
|
||||
// access the same region at the same time). So the assert below is
|
||||
// too strong in the case of G1.
|
||||
assert(Heap_lock->owned_by_self() ||
|
||||
(SafepointSynchronize::is_at_safepoint() &&
|
||||
(Thread::current()->is_VM_thread() || UseG1GC)),
|
||||
(SafepointSynchronize::is_at_safepoint() && Thread::current()->is_VM_thread()),
|
||||
"not locked");
|
||||
HeapWord* obj = top();
|
||||
if (pointer_delta(end_value, obj) >= size) {
|
||||
|
@ -72,7 +72,7 @@
|
||||
#include "utilities/preserveException.hpp"
|
||||
#include "utilities/macros.hpp"
|
||||
#if INCLUDE_ALL_GCS
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
|
||||
#include "gc_implementation/shared/adaptiveSizePolicy.hpp"
|
||||
#include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp"
|
||||
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
|
||||
#include "gc_implementation/g1/g1CollectorPolicy.hpp"
|
||||
@ -802,13 +802,9 @@ jint Universe::initialize_heap() {
|
||||
gc_policy = new MarkSweepPolicy();
|
||||
} else if (UseConcMarkSweepGC) {
|
||||
#if INCLUDE_ALL_GCS
|
||||
if (UseAdaptiveSizePolicy) {
|
||||
gc_policy = new ASConcurrentMarkSweepPolicy();
|
||||
} else {
|
||||
gc_policy = new ConcurrentMarkSweepPolicy();
|
||||
}
|
||||
gc_policy = new ConcurrentMarkSweepPolicy();
|
||||
#else // INCLUDE_ALL_GCS
|
||||
fatal("UseConcMarkSweepGC not supported in this VM.");
|
||||
fatal("UseConcMarkSweepGC not supported in this VM.");
|
||||
#endif // INCLUDE_ALL_GCS
|
||||
} else { // default old generation
|
||||
gc_policy = new MarkSweepPolicy();
|
||||
|
@ -245,6 +245,7 @@ InstanceKlass::InstanceKlass(int vtable_len,
|
||||
set_static_oop_field_count(0);
|
||||
set_nonstatic_field_size(0);
|
||||
set_is_marked_dependent(false);
|
||||
set_has_unloaded_dependent(false);
|
||||
set_init_state(InstanceKlass::allocated);
|
||||
set_init_thread(NULL);
|
||||
set_reference_type(rt);
|
||||
@ -1801,6 +1802,9 @@ jmethodID InstanceKlass::jmethod_id_or_null(Method* method) {
|
||||
return id;
|
||||
}
|
||||
|
||||
int nmethodBucket::decrement() {
|
||||
return Atomic::add(-1, (volatile int *)&_count);
|
||||
}
|
||||
|
||||
//
|
||||
// Walk the list of dependent nmethods searching for nmethods which
|
||||
@ -1815,7 +1819,7 @@ int InstanceKlass::mark_dependent_nmethods(DepChange& changes) {
|
||||
nmethod* nm = b->get_nmethod();
|
||||
// since dependencies aren't removed until an nmethod becomes a zombie,
|
||||
// the dependency list may contain nmethods which aren't alive.
|
||||
if (nm->is_alive() && !nm->is_marked_for_deoptimization() && nm->check_dependency_on(changes)) {
|
||||
if (b->count() > 0 && nm->is_alive() && !nm->is_marked_for_deoptimization() && nm->check_dependency_on(changes)) {
|
||||
if (TraceDependencies) {
|
||||
ResourceMark rm;
|
||||
tty->print_cr("Marked for deoptimization");
|
||||
@ -1832,6 +1836,43 @@ int InstanceKlass::mark_dependent_nmethods(DepChange& changes) {
|
||||
return found;
|
||||
}
|
||||
|
||||
void InstanceKlass::clean_dependent_nmethods() {
|
||||
assert_locked_or_safepoint(CodeCache_lock);
|
||||
|
||||
if (has_unloaded_dependent()) {
|
||||
nmethodBucket* b = _dependencies;
|
||||
nmethodBucket* last = NULL;
|
||||
while (b != NULL) {
|
||||
assert(b->count() >= 0, err_msg("bucket count: %d", b->count()));
|
||||
|
||||
nmethodBucket* next = b->next();
|
||||
|
||||
if (b->count() == 0) {
|
||||
if (last == NULL) {
|
||||
_dependencies = next;
|
||||
} else {
|
||||
last->set_next(next);
|
||||
}
|
||||
delete b;
|
||||
// last stays the same.
|
||||
} else {
|
||||
last = b;
|
||||
}
|
||||
|
||||
b = next;
|
||||
}
|
||||
set_has_unloaded_dependent(false);
|
||||
}
|
||||
#ifdef ASSERT
|
||||
else {
|
||||
// Verification
|
||||
for (nmethodBucket* b = _dependencies; b != NULL; b = b->next()) {
|
||||
assert(b->count() >= 0, err_msg("bucket count: %d", b->count()));
|
||||
assert(b->count() != 0, "empty buckets need to be cleaned");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
//
|
||||
// Add an nmethodBucket to the list of dependencies for this nmethod.
|
||||
@ -1866,13 +1907,10 @@ void InstanceKlass::remove_dependent_nmethod(nmethod* nm) {
|
||||
nmethodBucket* last = NULL;
|
||||
while (b != NULL) {
|
||||
if (nm == b->get_nmethod()) {
|
||||
if (b->decrement() == 0) {
|
||||
if (last == NULL) {
|
||||
_dependencies = b->next();
|
||||
} else {
|
||||
last->set_next(b->next());
|
||||
}
|
||||
delete b;
|
||||
int val = b->decrement();
|
||||
guarantee(val >= 0, err_msg("Underflow: %d", val));
|
||||
if (val == 0) {
|
||||
set_has_unloaded_dependent(true);
|
||||
}
|
||||
return;
|
||||
}
|
||||
@ -1911,6 +1949,11 @@ bool InstanceKlass::is_dependent_nmethod(nmethod* nm) {
|
||||
nmethodBucket* b = _dependencies;
|
||||
while (b != NULL) {
|
||||
if (nm == b->get_nmethod()) {
|
||||
#ifdef ASSERT
|
||||
int count = b->count();
|
||||
assert(count >= 0, "Just check if we ever get here 1");
|
||||
assert(count > 0, "Just check if we ever get here 2");
|
||||
#endif
|
||||
return true;
|
||||
}
|
||||
b = b->next();
|
||||
@ -2209,7 +2252,7 @@ int InstanceKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
|
||||
#endif // INCLUDE_ALL_GCS
|
||||
|
||||
void InstanceKlass::clean_implementors_list(BoolObjectClosure* is_alive) {
|
||||
assert(is_loader_alive(is_alive), "this klass should be live");
|
||||
assert(class_loader_data()->is_alive(is_alive), "this klass should be live");
|
||||
if (is_interface()) {
|
||||
if (ClassUnloading) {
|
||||
Klass* impl = implementor();
|
||||
|
@ -197,6 +197,7 @@ class InstanceKlass: public Klass {
|
||||
// _is_marked_dependent can be set concurrently, thus cannot be part of the
|
||||
// _misc_flags.
|
||||
bool _is_marked_dependent; // used for marking during flushing and deoptimization
|
||||
bool _has_unloaded_dependent;
|
||||
|
||||
enum {
|
||||
_misc_rewritten = 1 << 0, // methods rewritten.
|
||||
@ -444,6 +445,9 @@ class InstanceKlass: public Klass {
|
||||
bool is_marked_dependent() const { return _is_marked_dependent; }
|
||||
void set_is_marked_dependent(bool value) { _is_marked_dependent = value; }
|
||||
|
||||
bool has_unloaded_dependent() const { return _has_unloaded_dependent; }
|
||||
void set_has_unloaded_dependent(bool value) { _has_unloaded_dependent = value; }
|
||||
|
||||
// initialization (virtuals from Klass)
|
||||
bool should_be_initialized() const; // means that initialize should be called
|
||||
void initialize(TRAPS);
|
||||
@ -922,6 +926,7 @@ class InstanceKlass: public Klass {
|
||||
|
||||
void clean_implementors_list(BoolObjectClosure* is_alive);
|
||||
void clean_method_data(BoolObjectClosure* is_alive);
|
||||
void clean_dependent_nmethods();
|
||||
|
||||
// Explicit metaspace deallocation of fields
|
||||
// For RedefineClasses and class file parsing errors, we need to deallocate
|
||||
@ -1210,7 +1215,7 @@ class nmethodBucket: public CHeapObj<mtClass> {
|
||||
}
|
||||
int count() { return _count; }
|
||||
int increment() { _count += 1; return _count; }
|
||||
int decrement() { _count -= 1; assert(_count >= 0, "don't underflow"); return _count; }
|
||||
int decrement();
|
||||
nmethodBucket* next() { return _next; }
|
||||
void set_next(nmethodBucket* b) { _next = b; }
|
||||
nmethod* get_nmethod() { return _nmethod; }
|
||||
|
@ -42,6 +42,7 @@
|
||||
#include "utilities/stack.hpp"
|
||||
#include "utilities/macros.hpp"
|
||||
#if INCLUDE_ALL_GCS
|
||||
#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
|
||||
#include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
|
||||
#include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
|
||||
#include "gc_implementation/parallelScavenge/psScavenge.hpp"
|
||||
@ -159,7 +160,12 @@ Klass::Klass() {
|
||||
_primary_supers[0] = k;
|
||||
set_super_check_offset(in_bytes(primary_supers_offset()));
|
||||
|
||||
set_java_mirror(NULL);
|
||||
// The constructor is used from init_self_patching_vtbl_list,
|
||||
// which doesn't zero out the memory before calling the constructor.
|
||||
// Need to set the field explicitly to not hit an assert that the field
|
||||
// should be NULL before setting it.
|
||||
_java_mirror = NULL;
|
||||
|
||||
set_modifier_flags(0);
|
||||
set_layout_helper(Klass::_lh_neutral_value);
|
||||
set_name(NULL);
|
||||
@ -383,7 +389,7 @@ bool Klass::is_loader_alive(BoolObjectClosure* is_alive) {
|
||||
return mirror_alive;
|
||||
}
|
||||
|
||||
void Klass::clean_weak_klass_links(BoolObjectClosure* is_alive) {
|
||||
void Klass::clean_weak_klass_links(BoolObjectClosure* is_alive, bool clean_alive_klasses) {
|
||||
if (!ClassUnloading) {
|
||||
return;
|
||||
}
|
||||
@ -428,7 +434,7 @@ void Klass::clean_weak_klass_links(BoolObjectClosure* is_alive) {
|
||||
}
|
||||
|
||||
// Clean the implementors list and method data.
|
||||
if (current->oop_is_instance()) {
|
||||
if (clean_alive_klasses && current->oop_is_instance()) {
|
||||
InstanceKlass* ik = InstanceKlass::cast(current);
|
||||
ik->clean_implementors_list(is_alive);
|
||||
ik->clean_method_data(is_alive);
|
||||
@ -440,12 +446,18 @@ void Klass::klass_update_barrier_set(oop v) {
|
||||
record_modified_oops();
|
||||
}
|
||||
|
||||
void Klass::klass_update_barrier_set_pre(void* p, oop v) {
|
||||
// This barrier used by G1, where it's used remember the old oop values,
|
||||
// so that we don't forget any objects that were live at the snapshot at
|
||||
// the beginning. This function is only used when we write oops into
|
||||
// Klasses. Since the Klasses are used as roots in G1, we don't have to
|
||||
// do anything here.
|
||||
// This barrier is used by G1 to remember the old oop values, so
|
||||
// that we don't forget any objects that were live at the snapshot at
|
||||
// the beginning. This function is only used when we write oops into Klasses.
|
||||
void Klass::klass_update_barrier_set_pre(oop* p, oop v) {
|
||||
#if INCLUDE_ALL_GCS
|
||||
if (UseG1GC) {
|
||||
oop obj = *p;
|
||||
if (obj != NULL) {
|
||||
G1SATBCardTableModRefBS::enqueue(obj);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void Klass::klass_oop_store(oop* p, oop v) {
|
||||
@ -456,7 +468,7 @@ void Klass::klass_oop_store(oop* p, oop v) {
|
||||
if (always_do_update_barrier) {
|
||||
klass_oop_store((volatile oop*)p, v);
|
||||
} else {
|
||||
klass_update_barrier_set_pre((void*)p, v);
|
||||
klass_update_barrier_set_pre(p, v);
|
||||
*p = v;
|
||||
klass_update_barrier_set(v);
|
||||
}
|
||||
@ -466,7 +478,7 @@ void Klass::klass_oop_store(volatile oop* p, oop v) {
|
||||
assert(!Universe::heap()->is_in_reserved((void*)p), "Should store pointer into metadata");
|
||||
assert(v == NULL || Universe::heap()->is_in_reserved((void*)v), "Should store pointer to an object");
|
||||
|
||||
klass_update_barrier_set_pre((void*)p, v);
|
||||
klass_update_barrier_set_pre((oop*)p, v); // Cast away volatile.
|
||||
OrderAccess::release_store_ptr(p, v);
|
||||
klass_update_barrier_set(v);
|
||||
}
|
||||
|
@ -553,7 +553,10 @@ class Klass : public Metadata {
|
||||
// The is_alive closure passed in depends on the Garbage Collector used.
|
||||
bool is_loader_alive(BoolObjectClosure* is_alive);
|
||||
|
||||
static void clean_weak_klass_links(BoolObjectClosure* is_alive);
|
||||
static void clean_weak_klass_links(BoolObjectClosure* is_alive, bool clean_alive_klasses = true);
|
||||
static void clean_subklass_tree(BoolObjectClosure* is_alive) {
|
||||
clean_weak_klass_links(is_alive, false /* clean_alive_klasses */);
|
||||
}
|
||||
|
||||
// iterators
|
||||
virtual int oop_oop_iterate(oop obj, ExtendedOopClosure* blk) = 0;
|
||||
@ -660,7 +663,7 @@ class Klass : public Metadata {
|
||||
private:
|
||||
// barriers used by klass_oop_store
|
||||
void klass_update_barrier_set(oop v);
|
||||
void klass_update_barrier_set_pre(void* p, oop v);
|
||||
void klass_update_barrier_set_pre(oop* p, oop v);
|
||||
};
|
||||
|
||||
#endif // SHARE_VM_OOPS_KLASS_HPP
|
||||
|
@ -3019,7 +3019,7 @@ inline bool VM_HeapWalkOperation::collect_simple_roots() {
|
||||
|
||||
// If there are any non-perm roots in the code cache, visit them.
|
||||
blk.set_kind(JVMTI_HEAP_REFERENCE_OTHER);
|
||||
CodeBlobToOopClosure look_in_blobs(&blk, false);
|
||||
CodeBlobToOopClosure look_in_blobs(&blk, !CodeBlobToOopClosure::FixRelocations);
|
||||
CodeCache::scavenge_root_nmethods_do(&look_in_blobs);
|
||||
|
||||
return true;
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user