--- a/src/share/vm/classfile/classFileParser.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/classfile/classFileParser.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -766,16 +766,16 @@ enum FieldAllocationType {
struct FieldAllocationCount {
- int static_oop_count;
- int static_byte_count;
- int static_short_count;
- int static_word_count;
- int static_double_count;
- int nonstatic_oop_count;
- int nonstatic_byte_count;
- int nonstatic_short_count;
- int nonstatic_word_count;
- int nonstatic_double_count;
+ unsigned int static_oop_count;
+ unsigned int static_byte_count;
+ unsigned int static_short_count;
+ unsigned int static_word_count;
+ unsigned int static_double_count;
+ unsigned int nonstatic_oop_count;
+ unsigned int nonstatic_byte_count;
+ unsigned int nonstatic_short_count;
+ unsigned int nonstatic_word_count;
+ unsigned int nonstatic_double_count;
};
typeArrayHandle ClassFileParser::parse_fields(constantPoolHandle cp, bool is_interface,
@@ -2908,11 +2908,11 @@ instanceKlassHandle ClassFileParser::par
}
// end of "discovered" field compactibility fix
- int nonstatic_double_count = fac.nonstatic_double_count;
- int nonstatic_word_count = fac.nonstatic_word_count;
- int nonstatic_short_count = fac.nonstatic_short_count;
- int nonstatic_byte_count = fac.nonstatic_byte_count;
- int nonstatic_oop_count = fac.nonstatic_oop_count;
+ unsigned int nonstatic_double_count = fac.nonstatic_double_count;
+ unsigned int nonstatic_word_count = fac.nonstatic_word_count;
+ unsigned int nonstatic_short_count = fac.nonstatic_short_count;
+ unsigned int nonstatic_byte_count = fac.nonstatic_byte_count;
+ unsigned int nonstatic_oop_count = fac.nonstatic_oop_count;
bool super_has_nonstatic_fields =
(super_klass() != NULL && super_klass->has_nonstatic_fields());
@@ -2922,26 +2922,26 @@ instanceKlassHandle ClassFileParser::par
nonstatic_oop_count) != 0);
- // Prepare list of oops for oop maps generation.
- u2* nonstatic_oop_offsets;
- u2* nonstatic_oop_length;
- int nonstatic_oop_map_count = 0;
+ // Prepare list of oops for oop map generation.
+ int* nonstatic_oop_offsets;
+ unsigned int* nonstatic_oop_counts;
+ unsigned int nonstatic_oop_map_count = 0;
nonstatic_oop_offsets = NEW_RESOURCE_ARRAY_IN_THREAD(
- THREAD, u2, nonstatic_oop_count+1);
- nonstatic_oop_length = NEW_RESOURCE_ARRAY_IN_THREAD(
- THREAD, u2, nonstatic_oop_count+1);
+ THREAD, int, nonstatic_oop_count + 1);
+ nonstatic_oop_counts = NEW_RESOURCE_ARRAY_IN_THREAD(
+ THREAD, unsigned int, nonstatic_oop_count + 1);
// Add fake fields for java.lang.Class instances (also see above).
// FieldsAllocationStyle and CompactFields values will be reset to default.
if(class_name() == vmSymbols::java_lang_Class() && class_loader.is_null()) {
java_lang_Class_fix_post(&next_nonstatic_field_offset);
- nonstatic_oop_offsets[0] = (u2)first_nonstatic_field_offset;
- int fake_oop_count = (( next_nonstatic_field_offset -
- first_nonstatic_field_offset ) / heapOopSize);
- nonstatic_oop_length [0] = (u2)fake_oop_count;
- nonstatic_oop_map_count = 1;
- nonstatic_oop_count -= fake_oop_count;
+ nonstatic_oop_offsets[0] = first_nonstatic_field_offset;
+ const uint fake_oop_count = (next_nonstatic_field_offset -
+ first_nonstatic_field_offset) / heapOopSize;
+ nonstatic_oop_counts[0] = fake_oop_count;
+ nonstatic_oop_map_count = 1;
+ nonstatic_oop_count -= fake_oop_count;
first_nonstatic_oop_offset = first_nonstatic_field_offset;
} else {
first_nonstatic_oop_offset = 0; // will be set for first oop field
@@ -3119,13 +3119,15 @@ instanceKlassHandle ClassFileParser::par
// Update oop maps
if( nonstatic_oop_map_count > 0 &&
nonstatic_oop_offsets[nonstatic_oop_map_count - 1] ==
- (u2)(real_offset - nonstatic_oop_length[nonstatic_oop_map_count - 1] * heapOopSize) ) {
+ real_offset -
+ int(nonstatic_oop_counts[nonstatic_oop_map_count - 1]) *
+ heapOopSize ) {
// Extend current oop map
- nonstatic_oop_length[nonstatic_oop_map_count - 1] += 1;
+ nonstatic_oop_counts[nonstatic_oop_map_count - 1] += 1;
} else {
// Create new oop map
- nonstatic_oop_offsets[nonstatic_oop_map_count] = (u2)real_offset;
- nonstatic_oop_length [nonstatic_oop_map_count] = 1;
+ nonstatic_oop_offsets[nonstatic_oop_map_count] = real_offset;
+ nonstatic_oop_counts [nonstatic_oop_map_count] = 1;
nonstatic_oop_map_count += 1;
if( first_nonstatic_oop_offset == 0 ) { // Undefined
first_nonstatic_oop_offset = real_offset;
@@ -3182,8 +3184,10 @@ instanceKlassHandle ClassFileParser::par
assert(instance_size == align_object_size(align_size_up((instanceOopDesc::base_offset_in_bytes() + nonstatic_field_size*heapOopSize), wordSize) / wordSize), "consistent layout helper value");
- // Size of non-static oop map blocks (in words) allocated at end of klass
- int nonstatic_oop_map_size = compute_oop_map_size(super_klass, nonstatic_oop_map_count, first_nonstatic_oop_offset);
+ // Number of non-static oop map blocks allocated at end of klass.
+ const unsigned int total_oop_map_count =
+ compute_oop_map_count(super_klass, nonstatic_oop_map_count,
+ first_nonstatic_oop_offset);
// Compute reference type
ReferenceType rt;
@@ -3194,14 +3198,15 @@ instanceKlassHandle ClassFileParser::par
}
// We can now create the basic klassOop for this klass
- klassOop ik = oopFactory::new_instanceKlass(
- vtable_size, itable_size,
- static_field_size, nonstatic_oop_map_size,
- rt, CHECK_(nullHandle));
+ klassOop ik = oopFactory::new_instanceKlass(vtable_size, itable_size,
+ static_field_size,
+ total_oop_map_count,
+ rt, CHECK_(nullHandle));
instanceKlassHandle this_klass (THREAD, ik);
- assert(this_klass->static_field_size() == static_field_size &&
- this_klass->nonstatic_oop_map_size() == nonstatic_oop_map_size, "sanity check");
+ assert(this_klass->static_field_size() == static_field_size, "sanity");
+ assert(this_klass->nonstatic_oop_map_count() == total_oop_map_count,
+ "sanity");
// Fill in information already parsed
this_klass->set_access_flags(access_flags);
@@ -3282,7 +3287,7 @@ instanceKlassHandle ClassFileParser::par
klassItable::setup_itable_offset_table(this_klass);
// Do final class setup
- fill_oop_maps(this_klass, nonstatic_oop_map_count, nonstatic_oop_offsets, nonstatic_oop_length);
+ fill_oop_maps(this_klass, nonstatic_oop_map_count, nonstatic_oop_offsets, nonstatic_oop_counts);
set_precomputed_flags(this_klass);
@@ -3375,66 +3380,73 @@ instanceKlassHandle ClassFileParser::par
}
-int ClassFileParser::compute_oop_map_size(instanceKlassHandle super, int nonstatic_oop_map_count, int first_nonstatic_oop_offset) {
- int map_size = super.is_null() ? 0 : super->nonstatic_oop_map_size();
+unsigned int
+ClassFileParser::compute_oop_map_count(instanceKlassHandle super,
+ unsigned int nonstatic_oop_map_count,
+ int first_nonstatic_oop_offset) {
+ unsigned int map_count =
+ super.is_null() ? 0 : super->nonstatic_oop_map_count();
if (nonstatic_oop_map_count > 0) {
// We have oops to add to map
- if (map_size == 0) {
- map_size = nonstatic_oop_map_count;
+ if (map_count == 0) {
+ map_count = nonstatic_oop_map_count;
} else {
- // Check whether we should add a new map block or whether the last one can be extended
- OopMapBlock* first_map = super->start_of_nonstatic_oop_maps();
- OopMapBlock* last_map = first_map + map_size - 1;
-
- int next_offset = last_map->offset() + (last_map->length() * heapOopSize);
+ // Check whether we should add a new map block or whether the last one can
+ // be extended
+ OopMapBlock* const first_map = super->start_of_nonstatic_oop_maps();
+ OopMapBlock* const last_map = first_map + map_count - 1;
+
+ int next_offset = last_map->offset() + last_map->count() * heapOopSize;
if (next_offset == first_nonstatic_oop_offset) {
// There is no gap bettwen superklass's last oop field and first
// local oop field, merge maps.
nonstatic_oop_map_count -= 1;
} else {
// Superklass didn't end with a oop field, add extra maps
- assert(next_offset<first_nonstatic_oop_offset, "just checking");
- }
- map_size += nonstatic_oop_map_count;
- }
- }
- return map_size;
+ assert(next_offset < first_nonstatic_oop_offset, "just checking");
+ }
+ map_count += nonstatic_oop_map_count;
+ }
+ }
+ return map_count;
}
void ClassFileParser::fill_oop_maps(instanceKlassHandle k,
- int nonstatic_oop_map_count,
- u2* nonstatic_oop_offsets, u2* nonstatic_oop_length) {
+ unsigned int nonstatic_oop_map_count,
+ int* nonstatic_oop_offsets,
+ unsigned int* nonstatic_oop_counts) {
OopMapBlock* this_oop_map = k->start_of_nonstatic_oop_maps();
- OopMapBlock* last_oop_map = this_oop_map + k->nonstatic_oop_map_size();
- instanceKlass* super = k->superklass();
- if (super != NULL) {
- int super_oop_map_size = super->nonstatic_oop_map_size();
+ const instanceKlass* const super = k->superklass();
+ const unsigned int super_count = super ? super->nonstatic_oop_map_count() : 0;
+ if (super_count > 0) {
+ // Copy maps from superklass
OopMapBlock* super_oop_map = super->start_of_nonstatic_oop_maps();
- // Copy maps from superklass
- while (super_oop_map_size-- > 0) {
+ for (unsigned int i = 0; i < super_count; ++i) {
*this_oop_map++ = *super_oop_map++;
}
}
+
if (nonstatic_oop_map_count > 0) {
- if (this_oop_map + nonstatic_oop_map_count > last_oop_map) {
- // Calculated in compute_oop_map_size() number of oop maps is less then
- // collected oop maps since there is no gap between superklass's last oop
- // field and first local oop field. Extend the last oop map copied
+ if (super_count + nonstatic_oop_map_count > k->nonstatic_oop_map_count()) {
+ // The counts differ because there is no gap between superklass's last oop
+ // field and the first local oop field. Extend the last oop map copied
// from the superklass instead of creating new one.
nonstatic_oop_map_count--;
nonstatic_oop_offsets++;
this_oop_map--;
- this_oop_map->set_length(this_oop_map->length() + *nonstatic_oop_length++);
+ this_oop_map->set_count(this_oop_map->count() + *nonstatic_oop_counts++);
this_oop_map++;
}
- assert((this_oop_map + nonstatic_oop_map_count) == last_oop_map, "just checking");
+
// Add new map blocks, fill them
while (nonstatic_oop_map_count-- > 0) {
this_oop_map->set_offset(*nonstatic_oop_offsets++);
- this_oop_map->set_length(*nonstatic_oop_length++);
+ this_oop_map->set_count(*nonstatic_oop_counts++);
this_oop_map++;
}
+ assert(k->start_of_nonstatic_oop_maps() + k->nonstatic_oop_map_count() ==
+ this_oop_map, "sanity");
}
}
--- a/src/share/vm/classfile/classFileParser.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/classfile/classFileParser.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -125,10 +125,13 @@ class ClassFileParser VALUE_OBJ_CLASS_SP
int runtime_invisible_annotations_length, TRAPS);
// Final setup
- int compute_oop_map_size(instanceKlassHandle super, int nonstatic_oop_count,
- int first_nonstatic_oop_offset);
- void fill_oop_maps(instanceKlassHandle k, int nonstatic_oop_map_count,
- u2* nonstatic_oop_offsets, u2* nonstatic_oop_length);
+ unsigned int compute_oop_map_count(instanceKlassHandle super,
+ unsigned int nonstatic_oop_count,
+ int first_nonstatic_oop_offset);
+ void fill_oop_maps(instanceKlassHandle k,
+ unsigned int nonstatic_oop_map_count,
+ int* nonstatic_oop_offsets,
+ unsigned int* nonstatic_oop_counts);
void set_precomputed_flags(instanceKlassHandle k);
objArrayHandle compute_transitive_interfaces(instanceKlassHandle super,
objArrayHandle local_ifs, TRAPS);
--- a/src/share/vm/code/nmethod.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/code/nmethod.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -1079,6 +1079,10 @@ void nmethod::make_unloaded(BoolObjectCl
this, (address)_method, (address)cause);
cause->klass()->print();
}
+ // Unlink the osr method, so we do not look this up again
+ if (is_osr_method()) {
+ invalidate_osr_method();
+ }
// If _method is already NULL the methodOop is about to be unloaded,
// so we don't have to break the cycle. Note that it is possible to
// have the methodOop live here, in case we unload the nmethod because
@@ -1148,7 +1152,7 @@ void nmethod::make_not_entrant_or_zombie
// will never be used anymore. That the nmethods only gets removed when class unloading
// happens, make life much simpler, since the nmethods are not just going to disappear
// out of the blue.
- if (is_osr_only_method()) {
+ if (is_osr_method()) {
if (osr_entry_bci() != InvalidOSREntryBci) {
// only log this once
log_state_change(state);
@@ -1520,6 +1524,17 @@ void nmethod::do_unloading(BoolObjectClo
#endif // !PRODUCT
}
+// This method is called twice during GC -- once while
+// tracing the "active" nmethods on thread stacks during
+// the (strong) marking phase, and then again when walking
+// the code cache contents during the weak roots processing
+// phase. The two uses are distinguished by means of the
+// do_nmethods() method in the closure "f" below -- which
+// answers "yes" in the first case, and "no" in the second
+// case. We want to walk the weak roots in the nmethod
+// only in the second case. The weak roots in the nmethod
+// are the oops in the ExceptionCache and the InlineCache
+// oops.
void nmethod::oops_do(OopClosure* f) {
// make sure the oops ready to receive visitors
assert(!is_zombie() && !is_unloaded(),
@@ -1538,19 +1553,25 @@ void nmethod::oops_do(OopClosure* f) {
// Compiled code
f->do_oop((oop*) &_method);
- ExceptionCache* ec = exception_cache();
- while(ec != NULL) {
- f->do_oop((oop*)ec->exception_type_addr());
- ec = ec->next();
- }
+ if (!f->do_nmethods()) {
+ // weak roots processing phase -- update ExceptionCache oops
+ ExceptionCache* ec = exception_cache();
+ while(ec != NULL) {
+ f->do_oop((oop*)ec->exception_type_addr());
+ ec = ec->next();
+ }
+ } // Else strong roots phase -- skip oops in ExceptionCache
RelocIterator iter(this, low_boundary);
+
while (iter.next()) {
if (iter.type() == relocInfo::oop_type ) {
oop_Relocation* r = iter.oop_reloc();
// In this loop, we must only follow 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");
+ 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) {
f->do_oop(r->oop_addr());
}
--- a/src/share/vm/code/nmethod.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/code/nmethod.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -314,7 +314,6 @@ class nmethod : public CodeBlob {
bool is_java_method() const { return !method()->is_native(); }
bool is_native_method() const { return method()->is_native(); }
bool is_osr_method() const { return _entry_bci != InvocationEntryBci; }
- bool is_osr_only_method() const { return is_osr_method(); }
bool is_compiled_by_c1() const;
bool is_compiled_by_c2() const;
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -92,17 +92,50 @@ class MarkRefsIntoVerifyClosure: public
}
};
+// KlassRememberingOopClosure is used when marking of the permanent generation
+// is being done. It adds fields to support revisiting of klasses
+// for class unloading. _should_remember_klasses should be set to
+// indicate if klasses should be remembered. Currently that is whenever
+// CMS class unloading is turned on. The _revisit_stack is used
+// to save the klasses for later processing.
+class KlassRememberingOopClosure : public OopClosure {
+ protected:
+ CMSCollector* _collector;
+ CMSMarkStack* _revisit_stack;
+ bool const _should_remember_klasses;
+ public:
+ void check_remember_klasses() const PRODUCT_RETURN;
+ virtual const bool should_remember_klasses() const {
+ check_remember_klasses();
+ return _should_remember_klasses;
+ }
+ virtual void remember_klass(Klass* k);
+
+ KlassRememberingOopClosure(CMSCollector* collector,
+ ReferenceProcessor* rp,
+ CMSMarkStack* revisit_stack);
+};
+
+// Similar to KlassRememberingOopClosure for use when multiple
+// GC threads will execute the closure.
+
+class Par_KlassRememberingOopClosure : public KlassRememberingOopClosure {
+ public:
+ Par_KlassRememberingOopClosure(CMSCollector* collector,
+ ReferenceProcessor* rp,
+ CMSMarkStack* revisit_stack):
+ KlassRememberingOopClosure(collector, rp, revisit_stack) {}
+ virtual void remember_klass(Klass* k);
+};
+
// The non-parallel version (the parallel version appears further below).
-class PushAndMarkClosure: public OopClosure {
- private:
- CMSCollector* _collector;
+class PushAndMarkClosure: public KlassRememberingOopClosure {
+ private:
MemRegion _span;
CMSBitMap* _bit_map;
CMSBitMap* _mod_union_table;
CMSMarkStack* _mark_stack;
- CMSMarkStack* _revisit_stack;
bool _concurrent_precleaning;
- bool const _should_remember_klasses;
protected:
DO_OOP_WORK_DEFN
public:
@@ -122,10 +155,12 @@ class PushAndMarkClosure: public OopClos
Prefetch::style prefetch_style() {
return Prefetch::do_read;
}
- virtual const bool should_remember_klasses() const {
- return _should_remember_klasses;
- }
- virtual void remember_klass(Klass* k);
+ // In support of class unloading
+ virtual const bool should_remember_mdo() const {
+ return false;
+ // return _should_remember_klasses;
+ }
+ virtual void remember_mdo(DataLayout* v);
};
// In the parallel case, the revisit stack, the bit map and the
@@ -134,14 +169,11 @@ class PushAndMarkClosure: public OopClos
// synchronization (for instance, via CAS). The marking stack
// used in the non-parallel case above is here replaced with
// an OopTaskQueue structure to allow efficient work stealing.
-class Par_PushAndMarkClosure: public OopClosure {
- private:
- CMSCollector* _collector;
+class Par_PushAndMarkClosure: public Par_KlassRememberingOopClosure {
+ private:
MemRegion _span;
CMSBitMap* _bit_map;
OopTaskQueue* _work_queue;
- CMSMarkStack* _revisit_stack;
- bool const _should_remember_klasses;
protected:
DO_OOP_WORK_DEFN
public:
@@ -159,10 +191,12 @@ class Par_PushAndMarkClosure: public Oop
Prefetch::style prefetch_style() {
return Prefetch::do_read;
}
- virtual const bool should_remember_klasses() const {
- return _should_remember_klasses;
- }
- virtual void remember_klass(Klass* k);
+ // In support of class unloading
+ virtual const bool should_remember_mdo() const {
+ return false;
+ // return _should_remember_klasses;
+ }
+ virtual void remember_mdo(DataLayout* v);
};
// The non-parallel version (the parallel version appears further below).
@@ -201,6 +235,12 @@ class MarkRefsIntoAndScanClosure: public
void set_freelistLock(Mutex* m) {
_freelistLock = m;
}
+ virtual const bool should_remember_klasses() const {
+ return _pushAndMarkClosure.should_remember_klasses();
+ }
+ virtual void remember_klass(Klass* k) {
+ _pushAndMarkClosure.remember_klass(k);
+ }
private:
inline void do_yield_check();
@@ -234,6 +274,16 @@ class Par_MarkRefsIntoAndScanClosure: pu
inline void do_oop_nv(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); }
bool do_header() { return true; }
virtual const bool do_nmethods() const { return true; }
+ // When ScanMarkedObjectsAgainClosure is used,
+ // it passes [Par_]MarkRefsIntoAndScanClosure to oop_oop_iterate(),
+ // and this delegation is used.
+ virtual const bool should_remember_klasses() const {
+ return _par_pushAndMarkClosure.should_remember_klasses();
+ }
+ // See comment on should_remember_klasses() above.
+ virtual void remember_klass(Klass* k) {
+ _par_pushAndMarkClosure.remember_klass(k);
+ }
Prefetch::style prefetch_style() {
return Prefetch::do_read;
}
@@ -243,17 +293,14 @@ class Par_MarkRefsIntoAndScanClosure: pu
// This closure is used during the concurrent marking phase
// following the first checkpoint. Its use is buried in
// the closure MarkFromRootsClosure.
-class PushOrMarkClosure: public OopClosure {
- private:
- CMSCollector* _collector;
+class PushOrMarkClosure: public KlassRememberingOopClosure {
+ private:
MemRegion _span;
CMSBitMap* _bitMap;
CMSMarkStack* _markStack;
- CMSMarkStack* _revisitStack;
HeapWord* const _finger;
MarkFromRootsClosure* const
_parent;
- bool const _should_remember_klasses;
protected:
DO_OOP_WORK_DEFN
public:
@@ -268,10 +315,13 @@ class PushOrMarkClosure: public OopClosu
virtual void do_oop(narrowOop* p);
inline void do_oop_nv(oop* p) { PushOrMarkClosure::do_oop_work(p); }
inline void do_oop_nv(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); }
- virtual const bool should_remember_klasses() const {
- return _should_remember_klasses;
- }
- virtual void remember_klass(Klass* k);
+ // In support of class unloading
+ virtual const bool should_remember_mdo() const {
+ return false;
+ // return _should_remember_klasses;
+ }
+ virtual void remember_mdo(DataLayout* v);
+
// Deal with a stack overflow condition
void handle_stack_overflow(HeapWord* lost);
private:
@@ -282,20 +332,17 @@ class PushOrMarkClosure: public OopClosu
// This closure is used during the concurrent marking phase
// following the first checkpoint. Its use is buried in
// the closure Par_MarkFromRootsClosure.
-class Par_PushOrMarkClosure: public OopClosure {
- private:
- CMSCollector* _collector;
+class Par_PushOrMarkClosure: public Par_KlassRememberingOopClosure {
+ private:
MemRegion _whole_span;
MemRegion _span; // local chunk
CMSBitMap* _bit_map;
OopTaskQueue* _work_queue;
CMSMarkStack* _overflow_stack;
- CMSMarkStack* _revisit_stack;
HeapWord* const _finger;
HeapWord** const _global_finger_addr;
Par_MarkFromRootsClosure* const
_parent;
- bool const _should_remember_klasses;
protected:
DO_OOP_WORK_DEFN
public:
@@ -312,10 +359,13 @@ class Par_PushOrMarkClosure: public OopC
virtual void do_oop(narrowOop* p);
inline void do_oop_nv(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
inline void do_oop_nv(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
- virtual const bool should_remember_klasses() const {
- return _should_remember_klasses;
- }
- virtual void remember_klass(Klass* k);
+ // In support of class unloading
+ virtual const bool should_remember_mdo() const {
+ return false;
+ // return _should_remember_klasses;
+ }
+ virtual void remember_mdo(DataLayout* v);
+
// Deal with a stack overflow condition
void handle_stack_overflow(HeapWord* lost);
private:
@@ -328,9 +378,8 @@ class Par_PushOrMarkClosure: public OopC
// processing phase of the CMS final checkpoint step, as
// well as during the concurrent precleaning of the discovered
// reference lists.
-class CMSKeepAliveClosure: public OopClosure {
- private:
- CMSCollector* _collector;
+class CMSKeepAliveClosure: public KlassRememberingOopClosure {
+ private:
const MemRegion _span;
CMSMarkStack* _mark_stack;
CMSBitMap* _bit_map;
@@ -340,14 +389,7 @@ class CMSKeepAliveClosure: public OopClo
public:
CMSKeepAliveClosure(CMSCollector* collector, MemRegion span,
CMSBitMap* bit_map, CMSMarkStack* mark_stack,
- bool cpc):
- _collector(collector),
- _span(span),
- _bit_map(bit_map),
- _mark_stack(mark_stack),
- _concurrent_precleaning(cpc) {
- assert(!_span.is_empty(), "Empty span could spell trouble");
- }
+ CMSMarkStack* revisit_stack, bool cpc);
bool concurrent_precleaning() const { return _concurrent_precleaning; }
virtual void do_oop(oop* p);
virtual void do_oop(narrowOop* p);
@@ -355,9 +397,8 @@ class CMSKeepAliveClosure: public OopClo
inline void do_oop_nv(narrowOop* p) { CMSKeepAliveClosure::do_oop_work(p); }
};
-class CMSInnerParMarkAndPushClosure: public OopClosure {
- private:
- CMSCollector* _collector;
+class CMSInnerParMarkAndPushClosure: public Par_KlassRememberingOopClosure {
+ private:
MemRegion _span;
OopTaskQueue* _work_queue;
CMSBitMap* _bit_map;
@@ -366,11 +407,8 @@ class CMSInnerParMarkAndPushClosure: pub
public:
CMSInnerParMarkAndPushClosure(CMSCollector* collector,
MemRegion span, CMSBitMap* bit_map,
- OopTaskQueue* work_queue):
- _collector(collector),
- _span(span),
- _bit_map(bit_map),
- _work_queue(work_queue) { }
+ CMSMarkStack* revisit_stack,
+ OopTaskQueue* work_queue);
virtual void do_oop(oop* p);
virtual void do_oop(narrowOop* p);
inline void do_oop_nv(oop* p) { CMSInnerParMarkAndPushClosure::do_oop_work(p); }
@@ -380,9 +418,8 @@ class CMSInnerParMarkAndPushClosure: pub
// A parallel (MT) version of the above, used when
// reference processing is parallel; the only difference
// is in the do_oop method.
-class CMSParKeepAliveClosure: public OopClosure {
- private:
- CMSCollector* _collector;
+class CMSParKeepAliveClosure: public Par_KlassRememberingOopClosure {
+ private:
MemRegion _span;
OopTaskQueue* _work_queue;
CMSBitMap* _bit_map;
@@ -394,7 +431,8 @@ class CMSParKeepAliveClosure: public Oop
DO_OOP_WORK_DEFN
public:
CMSParKeepAliveClosure(CMSCollector* collector, MemRegion span,
- CMSBitMap* bit_map, OopTaskQueue* work_queue);
+ CMSBitMap* bit_map, CMSMarkStack* revisit_stack,
+ OopTaskQueue* work_queue);
virtual void do_oop(oop* p);
virtual void do_oop(narrowOop* p);
inline void do_oop_nv(oop* p) { CMSParKeepAliveClosure::do_oop_work(p); }
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -37,16 +37,34 @@ inline void Par_MarkRefsIntoAndScanClosu
}
}
-inline void PushOrMarkClosure::remember_klass(Klass* k) {
- if (!_revisitStack->push(oop(k))) {
+#ifndef PRODUCT
+void KlassRememberingOopClosure::check_remember_klasses() const {
+ assert(_should_remember_klasses == must_remember_klasses(),
+ "Should remember klasses in this context.");
+}
+#endif
+
+void KlassRememberingOopClosure::remember_klass(Klass* k) {
+ if (!_revisit_stack->push(oop(k))) {
fatal("Revisit stack overflow in PushOrMarkClosure");
}
+ check_remember_klasses();
}
-inline void Par_PushOrMarkClosure::remember_klass(Klass* k) {
+inline void PushOrMarkClosure::remember_mdo(DataLayout* v) {
+ // TBD
+}
+
+
+void Par_KlassRememberingOopClosure::remember_klass(Klass* k) {
if (!_revisit_stack->par_push(oop(k))) {
- fatal("Revisit stack overflow in PushOrMarkClosure");
+ fatal("Revisit stack overflow in Par_KlassRememberingOopClosure");
}
+ check_remember_klasses();
+}
+
+inline void Par_PushOrMarkClosure::remember_mdo(DataLayout* v) {
+ // TBD
}
inline void PushOrMarkClosure::do_yield_check() {
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -2276,7 +2276,7 @@ void CMSCollector::collect_in_background
VM_CMS_Final_Remark final_remark_op(this);
VMThread::execute(&final_remark_op);
- }
+ }
assert(_foregroundGCShouldWait, "block post-condition");
break;
case Sweeping:
@@ -3499,6 +3499,7 @@ void CMSCollector::checkpointRootsInitia
ref_processor()->set_enqueuing_is_done(false);
{
+ // This is not needed. DEBUG_ONLY(RememberKlassesChecker imx(true);)
COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;)
gch->rem_set()->prepare_for_younger_refs_iterate(false); // Not parallel.
gch->gen_process_strong_roots(_cmsGen->level(),
@@ -3622,6 +3623,8 @@ bool CMSCollector::markFromRootsWork(boo
verify_work_stacks_empty();
verify_overflow_empty();
assert(_revisitStack.isEmpty(), "tabula rasa");
+
+ DEBUG_ONLY(RememberKlassesChecker cmx(CMSClassUnloadingEnabled);)
bool result = false;
if (CMSConcurrentMTEnabled && ParallelCMSThreads > 0) {
@@ -3958,24 +3961,24 @@ void CMSConcMarkingTask::do_scan_and_mar
pst->all_tasks_completed();
}
-class Par_ConcMarkingClosure: public OopClosure {
+class Par_ConcMarkingClosure: public Par_KlassRememberingOopClosure {
private:
- CMSCollector* _collector;
MemRegion _span;
CMSBitMap* _bit_map;
CMSMarkStack* _overflow_stack;
- CMSMarkStack* _revisit_stack; // XXXXXX Check proper use
OopTaskQueue* _work_queue;
protected:
DO_OOP_WORK_DEFN
public:
Par_ConcMarkingClosure(CMSCollector* collector, OopTaskQueue* work_queue,
- CMSBitMap* bit_map, CMSMarkStack* overflow_stack):
- _collector(collector),
+ CMSBitMap* bit_map, CMSMarkStack* overflow_stack,
+ CMSMarkStack* revisit_stack):
+ Par_KlassRememberingOopClosure(collector, NULL, revisit_stack),
_span(_collector->_span),
_work_queue(work_queue),
_bit_map(bit_map),
- _overflow_stack(overflow_stack) { } // need to initialize revisit stack etc.
+ _overflow_stack(overflow_stack)
+ { }
virtual void do_oop(oop* p);
virtual void do_oop(narrowOop* p);
void trim_queue(size_t max);
@@ -4063,8 +4066,9 @@ void CMSConcMarkingTask::do_work_steal(i
oop obj_to_scan;
CMSBitMap* bm = &(_collector->_markBitMap);
CMSMarkStack* ovflw = &(_collector->_markStack);
+ CMSMarkStack* revisit = &(_collector->_revisitStack);
int* seed = _collector->hash_seed(i);
- Par_ConcMarkingClosure cl(_collector, work_q, bm, ovflw);
+ Par_ConcMarkingClosure cl(_collector, work_q, bm, ovflw, revisit);
while (true) {
cl.trim_queue(0);
assert(work_q->size() == 0, "Should have been emptied above");
@@ -4089,6 +4093,7 @@ void CMSConcMarkingTask::coordinator_yie
assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
"CMS thread should hold CMS token");
+ DEBUG_ONLY(RememberKlassesChecker mux(false);)
// First give up the locks, then yield, then re-lock
// We should probably use a constructor/destructor idiom to
// do this unlock/lock or modify the MutexUnlocker class to
@@ -4164,6 +4169,8 @@ bool CMSCollector::do_marking_mt(bool as
// Mutate the Refs discovery so it is MT during the
// multi-threaded marking phase.
ReferenceProcessorMTMutator mt(ref_processor(), num_workers > 1);
+
+ DEBUG_ONLY(RememberKlassesChecker cmx(CMSClassUnloadingEnabled);)
conc_workers()->start_task(&tsk);
while (tsk.yielded()) {
@@ -4404,7 +4411,8 @@ size_t CMSCollector::preclean_work(bool
CMSPrecleanRefsYieldClosure yield_cl(this);
assert(rp->span().equals(_span), "Spans should be equal");
CMSKeepAliveClosure keep_alive(this, _span, &_markBitMap,
- &_markStack, true /* preclean */);
+ &_markStack, &_revisitStack,
+ true /* preclean */);
CMSDrainMarkingStackClosure complete_trace(this,
_span, &_markBitMap, &_markStack,
&keep_alive, true /* preclean */);
@@ -4424,6 +4432,7 @@ size_t CMSCollector::preclean_work(bool
bitMapLock());
startTimer();
sample_eden();
+
// The following will yield to allow foreground
// collection to proceed promptly. XXX YSR:
// The code in this method may need further
@@ -4453,6 +4462,7 @@ size_t CMSCollector::preclean_work(bool
SurvivorSpacePrecleanClosure
sss_cl(this, _span, &_markBitMap, &_markStack,
&pam_cl, before_count, CMSYield);
+ DEBUG_ONLY(RememberKlassesChecker mx(CMSClassUnloadingEnabled);)
dng->from()->object_iterate_careful(&sss_cl);
dng->to()->object_iterate_careful(&sss_cl);
}
@@ -4554,6 +4564,13 @@ size_t CMSCollector::preclean_mod_union_
verify_work_stacks_empty();
verify_overflow_empty();
+ // Turn off checking for this method but turn it back on
+ // selectively. There are yield points in this method
+ // but it is difficult to turn the checking off just around
+ // the yield points. It is simpler to selectively turn
+ // it on.
+ DEBUG_ONLY(RememberKlassesChecker mux(false);)
+
// strategy: starting with the first card, accumulate contiguous
// ranges of dirty cards; clear these cards, then scan the region
// covered by these cards.
@@ -4582,6 +4599,7 @@ size_t CMSCollector::preclean_mod_union_
MemRegion dirtyRegion;
{
stopTimer();
+ // Potential yield point
CMSTokenSync ts(true);
startTimer();
sample_eden();
@@ -4607,6 +4625,7 @@ size_t CMSCollector::preclean_mod_union_
assert(numDirtyCards > 0, "consistency check");
HeapWord* stop_point = NULL;
stopTimer();
+ // Potential yield point
CMSTokenSyncWithLocks ts(true, gen->freelistLock(),
bitMapLock());
startTimer();
@@ -4614,6 +4633,7 @@ size_t CMSCollector::preclean_mod_union_
verify_work_stacks_empty();
verify_overflow_empty();
sample_eden();
+ DEBUG_ONLY(RememberKlassesChecker mx(CMSClassUnloadingEnabled);)
stop_point =
gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl);
}
@@ -4701,6 +4721,7 @@ size_t CMSCollector::preclean_card_table
sample_eden();
verify_work_stacks_empty();
verify_overflow_empty();
+ DEBUG_ONLY(RememberKlassesChecker mx(CMSClassUnloadingEnabled);)
HeapWord* stop_point =
gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl);
if (stop_point != NULL) {
@@ -4800,6 +4821,7 @@ void CMSCollector::checkpointRootsFinalW
assert(haveFreelistLocks(), "must have free list locks");
assert_lock_strong(bitMapLock());
+ DEBUG_ONLY(RememberKlassesChecker fmx(CMSClassUnloadingEnabled);)
if (!init_mark_was_synchronous) {
// We might assume that we need not fill TLAB's when
// CMSScavengeBeforeRemark is set, because we may have just done
@@ -4902,6 +4924,9 @@ void CMSCollector::checkpointRootsFinalW
}
_markStack._hit_limit = 0;
_markStack._failed_double = 0;
+
+ // Check that all the klasses have been checked
+ assert(_revisitStack.isEmpty(), "Not all klasses revisited");
if ((VerifyAfterGC || VerifyDuringGC) &&
GenCollectedHeap::heap()->total_collections() >= VerifyGCStartAt) {
@@ -5574,9 +5599,13 @@ void CMSRefProcTaskProxy::work(int i) {
void CMSRefProcTaskProxy::work(int i) {
assert(_collector->_span.equals(_span), "Inconsistency in _span");
CMSParKeepAliveClosure par_keep_alive(_collector, _span,
- _mark_bit_map, work_queue(i));
+ _mark_bit_map,
+ &_collector->_revisitStack,
+ work_queue(i));
CMSParDrainMarkingStackClosure par_drain_stack(_collector, _span,
- _mark_bit_map, work_queue(i));
+ _mark_bit_map,
+ &_collector->_revisitStack,
+ work_queue(i));
CMSIsAliveClosure is_alive_closure(_span, _mark_bit_map);
_task.work(i, is_alive_closure, par_keep_alive, par_drain_stack);
if (_task.marks_oops_alive()) {
@@ -5604,12 +5633,13 @@ public:
};
CMSParKeepAliveClosure::CMSParKeepAliveClosure(CMSCollector* collector,
- MemRegion span, CMSBitMap* bit_map, OopTaskQueue* work_queue):
- _collector(collector),
+ MemRegion span, CMSBitMap* bit_map, CMSMarkStack* revisit_stack,
+ OopTaskQueue* work_queue):
+ Par_KlassRememberingOopClosure(collector, NULL, revisit_stack),
_span(span),
_bit_map(bit_map),
_work_queue(work_queue),
- _mark_and_push(collector, span, bit_map, work_queue),
+ _mark_and_push(collector, span, bit_map, revisit_stack, work_queue),
_low_water_mark(MIN2((uint)(work_queue->max_elems()/4),
(uint)(CMSWorkQueueDrainThreshold * ParallelGCThreads)))
{ }
@@ -5696,7 +5726,8 @@ void CMSCollector::refProcessingWork(boo
verify_work_stacks_empty();
CMSKeepAliveClosure cmsKeepAliveClosure(this, _span, &_markBitMap,
- &_markStack, false /* !preclean */);
+ &_markStack, &_revisitStack,
+ false /* !preclean */);
CMSDrainMarkingStackClosure cmsDrainMarkingStackClosure(this,
_span, &_markBitMap, &_markStack,
&cmsKeepAliveClosure, false /* !preclean */);
@@ -6531,6 +6562,7 @@ void MarkRefsIntoAndScanClosure::do_yiel
assert_lock_strong(_freelistLock);
assert_lock_strong(_bit_map->lock());
// relinquish the free_list_lock and bitMaplock()
+ DEBUG_ONLY(RememberKlassesChecker mux(false);)
_bit_map->lock()->unlock();
_freelistLock->unlock();
ConcurrentMarkSweepThread::desynchronize(true);
@@ -6703,6 +6735,7 @@ void ScanMarkedObjectsAgainCarefullyClos
"CMS thread should hold CMS token");
assert_lock_strong(_freelistLock);
assert_lock_strong(_bitMap->lock());
+ DEBUG_ONLY(RememberKlassesChecker mux(false);)
// relinquish the free_list_lock and bitMaplock()
_bitMap->lock()->unlock();
_freelistLock->unlock();
@@ -6779,6 +6812,7 @@ void SurvivorSpacePrecleanClosure::do_yi
assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
"CMS thread should hold CMS token");
assert_lock_strong(_bit_map->lock());
+ DEBUG_ONLY(RememberKlassesChecker smx(false);)
// Relinquish the bit map lock
_bit_map->lock()->unlock();
ConcurrentMarkSweepThread::desynchronize(true);
@@ -6941,6 +6975,7 @@ void MarkFromRootsClosure::do_yield_work
assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
"CMS thread should hold CMS token");
assert_lock_strong(_bitMap->lock());
+ DEBUG_ONLY(RememberKlassesChecker mux(false);)
_bitMap->lock()->unlock();
ConcurrentMarkSweepThread::desynchronize(true);
ConcurrentMarkSweepThread::acknowledge_yield_request();
@@ -7295,15 +7330,12 @@ PushOrMarkClosure::PushOrMarkClosure(CMS
CMSBitMap* bitMap, CMSMarkStack* markStack,
CMSMarkStack* revisitStack,
HeapWord* finger, MarkFromRootsClosure* parent) :
- OopClosure(collector->ref_processor()),
- _collector(collector),
+ KlassRememberingOopClosure(collector, collector->ref_processor(), revisitStack),
_span(span),
_bitMap(bitMap),
_markStack(markStack),
- _revisitStack(revisitStack),
_finger(finger),
- _parent(parent),
- _should_remember_klasses(collector->should_unload_classes())
+ _parent(parent)
{ }
Par_PushOrMarkClosure::Par_PushOrMarkClosure(CMSCollector* collector,
@@ -7315,18 +7347,17 @@ Par_PushOrMarkClosure::Par_PushOrMarkClo
HeapWord* finger,
HeapWord** global_finger_addr,
Par_MarkFromRootsClosure* parent) :
- OopClosure(collector->ref_processor()),
- _collector(collector),
+ Par_KlassRememberingOopClosure(collector,
+ collector->ref_processor(),
+ revisit_stack),
_whole_span(collector->_span),
_span(span),
_bit_map(bit_map),
_work_queue(work_queue),
_overflow_stack(overflow_stack),
- _revisit_stack(revisit_stack),
_finger(finger),
_global_finger_addr(global_finger_addr),
- _parent(parent),
- _should_remember_klasses(collector->should_unload_classes())
+ _parent(parent)
{ }
// Assumes thread-safe access by callers, who are
@@ -7456,6 +7487,14 @@ void Par_PushOrMarkClosure::do_oop(oop*
void Par_PushOrMarkClosure::do_oop(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
void Par_PushOrMarkClosure::do_oop(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); }
+KlassRememberingOopClosure::KlassRememberingOopClosure(CMSCollector* collector,
+ ReferenceProcessor* rp,
+ CMSMarkStack* revisit_stack) :
+ OopClosure(rp),
+ _collector(collector),
+ _revisit_stack(revisit_stack),
+ _should_remember_klasses(collector->should_unload_classes()) {}
+
PushAndMarkClosure::PushAndMarkClosure(CMSCollector* collector,
MemRegion span,
ReferenceProcessor* rp,
@@ -7464,15 +7503,12 @@ PushAndMarkClosure::PushAndMarkClosure(C
CMSMarkStack* mark_stack,
CMSMarkStack* revisit_stack,
bool concurrent_precleaning):
- OopClosure(rp),
- _collector(collector),
+ KlassRememberingOopClosure(collector, rp, revisit_stack),
_span(span),
_bit_map(bit_map),
_mod_union_table(mod_union_table),
_mark_stack(mark_stack),
- _revisit_stack(revisit_stack),
- _concurrent_precleaning(concurrent_precleaning),
- _should_remember_klasses(collector->should_unload_classes())
+ _concurrent_precleaning(concurrent_precleaning)
{
assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL");
}
@@ -7540,13 +7576,10 @@ Par_PushAndMarkClosure::Par_PushAndMarkC
CMSBitMap* bit_map,
OopTaskQueue* work_queue,
CMSMarkStack* revisit_stack):
- OopClosure(rp),
- _collector(collector),
+ Par_KlassRememberingOopClosure(collector, rp, revisit_stack),
_span(span),
_bit_map(bit_map),
- _work_queue(work_queue),
- _revisit_stack(revisit_stack),
- _should_remember_klasses(collector->should_unload_classes())
+ _work_queue(work_queue)
{
assert(_ref_processor != NULL, "_ref_processor shouldn't be NULL");
}
@@ -7599,19 +7632,16 @@ void Par_PushAndMarkClosure::do_oop(oop*
void Par_PushAndMarkClosure::do_oop(oop* p) { Par_PushAndMarkClosure::do_oop_work(p); }
void Par_PushAndMarkClosure::do_oop(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); }
-void PushAndMarkClosure::remember_klass(Klass* k) {
- if (!_revisit_stack->push(oop(k))) {
- fatal("Revisit stack overflowed in PushAndMarkClosure");
- }
-}
-
-void Par_PushAndMarkClosure::remember_klass(Klass* k) {
- if (!_revisit_stack->par_push(oop(k))) {
- fatal("Revist stack overflowed in Par_PushAndMarkClosure");
- }
+void PushAndMarkClosure::remember_mdo(DataLayout* v) {
+ // TBD
+}
+
+void Par_PushAndMarkClosure::remember_mdo(DataLayout* v) {
+ // TBD
}
void CMSPrecleanRefsYieldClosure::do_yield_work() {
+ DEBUG_ONLY(RememberKlassesChecker mux(false);)
Mutex* bml = _collector->bitMapLock();
assert_lock_strong(bml);
assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(),
@@ -8302,6 +8332,19 @@ bool CMSIsAliveClosure::do_object_b(oop
(!_span.contains(addr) || _bit_map->isMarked(addr));
}
+CMSKeepAliveClosure::CMSKeepAliveClosure( CMSCollector* collector,
+ MemRegion span,
+ CMSBitMap* bit_map, CMSMarkStack* mark_stack,
+ CMSMarkStack* revisit_stack, bool cpc):
+ KlassRememberingOopClosure(collector, NULL, revisit_stack),
+ _span(span),
+ _bit_map(bit_map),
+ _mark_stack(mark_stack),
+ _concurrent_precleaning(cpc) {
+ assert(!_span.is_empty(), "Empty span could spell trouble");
+}
+
+
// CMSKeepAliveClosure: the serial version
void CMSKeepAliveClosure::do_oop(oop obj) {
HeapWord* addr = (HeapWord*)obj;
@@ -8385,6 +8428,16 @@ void CMSParKeepAliveClosure::trim_queue(
}
}
+CMSInnerParMarkAndPushClosure::CMSInnerParMarkAndPushClosure(
+ CMSCollector* collector,
+ MemRegion span, CMSBitMap* bit_map,
+ CMSMarkStack* revisit_stack,
+ OopTaskQueue* work_queue):
+ Par_KlassRememberingOopClosure(collector, NULL, revisit_stack),
+ _span(span),
+ _bit_map(bit_map),
+ _work_queue(work_queue) { }
+
void CMSInnerParMarkAndPushClosure::do_oop(oop obj) {
HeapWord* addr = (HeapWord*)obj;
if (_span.contains(addr) &&
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -1790,12 +1790,13 @@ class CMSParDrainMarkingStackClosure: pu
public:
CMSParDrainMarkingStackClosure(CMSCollector* collector,
MemRegion span, CMSBitMap* bit_map,
+ CMSMarkStack* revisit_stack,
OopTaskQueue* work_queue):
_collector(collector),
_span(span),
_bit_map(bit_map),
_work_queue(work_queue),
- _mark_and_push(collector, span, bit_map, work_queue) { }
+ _mark_and_push(collector, span, bit_map, revisit_stack, work_queue) { }
public:
void trim_queue(uint max);
--- a/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -39,7 +39,6 @@ ConcurrentG1RefineThread(ConcurrentG1Ref
_next(next),
_cg1r(cg1r),
_vtime_accum(0.0),
- _co_tracker(G1CRGroup),
_interval_ms(5.0)
{
create_and_start();
@@ -75,9 +74,6 @@ void ConcurrentG1RefineThread::run() {
initialize_in_thread();
_vtime_start = os::elapsedVTime();
wait_for_universe_init();
-
- _co_tracker.enable();
- _co_tracker.start();
while (!_should_terminate) {
DirtyCardQueueSet& dcqs = JavaThread::dirty_card_queue_set();
@@ -147,7 +143,6 @@ void ConcurrentG1RefineThread::run() {
}
break;
}
- _co_tracker.update(false);
// Check if we need to activate the next thread.
if (curr_buffer_num > next_threshold && _next != NULL && !_next->is_active()) {
@@ -168,7 +163,6 @@ void ConcurrentG1RefineThread::run() {
}
n_logs++;
}
- _co_tracker.update(false);
_sts.leave();
if (os::supports_vtime()) {
@@ -177,9 +171,6 @@ void ConcurrentG1RefineThread::run() {
_vtime_accum = 0.0;
}
}
- _sts.join();
- _co_tracker.update(true);
- _sts.leave();
assert(_should_terminate, "just checking");
terminate();
--- a/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/concurrentG1RefineThread.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -51,7 +51,6 @@ class ConcurrentG1RefineThread: public C
private:
ConcurrentG1Refine* _cg1r;
- COTracker _co_tracker;
double _interval_ms;
void decreaseInterval(int processing_time_ms) {
--- a/src/share/vm/gc_implementation/g1/concurrentMark.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/concurrentMark.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -433,8 +433,7 @@ ConcurrentMark::ConcurrentMark(ReservedS
_total_counting_time(0.0),
_total_rs_scrub_time(0.0),
- _parallel_workers(NULL),
- _cleanup_co_tracker(G1CLGroup)
+ _parallel_workers(NULL)
{
CMVerboseLevel verbose_level =
(CMVerboseLevel) G1MarkingVerboseLevel;
@@ -823,18 +822,6 @@ void ConcurrentMark::checkpointRootsInit
// when marking is on. So, it's also called at the end of the
// initial-mark pause to update the heap end, if the heap expands
// during it. No need to call it here.
-
- guarantee( !_cleanup_co_tracker.enabled(), "invariant" );
-
- size_t max_marking_threads =
- MAX2((size_t) 1, parallel_marking_threads());
- for (int i = 0; i < (int)_max_task_num; ++i) {
- _tasks[i]->enable_co_tracker();
- if (i < (int) max_marking_threads)
- _tasks[i]->reset_co_tracker(marking_task_overhead());
- else
- _tasks[i]->reset_co_tracker(0.0);
- }
}
// Checkpoint the roots into this generation from outside
@@ -845,7 +832,6 @@ void ConcurrentMark::checkpointRootsInit
G1CollectedHeap* g1h = G1CollectedHeap::heap();
double start = os::elapsedTime();
- GCOverheadReporter::recordSTWStart(start);
G1CollectorPolicy* g1p = G1CollectedHeap::heap()->g1_policy();
g1p->record_concurrent_mark_init_start();
@@ -876,7 +862,6 @@ void ConcurrentMark::checkpointRootsInit
// Statistics.
double end = os::elapsedTime();
_init_times.add((end - start) * 1000.0);
- GCOverheadReporter::recordSTWEnd(end);
g1p->record_concurrent_mark_init_end();
}
@@ -1035,7 +1020,6 @@ public:
guarantee( (size_t)worker_i < _cm->active_tasks(), "invariant" );
CMTask* the_task = _cm->task(worker_i);
- the_task->start_co_tracker();
the_task->record_start_time();
if (!_cm->has_aborted()) {
do {
@@ -1061,8 +1045,6 @@ public:
double end_time2_sec = os::elapsedTime();
double elapsed_time2_sec = end_time2_sec - start_time_sec;
- the_task->update_co_tracker();
-
#if 0
gclog_or_tty->print_cr("CM: elapsed %1.4lf ms, sleep %1.4lf ms, "
"overhead %1.4lf",
@@ -1079,7 +1061,6 @@ public:
ConcurrentGCThread::stsLeave();
double end_vtime = os::elapsedVTime();
- the_task->update_co_tracker(true);
_cm->update_accum_task_vtime(worker_i, end_vtime - start_vtime);
}
@@ -1133,7 +1114,6 @@ void ConcurrentMark::checkpointRootsFina
g1p->record_concurrent_mark_remark_start();
double start = os::elapsedTime();
- GCOverheadReporter::recordSTWStart(start);
checkpointRootsFinalWork();
@@ -1173,11 +1153,6 @@ void ConcurrentMark::checkpointRootsFina
_remark_weak_ref_times.add((now - mark_work_end) * 1000.0);
_remark_times.add((now - start) * 1000.0);
- GCOverheadReporter::recordSTWEnd(now);
- for (int i = 0; i < (int)_max_task_num; ++i)
- _tasks[i]->disable_co_tracker();
- _cleanup_co_tracker.enable();
- _cleanup_co_tracker.reset(cleanup_task_overhead());
g1p->record_concurrent_mark_remark_end();
}
@@ -1188,7 +1163,6 @@ class CalcLiveObjectsClosure: public Hea
CMBitMapRO* _bm;
ConcurrentMark* _cm;
- COTracker* _co_tracker;
bool _changed;
bool _yield;
size_t _words_done;
@@ -1216,12 +1190,10 @@ public:
public:
CalcLiveObjectsClosure(bool final,
CMBitMapRO *bm, ConcurrentMark *cm,
- BitMap* region_bm, BitMap* card_bm,
- COTracker* co_tracker) :
+ BitMap* region_bm, BitMap* card_bm) :
_bm(bm), _cm(cm), _changed(false), _yield(true),
_words_done(0), _tot_live(0), _tot_used(0),
- _region_bm(region_bm), _card_bm(card_bm),
- _final(final), _co_tracker(co_tracker),
+ _region_bm(region_bm), _card_bm(card_bm),_final(final),
_regions_done(0), _start_vtime_sec(0.0)
{
_bottom_card_num =
@@ -1265,9 +1237,6 @@ public:
}
bool doHeapRegion(HeapRegion* hr) {
- if (_co_tracker != NULL)
- _co_tracker->update();
-
if (!_final && _regions_done == 0)
_start_vtime_sec = os::elapsedVTime();
@@ -1396,12 +1365,6 @@ public:
if (elapsed_vtime_sec > (10.0 / 1000.0)) {
jlong sleep_time_ms =
(jlong) (elapsed_vtime_sec * _cm->cleanup_sleep_factor() * 1000.0);
-#if 0
- gclog_or_tty->print_cr("CL: elapsed %1.4lf ms, sleep %1.4lf ms, "
- "overhead %1.4lf",
- elapsed_vtime_sec * 1000.0, (double) sleep_time_ms,
- _co_tracker->concOverhead(os::elapsedTime()));
-#endif
os::sleep(Thread::current(), sleep_time_ms, false);
_start_vtime_sec = end_vtime_sec;
}
@@ -1421,15 +1384,11 @@ public:
void ConcurrentMark::calcDesiredRegions() {
- guarantee( _cleanup_co_tracker.enabled(), "invariant" );
- _cleanup_co_tracker.start();
-
_region_bm.clear();
_card_bm.clear();
CalcLiveObjectsClosure calccl(false /*final*/,
nextMarkBitMap(), this,
- &_region_bm, &_card_bm,
- &_cleanup_co_tracker);
+ &_region_bm, &_card_bm);
G1CollectedHeap *g1h = G1CollectedHeap::heap();
g1h->heap_region_iterate(&calccl);
@@ -1437,8 +1396,6 @@ void ConcurrentMark::calcDesiredRegions(
calccl.reset();
g1h->heap_region_iterate(&calccl);
} while (calccl.changed());
-
- _cleanup_co_tracker.update(true);
}
class G1ParFinalCountTask: public AbstractGangTask {
@@ -1472,8 +1429,7 @@ public:
void work(int i) {
CalcLiveObjectsClosure calccl(true /*final*/,
_bm, _g1h->concurrent_mark(),
- _region_bm, _card_bm,
- NULL /* CO tracker */);
+ _region_bm, _card_bm);
calccl.no_yield();
if (ParallelGCThreads > 0) {
_g1h->heap_region_par_iterate_chunked(&calccl, i,
@@ -1663,13 +1619,10 @@ void ConcurrentMark::cleanup() {
/* prev marking */ true);
}
- _cleanup_co_tracker.disable();
-
G1CollectorPolicy* g1p = G1CollectedHeap::heap()->g1_policy();
g1p->record_concurrent_mark_cleanup_start();
double start = os::elapsedTime();
- GCOverheadReporter::recordSTWStart(start);
// Do counting once more with the world stopped for good measure.
G1ParFinalCountTask g1_par_count_task(g1h, nextMarkBitMap(),
@@ -1774,7 +1727,6 @@ void ConcurrentMark::cleanup() {
// Statistics.
double end = os::elapsedTime();
_cleanup_times.add((end - start) * 1000.0);
- GCOverheadReporter::recordSTWEnd(end);
// G1CollectedHeap::heap()->print();
// gclog_or_tty->print_cr("HEAP GC TIME STAMP : %d",
@@ -2623,24 +2575,6 @@ void ConcurrentMark::registerCSetRegion(
HeapWord* region_end = hr->end();
if (region_end > _min_finger)
_should_gray_objects = true;
-}
-
-void ConcurrentMark::disable_co_trackers() {
- if (has_aborted()) {
- if (_cleanup_co_tracker.enabled())
- _cleanup_co_tracker.disable();
- for (int i = 0; i < (int)_max_task_num; ++i) {
- CMTask* task = _tasks[i];
- if (task->co_tracker_enabled())
- task->disable_co_tracker();
- }
- } else {
- guarantee( !_cleanup_co_tracker.enabled(), "invariant" );
- for (int i = 0; i < (int)_max_task_num; ++i) {
- CMTask* task = _tasks[i];
- guarantee( !task->co_tracker_enabled(), "invariant" );
- }
- }
}
// abandon current marking iteration due to a Full GC
@@ -4018,7 +3952,6 @@ CMTask::CMTask(int task_id,
CMTaskQueue* task_queue,
CMTaskQueueSet* task_queues)
: _g1h(G1CollectedHeap::heap()),
- _co_tracker(G1CMGroup),
_task_id(task_id), _cm(cm),
_claimed(false),
_nextMarkBitMap(NULL), _hash_seed(17),
--- a/src/share/vm/gc_implementation/g1/concurrentMark.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/concurrentMark.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -407,8 +407,6 @@ protected:
// verbose level
CMVerboseLevel _verbose_level;
- COTracker _cleanup_co_tracker;
-
// These two fields are used to implement the optimisation that
// avoids pushing objects on the global/region stack if there are
// no collection set regions above the lowest finger.
@@ -720,8 +718,6 @@ public:
// Called to abort the marking cycle after a Full GC takes palce.
void abort();
- void disable_co_trackers();
-
// This prints the global/local fingers. It is used for debugging.
NOT_PRODUCT(void print_finger();)
@@ -773,9 +769,6 @@ private:
// number of calls to this task
int _calls;
- // concurrent overhead over a single CPU for this task
- COTracker _co_tracker;
-
// when the virtual timer reaches this time, the marking step should
// exit
double _time_target_ms;
@@ -927,27 +920,6 @@ public:
void clear_region_fields();
void set_concurrent(bool concurrent) { _concurrent = concurrent; }
-
- void enable_co_tracker() {
- guarantee( !_co_tracker.enabled(), "invariant" );
- _co_tracker.enable();
- }
- void disable_co_tracker() {
- guarantee( _co_tracker.enabled(), "invariant" );
- _co_tracker.disable();
- }
- bool co_tracker_enabled() {
- return _co_tracker.enabled();
- }
- void reset_co_tracker(double starting_conc_overhead = 0.0) {
- _co_tracker.reset(starting_conc_overhead);
- }
- void start_co_tracker() {
- _co_tracker.start();
- }
- void update_co_tracker(bool force_end = false) {
- _co_tracker.update(force_end);
- }
// The main method of this class which performs a marking step
// trying not to exceed the given duration. However, it might exit
--- a/src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/concurrentMarkThread.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -260,10 +260,6 @@ void ConcurrentMarkThread::run() {
}
}
- _sts.join();
- _cm->disable_co_trackers();
- _sts.leave();
-
// we now want to allow clearing of the marking bitmap to be
// suspended by a collection pause.
_sts.join();
--- a/src/share/vm/gc_implementation/g1/concurrentZFThread.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/concurrentZFThread.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -35,8 +35,7 @@ int ConcurrentZFThread::_regions_filled
int ConcurrentZFThread::_regions_filled = 0;
ConcurrentZFThread::ConcurrentZFThread() :
- ConcurrentGCThread(),
- _co_tracker(G1ZFGroup)
+ ConcurrentGCThread()
{
create_and_start();
}
@@ -71,8 +70,6 @@ void ConcurrentZFThread::run() {
Thread* thr_self = Thread::current();
_vtime_start = os::elapsedVTime();
wait_for_universe_init();
- _co_tracker.enable();
- _co_tracker.start();
G1CollectedHeap* g1 = G1CollectedHeap::heap();
_sts.join();
@@ -135,10 +132,7 @@ void ConcurrentZFThread::run() {
}
_vtime_accum = (os::elapsedVTime() - _vtime_start);
_sts.join();
-
- _co_tracker.update();
}
- _co_tracker.update(false);
_sts.leave();
assert(_should_terminate, "just checking");
--- a/src/share/vm/gc_implementation/g1/concurrentZFThread.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/concurrentZFThread.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -42,8 +42,6 @@ class ConcurrentZFThread: public Concurr
// Number of regions CFZ thread fills.
static int _regions_filled;
- COTracker _co_tracker;
-
double _vtime_start; // Initial virtual time.
// These are static because the "print_summary_info" method is, and
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -24,6 +24,8 @@
#include "incls/_precompiled.incl"
#include "incls/_g1CollectedHeap.cpp.incl"
+
+size_t G1CollectedHeap::_humongous_object_threshold_in_words = 0;
// turn it on so that the contents of the young list (scan-only /
// to-be-collected) are printed at "strategic" points before / during
@@ -927,7 +929,6 @@ void G1CollectedHeap::do_collection(bool
TraceTime t(full ? "Full GC (System.gc())" : "Full GC", PrintGC, true, gclog_or_tty);
double start = os::elapsedTime();
- GCOverheadReporter::recordSTWStart(start);
g1_policy()->record_full_collection_start();
gc_prologue(true);
@@ -1049,7 +1050,6 @@ void G1CollectedHeap::do_collection(bool
}
double end = os::elapsedTime();
- GCOverheadReporter::recordSTWEnd(end);
g1_policy()->record_full_collection_end();
#ifdef TRACESPINNING
@@ -1396,6 +1396,9 @@ G1CollectedHeap::G1CollectedHeap(G1Colle
if (_process_strong_tasks == NULL || !_process_strong_tasks->valid()) {
vm_exit_during_initialization("Failed necessary allocation.");
}
+
+ _humongous_object_threshold_in_words = HeapRegion::GrainWords / 2;
+
int n_queues = MAX2((int)ParallelGCThreads, 1);
_task_queues = new RefToScanQueueSet(n_queues);
@@ -1548,9 +1551,10 @@ jint G1CollectedHeap::initialize() {
const size_t max_region_idx = ((size_t)1 << (sizeof(RegionIdx_t)*BitsPerByte-1)) - 1;
guarantee((max_regions() - 1) <= max_region_idx, "too many regions");
- const size_t cards_per_region = HeapRegion::GrainBytes >> CardTableModRefBS::card_shift;
size_t max_cards_per_region = ((size_t)1 << (sizeof(CardIdx_t)*BitsPerByte-1)) - 1;
- guarantee(cards_per_region < max_cards_per_region, "too many cards per region");
+ guarantee(HeapRegion::CardsPerRegion > 0, "make sure it's initialized");
+ guarantee((size_t) HeapRegion::CardsPerRegion < max_cards_per_region,
+ "too many cards per region");
_bot_shared = new G1BlockOffsetSharedArray(_reserved,
heap_word_size(init_byte_size));
@@ -1609,9 +1613,6 @@ jint G1CollectedHeap::initialize() {
// Do later initialization work for concurrent refinement.
_cg1r->init();
-
- const char* group_names[] = { "CR", "ZF", "CM", "CL" };
- GCOverheadReporter::initGCOverheadReporter(4, group_names);
return JNI_OK;
}
@@ -2431,8 +2432,6 @@ void G1CollectedHeap::print_tracing_info
}
g1_policy()->print_yg_surv_rate_info();
- GCOverheadReporter::printGCOverhead();
-
SpecializationStats::print();
}
@@ -2669,7 +2668,6 @@ G1CollectedHeap::do_collection_pause_at_
// The elapsed time induced by the start time below deliberately elides
// the possible verification above.
double start_time_sec = os::elapsedTime();
- GCOverheadReporter::recordSTWStart(start_time_sec);
size_t start_used_bytes = used();
g1_policy()->record_collection_pause_start(start_time_sec,
@@ -2746,8 +2744,6 @@ G1CollectedHeap::do_collection_pause_at_
// we're expecting them to be null at the beginning of the next GC
_in_cset_fast_test = NULL;
_in_cset_fast_test_base = NULL;
-
- release_gc_alloc_regions(false /* totally */);
cleanup_surviving_young_words();
@@ -2798,7 +2794,6 @@ G1CollectedHeap::do_collection_pause_at_
double end_time_sec = os::elapsedTime();
double pause_time_ms = (end_time_sec - start_time_sec) * MILLIUNITS;
g1_policy()->record_pause_time_ms(pause_time_ms);
- GCOverheadReporter::recordSTWEnd(end_time_sec);
g1_policy()->record_collection_pause_end(abandoned);
assert(regions_accounted_for(), "Region leakage.");
@@ -4141,6 +4136,7 @@ void G1CollectedHeap::evacuate_collectio
G1KeepAliveClosure keep_alive(this);
JNIHandles::weak_oops_do(&is_alive, &keep_alive);
}
+ release_gc_alloc_regions(false /* totally */);
g1_rem_set()->cleanup_after_oops_into_collection_set_do();
concurrent_g1_refine()->clear_hot_cache();
@@ -4274,12 +4270,18 @@ class G1ParCleanupCTTask : public Abstra
class G1ParCleanupCTTask : public AbstractGangTask {
CardTableModRefBS* _ct_bs;
G1CollectedHeap* _g1h;
+ HeapRegion* volatile _so_head;
+ HeapRegion* volatile _su_head;
public:
G1ParCleanupCTTask(CardTableModRefBS* ct_bs,
- G1CollectedHeap* g1h) :
+ G1CollectedHeap* g1h,
+ HeapRegion* scan_only_list,
+ HeapRegion* survivor_list) :
AbstractGangTask("G1 Par Cleanup CT Task"),
_ct_bs(ct_bs),
- _g1h(g1h)
+ _g1h(g1h),
+ _so_head(scan_only_list),
+ _su_head(survivor_list)
{ }
void work(int i) {
@@ -4287,22 +4289,64 @@ public:
while (r = _g1h->pop_dirty_cards_region()) {
clear_cards(r);
}
- }
+ // Redirty the cards of the scan-only and survivor regions.
+ dirty_list(&this->_so_head);
+ dirty_list(&this->_su_head);
+ }
+
void clear_cards(HeapRegion* r) {
// Cards for Survivor and Scan-Only regions will be dirtied later.
if (!r->is_scan_only() && !r->is_survivor()) {
_ct_bs->clear(MemRegion(r->bottom(), r->end()));
}
}
+
+ void dirty_list(HeapRegion* volatile * head_ptr) {
+ HeapRegion* head;
+ do {
+ // Pop region off the list.
+ head = *head_ptr;
+ if (head != NULL) {
+ HeapRegion* r = (HeapRegion*)
+ Atomic::cmpxchg_ptr(head->get_next_young_region(), head_ptr, head);
+ if (r == head) {
+ assert(!r->isHumongous(), "Humongous regions shouldn't be on survivor list");
+ _ct_bs->dirty(MemRegion(r->bottom(), r->end()));
+ }
+ }
+ } while (*head_ptr != NULL);
+ }
};
+
+#ifndef PRODUCT
+class G1VerifyCardTableCleanup: public HeapRegionClosure {
+ CardTableModRefBS* _ct_bs;
+public:
+ G1VerifyCardTableCleanup(CardTableModRefBS* ct_bs)
+ : _ct_bs(ct_bs)
+ { }
+ virtual bool doHeapRegion(HeapRegion* r)
+ {
+ MemRegion mr(r->bottom(), r->end());
+ if (r->is_scan_only() || r->is_survivor()) {
+ _ct_bs->verify_dirty_region(mr);
+ } else {
+ _ct_bs->verify_clean_region(mr);
+ }
+ return false;
+ }
+};
+#endif
void G1CollectedHeap::cleanUpCardTable() {
CardTableModRefBS* ct_bs = (CardTableModRefBS*) (barrier_set());
double start = os::elapsedTime();
// Iterate over the dirty cards region list.
- G1ParCleanupCTTask cleanup_task(ct_bs, this);
+ G1ParCleanupCTTask cleanup_task(ct_bs, this,
+ _young_list->first_scan_only_region(),
+ _young_list->first_survivor_region());
if (ParallelGCThreads > 0) {
set_par_threads(workers()->total_workers());
workers()->run_task(&cleanup_task);
@@ -4318,17 +4362,21 @@ void G1CollectedHeap::cleanUpCardTable()
}
r->set_next_dirty_cards_region(NULL);
}
- }
- // now, redirty the cards of the scan-only and survivor regions
- // (it seemed faster to do it this way, instead of iterating over
- // all regions and then clearing / dirtying as appropriate)
- dirtyCardsForYoungRegions(ct_bs, _young_list->first_scan_only_region());
- dirtyCardsForYoungRegions(ct_bs, _young_list->first_survivor_region());
-
+ // now, redirty the cards of the scan-only and survivor regions
+ // (it seemed faster to do it this way, instead of iterating over
+ // all regions and then clearing / dirtying as appropriate)
+ dirtyCardsForYoungRegions(ct_bs, _young_list->first_scan_only_region());
+ dirtyCardsForYoungRegions(ct_bs, _young_list->first_survivor_region());
+ }
double elapsed = os::elapsedTime() - start;
g1_policy()->record_clear_ct_time( elapsed * 1000.0);
-}
-
+#ifndef PRODUCT
+ if (G1VerifyCTCleanup || VerifyAfterGC) {
+ G1VerifyCardTableCleanup cleanup_verifier(ct_bs);
+ heap_region_iterate(&cleanup_verifier);
+ }
+#endif
+}
void G1CollectedHeap::do_collection_pause_if_appropriate(size_t word_size) {
if (g1_policy()->should_do_collection_pause(word_size)) {
@@ -5022,7 +5070,7 @@ bool G1CollectedHeap::is_in_closed_subse
return hr->is_in(p);
}
}
-#endif // PRODUCT
+#endif // !PRODUCT
void G1CollectedHeap::g1_unimplemented() {
// Unimplemented();
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -167,15 +167,10 @@ class G1CollectedHeap : public SharedHea
friend class G1MarkSweep;
private:
- enum SomePrivateConstants {
- VeryLargeInBytes = HeapRegion::GrainBytes/2,
- VeryLargeInWords = VeryLargeInBytes/HeapWordSize,
- MinHeapDeltaBytes = 10 * HeapRegion::GrainBytes, // FIXME
- NumAPIs = HeapRegion::MaxAge
- };
-
// The one and only G1CollectedHeap, so static functions can find it.
static G1CollectedHeap* _g1h;
+
+ static size_t _humongous_object_threshold_in_words;
// Storage for the G1 heap (excludes the permanent generation).
VirtualSpace _g1_storage;
@@ -859,7 +854,7 @@ public:
return _g1_committed;
}
- NOT_PRODUCT( bool is_in_closed_subset(const void* p) const; )
+ NOT_PRODUCT(bool is_in_closed_subset(const void* p) const;)
// Dirty card table entries covering a list of young regions.
void dirtyCardsForYoungRegions(CardTableModRefBS* ct_bs, HeapRegion* list);
@@ -1021,7 +1016,7 @@ public:
// Returns "true" iff the given word_size is "very large".
static bool isHumongous(size_t word_size) {
- return word_size >= VeryLargeInWords;
+ return word_size >= _humongous_object_threshold_in_words;
}
// Update mod union table with the set of dirty cards.
--- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -201,6 +201,11 @@ G1CollectorPolicy::G1CollectorPolicy() :
_survivors_age_table(true)
{
+ // Set up the region size and associated fields. Given that the
+ // policy is created before the heap, we have to set this up here,
+ // so it's done as soon as possible.
+ HeapRegion::setup_heap_region_size(Arguments::min_heap_size());
+
_recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime());
_prev_collection_pause_end_ms = os::elapsedTime() * 1000.0;
@@ -993,8 +998,6 @@ void G1CollectorPolicy::record_full_coll
double full_gc_time_sec = end_sec - _cur_collection_start_sec;
double full_gc_time_ms = full_gc_time_sec * 1000.0;
- checkpoint_conc_overhead();
-
_all_full_gc_times_ms->add(full_gc_time_ms);
update_recent_gc_times(end_sec, full_gc_time_ms);
@@ -1164,7 +1167,6 @@ void G1CollectorPolicy::record_concurren
double end_time_sec = os::elapsedTime();
double elapsed_time_ms = (end_time_sec - _mark_init_start_sec) * 1000.0;
_concurrent_mark_init_times_ms->add(elapsed_time_ms);
- checkpoint_conc_overhead();
record_concurrent_mark_init_end_pre(elapsed_time_ms);
_mmu_tracker->add_pause(_mark_init_start_sec, end_time_sec, true);
@@ -1178,7 +1180,6 @@ void G1CollectorPolicy::record_concurren
void G1CollectorPolicy::record_concurrent_mark_remark_end() {
double end_time_sec = os::elapsedTime();
double elapsed_time_ms = (end_time_sec - _mark_remark_start_sec)*1000.0;
- checkpoint_conc_overhead();
_concurrent_mark_remark_times_ms->add(elapsed_time_ms);
_cur_mark_stop_world_time_ms += elapsed_time_ms;
_prev_collection_pause_end_ms += elapsed_time_ms;
@@ -1210,7 +1211,6 @@ record_concurrent_mark_cleanup_end_work1
// The important thing about this is that it includes "os::elapsedTime".
void G1CollectorPolicy::record_concurrent_mark_cleanup_end_work2() {
- checkpoint_conc_overhead();
double end_time_sec = os::elapsedTime();
double elapsed_time_ms = (end_time_sec - _mark_cleanup_start_sec)*1000.0;
_concurrent_mark_cleanup_times_ms->add(elapsed_time_ms);
@@ -1424,8 +1424,6 @@ void G1CollectorPolicy::record_collectio
// do that for any other surv rate groups too
}
#endif // PRODUCT
-
- checkpoint_conc_overhead();
if (in_young_gc_mode()) {
last_pause_included_initial_mark = _should_initiate_conc_mark;
@@ -2525,19 +2523,6 @@ region_num_to_mbs(int length) {
}
#endif // PRODUCT
-void
-G1CollectorPolicy::checkpoint_conc_overhead() {
- double conc_overhead = 0.0;
- if (G1AccountConcurrentOverhead)
- conc_overhead = COTracker::totalPredConcOverhead();
- _mmu_tracker->update_conc_overhead(conc_overhead);
-#if 0
- gclog_or_tty->print(" CO %1.4lf TARGET %1.4lf",
- conc_overhead, _mmu_tracker->max_gc_time());
-#endif
-}
-
-
size_t G1CollectorPolicy::max_regions(int purpose) {
switch (purpose) {
case GCAllocForSurvived:
--- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -92,9 +92,7 @@ protected:
int _parallel_gc_threads;
enum SomePrivateConstants {
- NumPrevPausesForHeuristics = 10,
- NumPrevGCsForHeuristics = 10,
- NumAPIs = HeapRegion::MaxAge
+ NumPrevPausesForHeuristics = 10
};
G1MMUTracker* _mmu_tracker;
@@ -980,8 +978,6 @@ public:
bool should_initiate_conc_mark() { return _should_initiate_conc_mark; }
void set_should_initiate_conc_mark() { _should_initiate_conc_mark = true; }
void unset_should_initiate_conc_mark(){ _should_initiate_conc_mark = false; }
-
- void checkpoint_conc_overhead();
// If an expansion would be appropriate, because recent GC overhead had
// exceeded the desired limit, return an amount to expand by.
--- a/src/share/vm/gc_implementation/g1/g1MMUTracker.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/g1MMUTracker.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -37,21 +37,7 @@
G1MMUTracker::G1MMUTracker(double time_slice, double max_gc_time) :
_time_slice(time_slice),
- _max_gc_time(max_gc_time),
- _conc_overhead_time_sec(0.0) { }
-
-void
-G1MMUTracker::update_conc_overhead(double conc_overhead) {
- double conc_overhead_time_sec = _time_slice * conc_overhead;
- if (conc_overhead_time_sec > 0.9 * _max_gc_time) {
- // We are screwed, as we only seem to have <10% of the soft
- // real-time goal available for pauses. Let's admit defeat and
- // allow something more generous as a pause target.
- conc_overhead_time_sec = 0.75 * _max_gc_time;
- }
-
- _conc_overhead_time_sec = conc_overhead_time_sec;
-}
+ _max_gc_time(max_gc_time) { }
G1MMUTrackerQueue::G1MMUTrackerQueue(double time_slice, double max_gc_time) :
G1MMUTracker(time_slice, max_gc_time),
@@ -128,7 +114,7 @@ double G1MMUTrackerQueue::longest_pause_
while( 1 ) {
double gc_time =
- calculate_gc_time(current_time + target_time) + _conc_overhead_time_sec;
+ calculate_gc_time(current_time + target_time);
double diff = target_time + gc_time - _max_gc_time;
if (!is_double_leq_0(diff)) {
target_time -= diff;
--- a/src/share/vm/gc_implementation/g1/g1MMUTracker.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/g1MMUTracker.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -33,19 +33,15 @@ protected:
double _time_slice;
double _max_gc_time; // this is per time slice
- double _conc_overhead_time_sec;
-
public:
G1MMUTracker(double time_slice, double max_gc_time);
-
- void update_conc_overhead(double conc_overhead);
virtual void add_pause(double start, double end, bool gc_thread) = 0;
virtual double longest_pause(double current_time) = 0;
virtual double when_sec(double current_time, double pause_time) = 0;
double max_gc_time() {
- return _max_gc_time - _conc_overhead_time_sec;
+ return _max_gc_time;
}
inline bool now_max_gc(double current_time) {
--- a/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -102,9 +102,14 @@ void G1MarkSweep::allocate_stacks() {
GenMarkSweep::_marking_stack =
new (ResourceObj::C_HEAP) GrowableArray<oop>(4000, true);
- size_t size = SystemDictionary::number_of_classes() * 2;
+ int size = SystemDictionary::number_of_classes() * 2;
GenMarkSweep::_revisit_klass_stack =
- new (ResourceObj::C_HEAP) GrowableArray<Klass*>((int)size, true);
+ new (ResourceObj::C_HEAP) GrowableArray<Klass*>(size, true);
+ // (#klass/k)^2 for k ~ 10 appears a better fit, but this will have to do
+ // for now until we have a chance to work out a more optimal setting.
+ GenMarkSweep::_revisit_mdo_stack =
+ new (ResourceObj::C_HEAP) GrowableArray<DataLayout*>(size*2, true);
+
}
void G1MarkSweep::mark_sweep_phase1(bool& marked_for_unloading,
@@ -139,12 +144,17 @@ void G1MarkSweep::mark_sweep_phase1(bool
CodeCache::do_unloading(&GenMarkSweep::is_alive,
&GenMarkSweep::keep_alive,
purged_class);
- GenMarkSweep::follow_stack();
+ GenMarkSweep::follow_stack();
// Update subklass/sibling/implementor links of live klasses
GenMarkSweep::follow_weak_klass_links();
assert(GenMarkSweep::_marking_stack->is_empty(),
"stack should be empty by now");
+
+ // Visit memoized MDO's and clear any unmarked weak refs
+ GenMarkSweep::follow_mdo_weak_refs();
+ assert(GenMarkSweep::_marking_stack->is_empty(), "just drained");
+
// Visit symbol and interned string tables and delete unmarked oops
SymbolTable::unlink(&GenMarkSweep::is_alive);
--- a/src/share/vm/gc_implementation/g1/g1_globals.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/g1_globals.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -37,11 +37,7 @@
develop(intx, G1MarkingOverheadPercent, 0, \
"Overhead of concurrent marking") \
\
- develop(bool, G1AccountConcurrentOverhead, false, \
- "Whether soft real-time compliance in G1 will take into account" \
- "concurrent overhead") \
- \
- product(intx, G1YoungGenSize, 0, \
+ product(uintx, G1YoungGenSize, 0, \
"Size of the G1 young generation, 0 is the adaptive policy") \
\
develop(bool, G1Gen, true, \
@@ -250,6 +246,9 @@
"If non-0 is the size of the G1 survivor space, " \
"otherwise SurvivorRatio is used to determine the size") \
\
+ product(uintx, G1HeapRegionSize, 0, \
+ "Size of the G1 regions.") \
+ \
experimental(bool, G1ParallelRSetUpdatingEnabled, false, \
"Enables the parallelization of remembered set updating " \
"during evacuation pauses") \
@@ -264,6 +263,9 @@
\
develop(intx, G1CardCountCacheExpandThreshold, 16, \
"Expand the card count cache if the number of collisions for " \
- "a particular entry exceeds this value.")
+ "a particular entry exceeds this value.") \
+ \
+ develop(bool, G1VerifyCTCleanup, false, \
+ "Verify card table cleanup.")
G1_FLAGS(DECLARE_DEVELOPER_FLAG, DECLARE_PD_DEVELOPER_FLAG, DECLARE_PRODUCT_FLAG, DECLARE_PD_PRODUCT_FLAG, DECLARE_DIAGNOSTIC_FLAG, DECLARE_EXPERIMENTAL_FLAG, DECLARE_NOTPRODUCT_FLAG, DECLARE_MANAGEABLE_FLAG, DECLARE_PRODUCT_RW_FLAG)
--- a/src/share/vm/gc_implementation/g1/heapRegion.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/heapRegion.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -24,6 +24,12 @@
#include "incls/_precompiled.incl"
#include "incls/_heapRegion.cpp.incl"
+
+int HeapRegion::LogOfHRGrainBytes = 0;
+int HeapRegion::LogOfHRGrainWords = 0;
+int HeapRegion::GrainBytes = 0;
+int HeapRegion::GrainWords = 0;
+int HeapRegion::CardsPerRegion = 0;
HeapRegionDCTOC::HeapRegionDCTOC(G1CollectedHeap* g1,
HeapRegion* hr, OopClosure* cl,
@@ -231,6 +237,73 @@ void HeapRegionDCTOC::walk_mem_region_wi
}
}
+// Minimum region size; we won't go lower than that.
+// We might want to decrease this in the future, to deal with small
+// heaps a bit more efficiently.
+#define MIN_REGION_SIZE ( 1024 * 1024 )
+
+// Maximum region size; we don't go higher than that. There's a good
+// reason for having an upper bound. We don't want regions to get too
+// large, otherwise cleanup's effectiveness would decrease as there
+// will be fewer opportunities to find totally empty regions after
+// marking.
+#define MAX_REGION_SIZE ( 32 * 1024 * 1024 )
+
+// The automatic region size calculation will try to have around this
+// many regions in the heap (based on the min heap size).
+#define TARGET_REGION_NUMBER 2048
+
+void HeapRegion::setup_heap_region_size(uintx min_heap_size) {
+ // region_size in bytes
+ uintx region_size = G1HeapRegionSize;
+ if (FLAG_IS_DEFAULT(G1HeapRegionSize)) {
+ // We base the automatic calculation on the min heap size. This
+ // can be problematic if the spread between min and max is quite
+ // wide, imagine -Xms128m -Xmx32g. But, if we decided it based on
+ // the max size, the region size might be way too large for the
+ // min size. Either way, some users might have to set the region
+ // size manually for some -Xms / -Xmx combos.
+
+ region_size = MAX2(min_heap_size / TARGET_REGION_NUMBER,
+ (uintx) MIN_REGION_SIZE);
+ }
+
+ int region_size_log = log2_long((jlong) region_size);
+ // Recalculate the region size to make sure it's a power of
+ // 2. This means that region_size is the largest power of 2 that's
+ // <= what we've calculated so far.
+ region_size = 1 << region_size_log;
+
+ // Now make sure that we don't go over or under our limits.
+ if (region_size < MIN_REGION_SIZE) {
+ region_size = MIN_REGION_SIZE;
+ } else if (region_size > MAX_REGION_SIZE) {
+ region_size = MAX_REGION_SIZE;
+ }
+
+ // And recalculate the log.
+ region_size_log = log2_long((jlong) region_size);
+
+ // Now, set up the globals.
+ guarantee(LogOfHRGrainBytes == 0, "we should only set it once");
+ LogOfHRGrainBytes = region_size_log;
+
+ guarantee(LogOfHRGrainWords == 0, "we should only set it once");
+ LogOfHRGrainWords = LogOfHRGrainBytes - LogHeapWordSize;
+
+ guarantee(GrainBytes == 0, "we should only set it once");
+ // The cast to int is safe, given that we've bounded region_size by
+ // MIN_REGION_SIZE and MAX_REGION_SIZE.
+ GrainBytes = (int) region_size;
+
+ guarantee(GrainWords == 0, "we should only set it once");
+ GrainWords = GrainBytes >> LogHeapWordSize;
+ guarantee(1 << LogOfHRGrainWords == GrainWords, "sanity");
+
+ guarantee(CardsPerRegion == 0, "we should only set it once");
+ CardsPerRegion = GrainBytes >> CardTableModRefBS::card_shift;
+}
+
void HeapRegion::reset_after_compaction() {
G1OffsetTableContigSpace::reset_after_compaction();
// After a compaction the mark bitmap is invalid, so we must
--- a/src/share/vm/gc_implementation/g1/heapRegion.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/heapRegion.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -297,15 +297,24 @@ class HeapRegion: public G1OffsetTableCo
HeapRegion(G1BlockOffsetSharedArray* sharedOffsetArray,
MemRegion mr, bool is_zeroed);
- enum SomePublicConstants {
- // HeapRegions are GrainBytes-aligned
- // and have sizes that are multiples of GrainBytes.
- LogOfHRGrainBytes = 20,
- LogOfHRGrainWords = LogOfHRGrainBytes - LogHeapWordSize,
- GrainBytes = 1 << LogOfHRGrainBytes,
- GrainWords = 1 <<LogOfHRGrainWords,
- MaxAge = 2, NoOfAges = MaxAge+1
- };
+ static int LogOfHRGrainBytes;
+ static int LogOfHRGrainWords;
+ // The normal type of these should be size_t. However, they used to
+ // be members of an enum before and they are assumed by the
+ // compilers to be ints. To avoid going and fixing all their uses,
+ // I'm declaring them as ints. I'm not anticipating heap region
+ // sizes to reach anywhere near 2g, so using an int here is safe.
+ static int GrainBytes;
+ static int GrainWords;
+ static int CardsPerRegion;
+
+ // It sets up the heap region size (GrainBytes / GrainWords), as
+ // well as other related fields that are based on the heap region
+ // size (LogOfHRGrainBytes / LogOfHRGrainWords /
+ // CardsPerRegion). All those fields are considered constant
+ // throughout the JVM's execution, therefore they should only be set
+ // up once during initialization time.
+ static void setup_heap_region_size(uintx min_heap_size);
enum ClaimValues {
InitialClaimValue = 0,
--- a/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -57,10 +57,6 @@ class PerRegionTable: public CHeapObj {
#endif // _MSC_VER
- enum SomePrivateConstants {
- CardsPerRegion = HeapRegion::GrainBytes >> CardTableModRefBS::card_shift
- };
-
protected:
// We need access in order to union things into the base table.
BitMap* bm() { return &_bm; }
@@ -76,7 +72,7 @@ protected:
#if PRT_COUNT_OCCUPIED
_occupied(0),
#endif
- _bm(CardsPerRegion, false /* in-resource-area */)
+ _bm(HeapRegion::CardsPerRegion, false /* in-resource-area */)
{}
static void free(PerRegionTable* prt) {
@@ -144,7 +140,8 @@ protected:
CardIdx_t from_card = (CardIdx_t)
hw_offset >> (CardTableModRefBS::card_shift - LogHeapWordSize);
- assert(0 <= from_card && from_card < CardsPerRegion, "Must be in range.");
+ assert(0 <= from_card && from_card < HeapRegion::CardsPerRegion,
+ "Must be in range.");
add_card_work(from_card, par);
}
}
@@ -631,7 +628,7 @@ void OtherRegionsTable::add_reference(Oo
uintptr_t(from_hr->bottom())
>> CardTableModRefBS::card_shift;
CardIdx_t card_index = from_card - from_hr_bot_card_index;
- assert(0 <= card_index && card_index < PosParPRT::CardsPerRegion,
+ assert(0 <= card_index && card_index < HeapRegion::CardsPerRegion,
"Must be in range.");
if (G1HRRSUseSparseTable &&
_sparse_table.add_card(from_hrs_ind, card_index)) {
@@ -922,7 +919,7 @@ size_t OtherRegionsTable::occ_fine() con
}
size_t OtherRegionsTable::occ_coarse() const {
- return (_n_coarse_entries * PosParPRT::CardsPerRegion);
+ return (_n_coarse_entries * HeapRegion::CardsPerRegion);
}
size_t OtherRegionsTable::occ_sparse() const {
@@ -1049,7 +1046,8 @@ bool OtherRegionsTable::contains_referen
uintptr_t(hr->bottom()) >> CardTableModRefBS::card_shift;
assert(from_card >= hr_bot_card_index, "Inv");
CardIdx_t card_index = from_card - hr_bot_card_index;
- assert(0 <= card_index && card_index < PosParPRT::CardsPerRegion, "Must be in range.");
+ assert(0 <= card_index && card_index < HeapRegion::CardsPerRegion,
+ "Must be in range.");
return _sparse_table.contains_card(hr_ind, card_index);
}
@@ -1176,7 +1174,7 @@ void HeapRegionRemSetIterator::initializ
_is = Sparse;
// Set these values so that we increment to the first region.
_coarse_cur_region_index = -1;
- _coarse_cur_region_cur_card = (PosParPRT::CardsPerRegion-1);;
+ _coarse_cur_region_cur_card = (HeapRegion::CardsPerRegion-1);;
_cur_region_cur_card = 0;
@@ -1195,7 +1193,7 @@ bool HeapRegionRemSetIterator::coarse_ha
// Go to the next card.
_coarse_cur_region_cur_card++;
// Was the last the last card in the current region?
- if (_coarse_cur_region_cur_card == PosParPRT::CardsPerRegion) {
+ if (_coarse_cur_region_cur_card == HeapRegion::CardsPerRegion) {
// Yes: find the next region. This may leave _coarse_cur_region_index
// Set to the last index, in which case there are no more coarse
// regions.
@@ -1232,7 +1230,7 @@ bool HeapRegionRemSetIterator::fine_has_
_fine_cur_prt->_bm.get_next_one_offset(_cur_region_cur_card + 1);
}
while (!fine_has_next()) {
- if (_cur_region_cur_card == PosParPRT::CardsPerRegion) {
+ if (_cur_region_cur_card == (size_t) HeapRegion::CardsPerRegion) {
_cur_region_cur_card = 0;
_fine_cur_prt = _fine_cur_prt->next();
}
@@ -1255,7 +1253,7 @@ bool HeapRegionRemSetIterator::fine_has_
bool HeapRegionRemSetIterator::fine_has_next() {
return
_fine_cur_prt != NULL &&
- _cur_region_cur_card < PosParPRT::CardsPerRegion;
+ _cur_region_cur_card < (size_t) HeapRegion::CardsPerRegion;
}
bool HeapRegionRemSetIterator::has_next(size_t& card_index) {
--- a/src/share/vm/gc_implementation/g1/sparsePRT.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/sparsePRT.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -347,7 +347,7 @@ size_t /* RSHashTable:: */ RSHashTableIt
size_t /* RSHashTable:: */ RSHashTableIter::compute_card_ind(CardIdx_t ci) {
return
_heap_bot_card_ind
- + (_rsht->entry(_bl_ind)->r_ind() * CardsPerRegion)
+ + (_rsht->entry(_bl_ind)->r_ind() * HeapRegion::CardsPerRegion)
+ ci;
}
--- a/src/share/vm/gc_implementation/g1/sparsePRT.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/g1/sparsePRT.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -172,10 +172,6 @@ class RSHashTableIter VALUE_OBJ_CLASS_SP
RSHashTable* _rsht;
size_t _heap_bot_card_ind;
- enum SomePrivateConstants {
- CardsPerRegion = HeapRegion::GrainBytes >> CardTableModRefBS::card_shift
- };
-
// If the bucket list pointed to by _bl_ind contains a card, sets
// _bl_ind to the index of that entry, and returns the card.
// Otherwise, returns SparseEntry::NullEntry.
--- a/src/share/vm/gc_implementation/includeDB_gc_concurrentMarkSweep Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/includeDB_gc_concurrentMarkSweep Thu Sep 10 09:04:41 2009 -0400
@@ -145,6 +145,7 @@ concurrentMarkSweepGeneration.cpp
concurrentMarkSweepGeneration.cpp globals_extension.hpp
concurrentMarkSweepGeneration.cpp handles.inline.hpp
concurrentMarkSweepGeneration.cpp isGCActiveMark.hpp
+concurrentMarkSweepGeneration.cpp iterator.hpp
concurrentMarkSweepGeneration.cpp java.hpp
concurrentMarkSweepGeneration.cpp jvmtiExport.hpp
concurrentMarkSweepGeneration.cpp oop.inline.hpp
--- a/src/share/vm/gc_implementation/includeDB_gc_g1 Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/includeDB_gc_g1 Thu Sep 10 09:04:41 2009 -0400
@@ -64,14 +64,12 @@ concurrentG1RefineThread.cpp resourceAr
concurrentG1RefineThread.cpp resourceArea.hpp
concurrentG1RefineThread.hpp concurrentGCThread.hpp
-concurrentG1RefineThread.hpp coTracker.hpp
concurrentMark.cpp concurrentMark.hpp
concurrentMark.cpp concurrentMarkThread.inline.hpp
concurrentMark.cpp g1CollectedHeap.inline.hpp
concurrentMark.cpp g1CollectorPolicy.hpp
concurrentMark.cpp g1RemSet.hpp
-concurrentMark.cpp gcOverheadReporter.hpp
concurrentMark.cpp genOopClosures.inline.hpp
concurrentMark.cpp heapRegionRemSet.hpp
concurrentMark.cpp heapRegionSeq.inline.hpp
@@ -82,7 +80,6 @@ concurrentMark.cpp resourceArea.hpp
concurrentMark.cpp resourceArea.hpp
concurrentMark.cpp symbolTable.hpp
-concurrentMark.hpp coTracker.hpp
concurrentMark.hpp heapRegion.hpp
concurrentMark.hpp taskqueue.hpp
@@ -107,7 +104,6 @@ concurrentZFThread.cpp space.inline.hp
concurrentZFThread.cpp space.inline.hpp
concurrentZFThread.hpp concurrentGCThread.hpp
-concurrentZFThread.hpp coTracker.hpp
dirtyCardQueue.cpp atomic.hpp
dirtyCardQueue.cpp dirtyCardQueue.hpp
@@ -147,7 +143,6 @@ g1CollectedHeap.cpp
g1CollectedHeap.cpp g1OopClosures.inline.hpp
g1CollectedHeap.cpp genOopClosures.inline.hpp
g1CollectedHeap.cpp gcLocker.inline.hpp
-g1CollectedHeap.cpp gcOverheadReporter.hpp
g1CollectedHeap.cpp generationSpec.hpp
g1CollectedHeap.cpp heapRegionRemSet.hpp
g1CollectedHeap.cpp heapRegionSeq.inline.hpp
@@ -170,6 +165,7 @@ g1CollectedHeap.inline.hpp
g1CollectedHeap.inline.hpp heapRegionSeq.hpp
g1CollectedHeap.inline.hpp taskqueue.hpp
+g1CollectorPolicy.cpp arguments.hpp
g1CollectorPolicy.cpp concurrentG1Refine.hpp
g1CollectorPolicy.cpp concurrentMark.hpp
g1CollectorPolicy.cpp concurrentMarkThread.inline.hpp
--- a/src/share/vm/gc_implementation/includeDB_gc_parallelScavenge Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/includeDB_gc_parallelScavenge Thu Sep 10 09:04:41 2009 -0400
@@ -253,10 +253,11 @@ psParallelCompact.cpp gcLocker.inline.
psParallelCompact.cpp gcLocker.inline.hpp
psParallelCompact.cpp gcTaskManager.hpp
psParallelCompact.cpp isGCActiveMark.hpp
+psParallelCompact.cpp management.hpp
+psParallelCompact.cpp memoryService.hpp
+psParallelCompact.cpp methodDataOop.hpp
psParallelCompact.cpp oop.inline.hpp
psParallelCompact.cpp oop.pcgc.inline.hpp
-psParallelCompact.cpp memoryService.hpp
-psParallelCompact.cpp management.hpp
psParallelCompact.cpp parallelScavengeHeap.inline.hpp
psParallelCompact.cpp pcTasks.hpp
psParallelCompact.cpp psMarkSweep.hpp
--- a/src/share/vm/gc_implementation/includeDB_gc_shared Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/includeDB_gc_shared Thu Sep 10 09:04:41 2009 -0400
@@ -35,12 +35,6 @@ concurrentGCThread.cpp
concurrentGCThread.hpp thread.hpp
-coTracker.hpp globalDefinitions.hpp
-coTracker.hpp numberSeq.hpp
-
-coTracker.cpp coTracker.hpp
-coTracker.cpp os.hpp
-
allocationStats.cpp allocationStats.hpp
allocationStats.cpp ostream.hpp
@@ -53,13 +47,6 @@ gcAdaptivePolicyCounters.hpp
gcAdaptivePolicyCounters.cpp resourceArea.hpp
gcAdaptivePolicyCounters.cpp gcAdaptivePolicyCounters.hpp
-
-gcOverheadReporter.cpp allocation.inline.hpp
-gcOverheadReporter.cpp concurrentGCThread.hpp
-gcOverheadReporter.cpp coTracker.hpp
-gcOverheadReporter.cpp gcOverheadReporter.hpp
-gcOverheadReporter.cpp ostream.hpp
-gcOverheadReporter.cpp thread_<os_family>.inline.hpp
gSpaceCounters.cpp generation.hpp
gSpaceCounters.cpp resourceArea.hpp
--- a/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -58,9 +58,8 @@ void MarkFromRootsTask::do_it(GCTaskMana
PrintGCDetails && TraceParallelOldGCTasks, true, gclog_or_tty));
ParCompactionManager* cm =
ParCompactionManager::gc_thread_compaction_manager(which);
- // cm->allocate_stacks();
assert(cm->stacks_have_been_allocated(),
- "Stack space has not been allocated");
+ "Stack space has not been allocated");
PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
switch (_root_type) {
@@ -129,9 +128,8 @@ void RefProcTaskProxy::do_it(GCTaskManag
PrintGCDetails && TraceParallelOldGCTasks, true, gclog_or_tty));
ParCompactionManager* cm =
ParCompactionManager::gc_thread_compaction_manager(which);
- // cm->allocate_stacks();
assert(cm->stacks_have_been_allocated(),
- "Stack space has not been allocated");
+ "Stack space has not been allocated");
PSParallelCompact::MarkAndPushClosure mark_and_push_closure(cm);
PSParallelCompact::FollowStackClosure follow_stack_closure(cm);
_rp_task.work(_work_id, *PSParallelCompact::is_alive_closure(),
--- a/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -61,12 +61,16 @@ ParCompactionManager::ParCompactionManag
int size =
(SystemDictionary::number_of_classes() * 2) * 2 / ParallelGCThreads;
_revisit_klass_stack = new (ResourceObj::C_HEAP) GrowableArray<Klass*>(size, true);
+ // From some experiments (#klass/k)^2 for k = 10 seems a better fit, but this will
+ // have to do for now until we are able to investigate a more optimal setting.
+ _revisit_mdo_stack = new (ResourceObj::C_HEAP) GrowableArray<DataLayout*>(size*2, true);
}
ParCompactionManager::~ParCompactionManager() {
delete _overflow_stack;
delete _revisit_klass_stack;
+ delete _revisit_mdo_stack;
// _manager_array and _stack_array are statics
// shared with all instances of ParCompactionManager
// should not be deallocated.
@@ -195,6 +199,7 @@ void ParCompactionManager::reset() {
void ParCompactionManager::reset() {
for(uint i=0; i<ParallelGCThreads+1; i++) {
manager_array(i)->revisit_klass_stack()->clear();
+ manager_array(i)->revisit_mdo_stack()->clear();
}
}
@@ -296,6 +301,7 @@ void ParCompactionManager::drain_region_
#ifdef ASSERT
bool ParCompactionManager::stacks_have_been_allocated() {
- return (revisit_klass_stack()->data_addr() != NULL);
-}
-#endif
+ return (revisit_klass_stack()->data_addr() != NULL &&
+ revisit_mdo_stack()->data_addr() != NULL);
+}
+#endif
--- a/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -93,6 +93,7 @@ class ParCompactionManager : public CHea
#if 1 // does this happen enough to need a per thread stack?
GrowableArray<Klass*>* _revisit_klass_stack;
+ GrowableArray<DataLayout*>* _revisit_mdo_stack;
#endif
static ParMarkBitMap* _mark_bitmap;
@@ -154,6 +155,7 @@ class ParCompactionManager : public CHea
#if 1
// Probably stays as a growable array
GrowableArray<Klass*>* revisit_klass_stack() { return _revisit_klass_stack; }
+ GrowableArray<DataLayout*>* revisit_mdo_stack() { return _revisit_mdo_stack; }
#endif
// Save oop for later processing. Must not fail.
--- a/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -482,6 +482,9 @@ void PSMarkSweep::allocate_stacks() {
int size = SystemDictionary::number_of_classes() * 2;
_revisit_klass_stack = new (ResourceObj::C_HEAP) GrowableArray<Klass*>(size, true);
+ // (#klass/k)^2, for k ~ 10 appears a better setting, but this will have to do for
+ // now until we investigate a more optimal setting.
+ _revisit_mdo_stack = new (ResourceObj::C_HEAP) GrowableArray<DataLayout*>(size*2, true);
}
@@ -495,6 +498,7 @@ void PSMarkSweep::deallocate_stacks() {
delete _marking_stack;
delete _revisit_klass_stack;
+ delete _revisit_mdo_stack;
}
void PSMarkSweep::mark_sweep_phase1(bool clear_all_softrefs) {
@@ -538,6 +542,10 @@ void PSMarkSweep::mark_sweep_phase1(bool
// Update subklass/sibling/implementor links of live klasses
follow_weak_klass_links();
+ assert(_marking_stack->is_empty(), "just drained");
+
+ // Visit memoized mdo's and clear unmarked weak refs
+ follow_mdo_weak_refs();
assert(_marking_stack->is_empty(), "just drained");
// Visit symbol and interned string tables and delete unmarked oops
--- a/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -2378,7 +2378,10 @@ void PSParallelCompact::marking_phase(Pa
// Update subklass/sibling/implementor links of live klasses
// revisit_klass_stack is used in follow_weak_klass_links().
- follow_weak_klass_links(cm);
+ follow_weak_klass_links();
+
+ // Revisit memoized MDO's and clear any unmarked weak refs
+ follow_mdo_weak_refs();
// Visit symbol and interned string tables and delete unmarked oops
SymbolTable::unlink(is_alive_closure());
@@ -2721,17 +2724,25 @@ void PSParallelCompact::follow_stack(Par
}
void
-PSParallelCompact::follow_weak_klass_links(ParCompactionManager* serial_cm) {
+PSParallelCompact::follow_weak_klass_links() {
// All klasses on the revisit stack are marked at this point.
// Update and follow all subklass, sibling and implementor links.
- for (uint i = 0; i < ParallelGCThreads+1; i++) {
+ if (PrintRevisitStats) {
+ gclog_or_tty->print_cr("#classes in system dictionary = %d", SystemDictionary::number_of_classes());
+ }
+ for (uint i = 0; i < ParallelGCThreads + 1; i++) {
ParCompactionManager* cm = ParCompactionManager::manager_array(i);
KeepAliveClosure keep_alive_closure(cm);
- for (int i = 0; i < cm->revisit_klass_stack()->length(); i++) {
- cm->revisit_klass_stack()->at(i)->follow_weak_klass_links(
+ int length = cm->revisit_klass_stack()->length();
+ if (PrintRevisitStats) {
+ gclog_or_tty->print_cr("Revisit klass stack[%d] length = %d", i, length);
+ }
+ for (int j = 0; j < length; j++) {
+ cm->revisit_klass_stack()->at(j)->follow_weak_klass_links(
is_alive_closure(),
&keep_alive_closure);
}
+ // revisit_klass_stack is cleared in reset()
follow_stack(cm);
}
}
@@ -2740,6 +2751,35 @@ PSParallelCompact::revisit_weak_klass_li
PSParallelCompact::revisit_weak_klass_link(ParCompactionManager* cm, Klass* k) {
cm->revisit_klass_stack()->push(k);
}
+
+#if ( defined(COMPILER1) || defined(COMPILER2) )
+void PSParallelCompact::revisit_mdo(ParCompactionManager* cm, DataLayout* p) {
+ cm->revisit_mdo_stack()->push(p);
+}
+
+void PSParallelCompact::follow_mdo_weak_refs() {
+ // All strongly reachable oops have been marked at this point;
+ // we can visit and clear any weak references from MDO's which
+ // we memoized during the strong marking phase.
+ if (PrintRevisitStats) {
+ gclog_or_tty->print_cr("#classes in system dictionary = %d", SystemDictionary::number_of_classes());
+ }
+ for (uint i = 0; i < ParallelGCThreads + 1; i++) {
+ ParCompactionManager* cm = ParCompactionManager::manager_array(i);
+ GrowableArray<DataLayout*>* rms = cm->revisit_mdo_stack();
+ int length = rms->length();
+ if (PrintRevisitStats) {
+ gclog_or_tty->print_cr("Revisit MDO stack[%d] length = %d", i, length);
+ }
+ for (int j = 0; j < length; j++) {
+ rms->at(j)->follow_weak_refs(is_alive_closure());
+ }
+ // revisit_mdo_stack is cleared in reset()
+ follow_stack(cm);
+ }
+}
+#endif // ( COMPILER1 || COMPILER2 )
+
#ifdef VALIDATE_MARK_SWEEP
--- a/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -901,7 +901,8 @@ class PSParallelCompact : AllStatic {
static void marking_phase(ParCompactionManager* cm,
bool maximum_heap_compaction);
static void follow_stack(ParCompactionManager* cm);
- static void follow_weak_klass_links(ParCompactionManager* cm);
+ static void follow_weak_klass_links();
+ static void follow_mdo_weak_refs();
template <class T> static inline void adjust_pointer(T* p, bool is_root);
static void adjust_root_pointer(oop* p) { adjust_pointer(p, true); }
@@ -1220,6 +1221,9 @@ class PSParallelCompact : AllStatic {
// Call backs for class unloading
// Update subklass/sibling/implementor links at end of marking.
static void revisit_weak_klass_link(ParCompactionManager* cm, Klass* k);
+
+ // Clear unmarked oops in MDOs at the end of marking.
+ static void revisit_mdo(ParCompactionManager* cm, DataLayout* p);
#ifndef PRODUCT
// Debugging support.
--- a/src/share/vm/gc_implementation/shared/markSweep.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/shared/markSweep.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -27,6 +27,7 @@
GrowableArray<oop>* MarkSweep::_marking_stack = NULL;
GrowableArray<Klass*>* MarkSweep::_revisit_klass_stack = NULL;
+GrowableArray<DataLayout*>* MarkSweep::_revisit_mdo_stack = NULL;
GrowableArray<oop>* MarkSweep::_preserved_oop_stack = NULL;
GrowableArray<markOop>* MarkSweep::_preserved_mark_stack= NULL;
@@ -62,11 +63,36 @@ void MarkSweep::follow_weak_klass_links(
void MarkSweep::follow_weak_klass_links() {
// All klasses on the revisit stack are marked at this point.
// Update and follow all subklass, sibling and implementor links.
+ if (PrintRevisitStats) {
+ gclog_or_tty->print_cr("#classes in system dictionary = %d", SystemDictionary::number_of_classes());
+ gclog_or_tty->print_cr("Revisit klass stack length = %d", _revisit_klass_stack->length());
+ }
for (int i = 0; i < _revisit_klass_stack->length(); i++) {
_revisit_klass_stack->at(i)->follow_weak_klass_links(&is_alive,&keep_alive);
}
follow_stack();
}
+
+#if ( defined(COMPILER1) || defined(COMPILER2) )
+void MarkSweep::revisit_mdo(DataLayout* p) {
+ _revisit_mdo_stack->push(p);
+}
+
+void MarkSweep::follow_mdo_weak_refs() {
+ // All strongly reachable oops have been marked at this point;
+ // we can visit and clear any weak references from MDO's which
+ // we memoized during the strong marking phase.
+ assert(_marking_stack->is_empty(), "Marking stack should be empty");
+ if (PrintRevisitStats) {
+ gclog_or_tty->print_cr("#classes in system dictionary = %d", SystemDictionary::number_of_classes());
+ gclog_or_tty->print_cr("Revisit MDO stack length = %d", _revisit_mdo_stack->length());
+ }
+ for (int i = 0; i < _revisit_mdo_stack->length(); i++) {
+ _revisit_mdo_stack->at(i)->follow_weak_refs(&is_alive);
+ }
+ follow_stack();
+}
+#endif // ( COMPILER1 || COMPILER2 )
MarkSweep::FollowRootClosure MarkSweep::follow_root_closure;
--- a/src/share/vm/gc_implementation/shared/markSweep.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_implementation/shared/markSweep.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -23,6 +23,7 @@
*/
class ReferenceProcessor;
+class DataLayout;
// MarkSweep takes care of global mark-compact garbage collection for a
// GenCollectedHeap using a four-phase pointer forwarding algorithm. All
@@ -65,6 +66,8 @@ class MarkSweep : AllStatic {
virtual void do_oop(oop* p);
virtual void do_oop(narrowOop* p);
virtual const bool do_nmethods() const { return true; }
+ virtual const bool should_remember_mdo() const { return true; }
+ virtual void remember_mdo(DataLayout* p) { MarkSweep::revisit_mdo(p); }
};
class FollowStackClosure: public VoidClosure {
@@ -103,6 +106,7 @@ class MarkSweep : AllStatic {
friend class KeepAliveClosure;
friend class VM_MarkSweep;
friend void marksweep_init();
+ friend class DataLayout;
//
// Vars
@@ -112,6 +116,8 @@ class MarkSweep : AllStatic {
static GrowableArray<oop>* _marking_stack;
// Stack for live klasses to revisit at end of marking phase
static GrowableArray<Klass*>* _revisit_klass_stack;
+ // Set (stack) of MDO's to revisit at end of marking phase
+ static GrowableArray<DataLayout*>* _revisit_mdo_stack;
// Space for storing/restoring mark word
static GrowableArray<markOop>* _preserved_mark_stack;
@@ -157,6 +163,10 @@ class MarkSweep : AllStatic {
// Class unloading. Update subklass/sibling/implementor links at end of marking phase.
static void follow_weak_klass_links();
+ // Class unloading. Clear weak refs in MDO's (ProfileData)
+ // at the end of the marking phase.
+ static void follow_mdo_weak_refs();
+
// Debugging
static void trace(const char* msg) PRODUCT_RETURN;
@@ -213,7 +223,10 @@ class MarkSweep : AllStatic {
#endif
// Call backs for class unloading
- static void revisit_weak_klass_link(Klass* k); // Update subklass/sibling/implementor links at end of marking.
+ // Update subklass/sibling/implementor links at end of marking.
+ static void revisit_weak_klass_link(Klass* k);
+ // For weak refs clearing in MDO's
+ static void revisit_mdo(DataLayout* p);
};
class PreservedMark VALUE_OBJ_CLASS_SPEC {
--- a/src/share/vm/gc_interface/collectedHeap.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/gc_interface/collectedHeap.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -239,6 +239,9 @@ class CollectedHeap : public CHeapObj {
return p == NULL || is_in_closed_subset(p);
}
+ // XXX is_permanent() and is_in_permanent() should be better named
+ // to distinguish one from the other.
+
// Returns "TRUE" if "p" is allocated as "permanent" data.
// If the heap does not use "permanent" data, returns the same
// value is_in_reserved() would return.
@@ -247,13 +250,17 @@ class CollectedHeap : public CHeapObj {
// space). If you need the more conservative answer use is_permanent().
virtual bool is_in_permanent(const void *p) const = 0;
+ bool is_in_permanent_or_null(const void *p) const {
+ return p == NULL || is_in_permanent(p);
+ }
+
// Returns "TRUE" if "p" is in the committed area of "permanent" data.
// If the heap does not use "permanent" data, returns the same
// value is_in() would return.
virtual bool is_permanent(const void *p) const = 0;
- bool is_in_permanent_or_null(const void *p) const {
- return p == NULL || is_in_permanent(p);
+ bool is_permanent_or_null(const void *p) const {
+ return p == NULL || is_permanent(p);
}
// Returns "TRUE" if "p" is a method oop in the
--- a/src/share/vm/includeDB_core Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/includeDB_core Thu Sep 10 09:04:41 2009 -0400
@@ -2684,6 +2684,7 @@ markOop.inline.hpp
markOop.inline.hpp markOop.hpp
markSweep.cpp compileBroker.hpp
+markSweep.cpp methodDataOop.hpp
markSweep.hpp collectedHeap.hpp
--- a/src/share/vm/interpreter/interpreterRuntime.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/interpreter/interpreterRuntime.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -849,8 +849,25 @@ static void trace_osr_request(methodHand
}
#endif // !PRODUCT
+nmethod* InterpreterRuntime::frequency_counter_overflow(JavaThread* thread, address branch_bcp) {
+ nmethod* nm = frequency_counter_overflow_inner(thread, branch_bcp);
+ assert(branch_bcp != NULL || nm == NULL, "always returns null for non OSR requests");
+ if (branch_bcp != NULL && nm != NULL) {
+ // This was a successful request for an OSR nmethod. Because
+ // frequency_counter_overflow_inner ends with a safepoint check,
+ // nm could have been unloaded so look it up again. It's unsafe
+ // to examine nm directly since it might have been freed and used
+ // for something else.
+ frame fr = thread->last_frame();
+ methodOop method = fr.interpreter_frame_method();
+ int bci = method->bci_from(fr.interpreter_frame_bcp());
+ nm = method->lookup_osr_nmethod_for(bci);
+ }
+ return nm;
+}
+
IRT_ENTRY(nmethod*,
- InterpreterRuntime::frequency_counter_overflow(JavaThread* thread, address branch_bcp))
+ InterpreterRuntime::frequency_counter_overflow_inner(JavaThread* thread, address branch_bcp))
// use UnlockFlagSaver to clear and restore the _do_not_unlock_if_synchronized
// flag, in case this method triggers classloading which will call into Java.
UnlockFlagSaver fs(thread);
@@ -923,7 +940,6 @@ IRT_ENTRY(nmethod*,
}
BiasedLocking::revoke(objects_to_revoke);
}
-
return osr_nm;
}
}
--- a/src/share/vm/interpreter/interpreterRuntime.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/interpreter/interpreterRuntime.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -48,6 +48,9 @@ class InterpreterRuntime: AllStatic {
static ConstantPoolCacheEntry* cache_entry_at(JavaThread *thread, int i) { return method(thread)->constants()->cache()->entry_at(i); }
static ConstantPoolCacheEntry* cache_entry(JavaThread *thread) { return cache_entry_at(thread, Bytes::get_native_u2(bcp(thread) + 1)); }
static void note_trap(JavaThread *thread, int reason, TRAPS);
+
+ // Inner work method for Interpreter's frequency counter overflow
+ static nmethod* frequency_counter_overflow_inner(JavaThread* thread, address branch_bcp);
public:
// Constants
--- a/src/share/vm/memory/cardTableModRefBS.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/memory/cardTableModRefBS.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -660,6 +660,29 @@ void CardTableModRefBS::verify_clean_reg
GuaranteeNotModClosure blk(this);
non_clean_card_iterate_work(mr, &blk, false);
}
+
+// To verify a MemRegion is entirely dirty this closure is passed to
+// dirty_card_iterate. If the region is dirty do_MemRegion will be
+// invoked only once with a MemRegion equal to the one being
+// verified.
+class GuaranteeDirtyClosure: public MemRegionClosure {
+ CardTableModRefBS* _ct;
+ MemRegion _mr;
+ bool _result;
+public:
+ GuaranteeDirtyClosure(CardTableModRefBS* ct, MemRegion mr)
+ : _ct(ct), _mr(mr), _result(false) {}
+ void do_MemRegion(MemRegion mr) {
+ _result = _mr.equals(mr);
+ }
+ bool result() const { return _result; }
+};
+
+void CardTableModRefBS::verify_dirty_region(MemRegion mr) {
+ GuaranteeDirtyClosure blk(this, mr);
+ dirty_card_iterate(mr, &blk);
+ guarantee(blk.result(), "Non-dirty cards in region that should be dirty");
+}
#endif
bool CardTableModRefBSForCTRS::card_will_be_scanned(jbyte cv) {
--- a/src/share/vm/memory/cardTableModRefBS.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/memory/cardTableModRefBS.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -456,6 +456,7 @@ public:
void verify_guard();
void verify_clean_region(MemRegion mr) PRODUCT_RETURN;
+ void verify_dirty_region(MemRegion mr) PRODUCT_RETURN;
static size_t par_chunk_heapword_alignment() {
return CardsPerStrideChunk * card_size_in_words;
--- a/src/share/vm/memory/genMarkSweep.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/memory/genMarkSweep.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -162,6 +162,9 @@ void GenMarkSweep::allocate_stacks() {
int size = SystemDictionary::number_of_classes() * 2;
_revisit_klass_stack = new (ResourceObj::C_HEAP) GrowableArray<Klass*>(size, true);
+ // (#klass/k)^2 for k ~ 10 appears to be a better fit, but this will have to do for
+ // now until we have had a chance to investigate a more optimal setting.
+ _revisit_mdo_stack = new (ResourceObj::C_HEAP) GrowableArray<DataLayout*>(2*size, true);
#ifdef VALIDATE_MARK_SWEEP
if (ValidateMarkSweep) {
@@ -206,6 +209,7 @@ void GenMarkSweep::deallocate_stacks() {
delete _marking_stack;
delete _revisit_klass_stack;
+ delete _revisit_mdo_stack;
#ifdef VALIDATE_MARK_SWEEP
if (ValidateMarkSweep) {
@@ -262,6 +266,10 @@ void GenMarkSweep::mark_sweep_phase1(int
follow_weak_klass_links();
assert(_marking_stack->is_empty(), "just drained");
+ // Visit memoized MDO's and clear any unmarked weak refs
+ follow_mdo_weak_refs();
+ assert(_marking_stack->is_empty(), "just drained");
+
// Visit symbol and interned string tables and delete unmarked oops
SymbolTable::unlink(&is_alive);
StringTable::unlink(&is_alive);
--- a/src/share/vm/memory/iterator.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/memory/iterator.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -25,6 +25,10 @@
# include "incls/_precompiled.incl"
# include "incls/_iterator.cpp.incl"
+#ifdef ASSERT
+bool OopClosure::_must_remember_klasses = false;
+#endif
+
void ObjectToOopClosure::do_object(oop obj) {
obj->oop_iterate(_cl);
}
@@ -32,3 +36,13 @@ void VoidClosure::do_void() {
void VoidClosure::do_void() {
ShouldNotCallThis();
}
+
+#ifdef ASSERT
+bool OopClosure::must_remember_klasses() {
+ return _must_remember_klasses;
+}
+void OopClosure::set_must_remember_klasses(bool v) {
+ _must_remember_klasses = v;
+}
+#endif
+
--- a/src/share/vm/memory/iterator.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/memory/iterator.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -25,6 +25,7 @@
// The following classes are C++ `closures` for iterating over objects, roots and spaces
class ReferenceProcessor;
+class DataLayout;
// Closure provides abortability.
@@ -54,8 +55,19 @@ class OopClosure : public Closure {
// In support of post-processing of weak links of KlassKlass objects;
// see KlassKlass::oop_oop_iterate().
- virtual const bool should_remember_klasses() const { return false; }
+
+ virtual const bool should_remember_klasses() const {
+ assert(!must_remember_klasses(), "Should have overriden this method.");
+ return false;
+ }
+
virtual void remember_klass(Klass* k) { /* do nothing */ }
+
+ // In support of post-processing of weak references in
+ // ProfileData (MethodDataOop) objects; see, for example,
+ // VirtualCallData::oop_iterate().
+ virtual const bool should_remember_mdo() const { return false; }
+ virtual void remember_mdo(DataLayout* v) { /* do nothing */ }
// If "true", invoke on nmethods (when scanning compiled frames).
virtual const bool do_nmethods() const { return false; }
@@ -74,6 +86,12 @@ class OopClosure : public Closure {
// location without an intervening "major reset" (like the end of a GC).
virtual bool idempotent() { return false; }
virtual bool apply_to_weak_ref_discovered_field() { return false; }
+
+#ifdef ASSERT
+ static bool _must_remember_klasses;
+ static bool must_remember_klasses();
+ static void set_must_remember_klasses(bool v);
+#endif
};
// ObjectClosure is used for iterating through an object space
@@ -219,3 +237,38 @@ public:
// correct length.
virtual void do_tag(int tag) = 0;
};
+
+#ifdef ASSERT
+// This class is used to flag phases of a collection that
+// can unload classes and which should override the
+// should_remember_klasses() and remember_klass() of OopClosure.
+// The _must_remember_klasses is set in the contructor and restored
+// in the destructor. _must_remember_klasses is checked in assertions
+// in the OopClosure implementations of should_remember_klasses() and
+// remember_klass() and the expectation is that the OopClosure
+// implementation should not be in use if _must_remember_klasses is set.
+// Instances of RememberKlassesChecker can be place in
+// marking phases of collections which can do class unloading.
+// RememberKlassesChecker can be passed "false" to turn off checking.
+// It is used by CMS when CMS yields to a different collector.
+class RememberKlassesChecker: StackObj {
+ bool _state;
+ bool _skip;
+ public:
+ RememberKlassesChecker(bool checking_on) : _state(false), _skip(false) {
+ _skip = !(ClassUnloading && !UseConcMarkSweepGC ||
+ CMSClassUnloadingEnabled && UseConcMarkSweepGC);
+ if (_skip) {
+ return;
+ }
+ _state = OopClosure::must_remember_klasses();
+ OopClosure::set_must_remember_klasses(checking_on);
+ }
+ ~RememberKlassesChecker() {
+ if (_skip) {
+ return;
+ }
+ OopClosure::set_must_remember_klasses(_state);
+ }
+};
+#endif // ASSERT
--- a/src/share/vm/memory/oopFactory.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/memory/oopFactory.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -98,10 +98,12 @@ constantPoolCacheOop oopFactory::new_con
}
-klassOop oopFactory::new_instanceKlass(int vtable_len, int itable_len, int static_field_size,
- int nonstatic_oop_map_size, ReferenceType rt, TRAPS) {
+klassOop oopFactory::new_instanceKlass(int vtable_len, int itable_len,
+ int static_field_size,
+ unsigned int nonstatic_oop_map_count,
+ ReferenceType rt, TRAPS) {
instanceKlassKlass* ikk = instanceKlassKlass::cast(Universe::instanceKlassKlassObj());
- return ikk->allocate_instance_klass(vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, CHECK_NULL);
+ return ikk->allocate_instance_klass(vtable_len, itable_len, static_field_size, nonstatic_oop_map_count, rt, CHECK_NULL);
}
--- a/src/share/vm/memory/oopFactory.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/memory/oopFactory.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -89,8 +89,10 @@ class oopFactory: AllStatic {
TRAPS);
// Instance classes
- static klassOop new_instanceKlass(int vtable_len, int itable_len, int static_field_size,
- int nonstatic_oop_map_size, ReferenceType rt, TRAPS);
+ static klassOop new_instanceKlass(int vtable_len, int itable_len,
+ int static_field_size,
+ unsigned int nonstatic_oop_map_count,
+ ReferenceType rt, TRAPS);
// Methods
private:
--- a/src/share/vm/memory/referenceProcessor.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/memory/referenceProcessor.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -1231,6 +1231,11 @@ void ReferenceProcessor::preclean_discov
NOT_PRODUCT(verify_ok_to_handle_reflists());
+#ifdef ASSERT
+ bool must_remember_klasses = ClassUnloading && !UseConcMarkSweepGC ||
+ CMSClassUnloadingEnabled && UseConcMarkSweepGC;
+ RememberKlassesChecker mx(must_remember_klasses);
+#endif
// Soft references
{
TraceTime tt("Preclean SoftReferences", PrintGCDetails && PrintReferenceGC,
--- a/src/share/vm/oops/instanceKlass.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/oops/instanceKlass.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -1397,18 +1397,18 @@ template <class T> void assert_nothing(T
/* Compute oopmap block range. The common case \
is nonstatic_oop_map_size == 1. */ \
OopMapBlock* map = start_of_nonstatic_oop_maps(); \
- OopMapBlock* const end_map = map + nonstatic_oop_map_size(); \
+ OopMapBlock* const end_map = map + nonstatic_oop_map_count(); \
if (UseCompressedOops) { \
while (map < end_map) { \
InstanceKlass_SPECIALIZED_OOP_ITERATE(narrowOop, \
- obj->obj_field_addr<narrowOop>(map->offset()), map->length(), \
+ obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \
do_oop, assert_fn) \
++map; \
} \
} else { \
while (map < end_map) { \
InstanceKlass_SPECIALIZED_OOP_ITERATE(oop, \
- obj->obj_field_addr<oop>(map->offset()), map->length(), \
+ obj->obj_field_addr<oop>(map->offset()), map->count(), \
do_oop, assert_fn) \
++map; \
} \
@@ -1418,19 +1418,19 @@ template <class T> void assert_nothing(T
#define InstanceKlass_OOP_MAP_REVERSE_ITERATE(obj, do_oop, assert_fn) \
{ \
OopMapBlock* const start_map = start_of_nonstatic_oop_maps(); \
- OopMapBlock* map = start_map + nonstatic_oop_map_size(); \
+ OopMapBlock* map = start_map + nonstatic_oop_map_count(); \
if (UseCompressedOops) { \
while (start_map < map) { \
--map; \
InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE(narrowOop, \
- obj->obj_field_addr<narrowOop>(map->offset()), map->length(), \
+ obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \
do_oop, assert_fn) \
} \
} else { \
while (start_map < map) { \
--map; \
InstanceKlass_SPECIALIZED_OOP_REVERSE_ITERATE(oop, \
- obj->obj_field_addr<oop>(map->offset()), map->length(), \
+ obj->obj_field_addr<oop>(map->offset()), map->count(), \
do_oop, assert_fn) \
} \
} \
@@ -1444,11 +1444,11 @@ template <class T> void assert_nothing(T
usually non-existent extra overhead of examining \
all the maps. */ \
OopMapBlock* map = start_of_nonstatic_oop_maps(); \
- OopMapBlock* const end_map = map + nonstatic_oop_map_size(); \
+ OopMapBlock* const end_map = map + nonstatic_oop_map_count(); \
if (UseCompressedOops) { \
while (map < end_map) { \
InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(narrowOop, \
- obj->obj_field_addr<narrowOop>(map->offset()), map->length(), \
+ obj->obj_field_addr<narrowOop>(map->offset()), map->count(), \
low, high, \
do_oop, assert_fn) \
++map; \
@@ -1456,7 +1456,7 @@ template <class T> void assert_nothing(T
} else { \
while (map < end_map) { \
InstanceKlass_SPECIALIZED_BOUNDED_OOP_ITERATE(oop, \
- obj->obj_field_addr<oop>(map->offset()), map->length(), \
+ obj->obj_field_addr<oop>(map->offset()), map->count(), \
low, high, \
do_oop, assert_fn) \
++map; \
@@ -2217,14 +2217,15 @@ void instanceKlass::verify_class_klass_n
first_time = false;
const int extra = java_lang_Class::number_of_fake_oop_fields;
guarantee(ik->nonstatic_field_size() == extra, "just checking");
- guarantee(ik->nonstatic_oop_map_size() == 1, "just checking");
+ guarantee(ik->nonstatic_oop_map_count() == 1, "just checking");
guarantee(ik->size_helper() == align_object_size(instanceOopDesc::header_size() + extra), "just checking");
// Check that the map is (2,extra)
int offset = java_lang_Class::klass_offset;
OopMapBlock* map = ik->start_of_nonstatic_oop_maps();
- guarantee(map->offset() == offset && map->length() == extra, "just checking");
+ guarantee(map->offset() == offset && map->count() == (unsigned int) extra,
+ "sanity");
}
}
--- a/src/share/vm/oops/instanceKlass.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/oops/instanceKlass.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -71,7 +71,6 @@
// forward declaration for class -- see below for definition
class SuperTypeClosure;
-class OopMapBlock;
class JNIid;
class jniIdMapBase;
class BreakpointInfo;
@@ -98,6 +97,29 @@ class FieldPrinter: public FieldClosure
void do_field(fieldDescriptor* fd);
};
#endif // !PRODUCT
+
+// ValueObjs embedded in klass. Describes where oops are located in instances of
+// this klass.
+class OopMapBlock VALUE_OBJ_CLASS_SPEC {
+ public:
+ // Byte offset of the first oop mapped by this block.
+ int offset() const { return _offset; }
+ void set_offset(int offset) { _offset = offset; }
+
+ // Number of oops in this block.
+ uint count() const { return _count; }
+ void set_count(uint count) { _count = count; }
+
+ // sizeof(OopMapBlock) in HeapWords.
+ static const int size_in_words() {
+ return align_size_up(int(sizeof(OopMapBlock)), HeapWordSize) >>
+ LogHeapWordSize;
+ }
+
+ private:
+ int _offset;
+ uint _count;
+};
class instanceKlass: public Klass {
friend class VMStructs;
@@ -191,7 +213,7 @@ class instanceKlass: public Klass {
int _nonstatic_field_size;
int _static_field_size; // number words used by static fields (oop and non-oop) in this klass
int _static_oop_field_size;// number of static oop fields in this klass
- int _nonstatic_oop_map_size;// number of nonstatic oop-map blocks allocated at end of this klass
+ int _nonstatic_oop_map_size;// size in words of nonstatic oop map blocks
bool _is_marked_dependent; // used for marking during flushing and deoptimization
bool _rewritten; // methods rewritten.
bool _has_nonstatic_fields; // for sizing with UseCompressedOops
@@ -424,8 +446,16 @@ class instanceKlass: public Klass {
void set_source_debug_extension(symbolOop n){ oop_store_without_check((oop*) &_source_debug_extension, (oop) n); }
// nonstatic oop-map blocks
- int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; }
- void set_nonstatic_oop_map_size(int size) { _nonstatic_oop_map_size = size; }
+ static int nonstatic_oop_map_size(unsigned int oop_map_count) {
+ return oop_map_count * OopMapBlock::size_in_words();
+ }
+ unsigned int nonstatic_oop_map_count() const {
+ return _nonstatic_oop_map_size / OopMapBlock::size_in_words();
+ }
+ int nonstatic_oop_map_size() const { return _nonstatic_oop_map_size; }
+ void set_nonstatic_oop_map_size(int words) {
+ _nonstatic_oop_map_size = words;
+ }
// RedefineClasses() support for previous versions:
void add_previous_version(instanceKlassHandle ikh, BitMap *emcp_methods,
@@ -839,21 +869,6 @@ inline u2 instanceKlass::next_method_idn
}
-// ValueObjs embedded in klass. Describes where oops are located in instances of this klass.
-
-class OopMapBlock VALUE_OBJ_CLASS_SPEC {
- private:
- jushort _offset; // Offset of first oop in oop-map block
- jushort _length; // Length of oop-map block
- public:
- // Accessors
- jushort offset() const { return _offset; }
- void set_offset(jushort offset) { _offset = offset; }
-
- jushort length() const { return _length; }
- void set_length(jushort length) { _length = length; }
-};
-
/* JNIid class for jfieldIDs only */
class JNIid: public CHeapObj {
friend class VMStructs;
--- a/src/share/vm/oops/instanceKlassKlass.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/oops/instanceKlassKlass.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -402,9 +402,14 @@ int instanceKlassKlass::oop_update_point
}
#endif // SERIALGC
-klassOop instanceKlassKlass::allocate_instance_klass(int vtable_len, int itable_len, int static_field_size,
- int nonstatic_oop_map_size, ReferenceType rt, TRAPS) {
-
+klassOop
+instanceKlassKlass::allocate_instance_klass(int vtable_len, int itable_len,
+ int static_field_size,
+ unsigned nonstatic_oop_map_count,
+ ReferenceType rt, TRAPS) {
+
+ const int nonstatic_oop_map_size =
+ instanceKlass::nonstatic_oop_map_size(nonstatic_oop_map_count);
int size = instanceKlass::object_size(align_object_offset(vtable_len) + align_object_offset(itable_len) + static_field_size + nonstatic_oop_map_size);
// Allocation
@@ -615,9 +620,9 @@ void instanceKlassKlass::oop_print_on(oo
st->print(BULLET"non-static oop maps: ");
OopMapBlock* map = ik->start_of_nonstatic_oop_maps();
- OopMapBlock* end_map = map + ik->nonstatic_oop_map_size();
+ OopMapBlock* end_map = map + ik->nonstatic_oop_map_count();
while (map < end_map) {
- st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->length() - 1));
+ st->print("%d-%d ", map->offset(), map->offset() + heapOopSize*(map->count() - 1));
map++;
}
st->cr();
--- a/src/share/vm/oops/instanceKlassKlass.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/oops/instanceKlassKlass.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -39,7 +39,7 @@ class instanceKlassKlass : public klassK
klassOop allocate_instance_klass(int vtable_len,
int itable_len,
int static_field_size,
- int nonstatic_oop_map_size,
+ unsigned int nonstatic_oop_map_count,
ReferenceType rt,
TRAPS);
--- a/src/share/vm/oops/instanceRefKlass.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/oops/instanceRefKlass.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -400,26 +400,26 @@ void instanceRefKlass::update_nonstatic_
assert(k == SystemDictionary::reference_klass() && first_time,
"Invalid update of maps");
debug_only(first_time = false);
- assert(ik->nonstatic_oop_map_size() == 1, "just checking");
+ assert(ik->nonstatic_oop_map_count() == 1, "just checking");
OopMapBlock* map = ik->start_of_nonstatic_oop_maps();
// Check that the current map is (2,4) - currently points at field with
// offset 2 (words) and has 4 map entries.
debug_only(int offset = java_lang_ref_Reference::referent_offset);
- debug_only(int length = ((java_lang_ref_Reference::discovered_offset -
+ debug_only(unsigned int count = ((java_lang_ref_Reference::discovered_offset -
java_lang_ref_Reference::referent_offset)/heapOopSize) + 1);
if (UseSharedSpaces) {
assert(map->offset() == java_lang_ref_Reference::queue_offset &&
- map->length() == 1, "just checking");
- } else {
- assert(map->offset() == offset && map->length() == length,
+ map->count() == 1, "just checking");
+ } else {
+ assert(map->offset() == offset && map->count() == count,
"just checking");
// Update map to (3,1) - point to offset of 3 (words) with 1 map entry.
map->set_offset(java_lang_ref_Reference::queue_offset);
- map->set_length(1);
+ map->set_count(1);
}
}
--- a/src/share/vm/oops/methodDataOop.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/oops/methodDataOop.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -49,6 +49,12 @@ void DataLayout::initialize(u1 tag, u2 b
}
}
+void DataLayout::follow_weak_refs(BoolObjectClosure* cl) {
+ ResourceMark m;
+ data_in()->follow_weak_refs(cl);
+}
+
+
// ==================================================================
// ProfileData
//
@@ -145,46 +151,105 @@ void JumpData::print_data_on(outputStrea
// which are used to store a type profile for the receiver of the check.
void ReceiverTypeData::follow_contents() {
- for (uint row = 0; row < row_limit(); row++) {
- if (receiver(row) != NULL) {
- MarkSweep::mark_and_push(adr_receiver(row));
- }
- }
+ // This is a set of weak references that need
+ // to be followed at the end of the strong marking
+ // phase. Memoize this object so it can be visited
+ // in the weak roots processing phase.
+ MarkSweep::revisit_mdo(data());
}
#ifndef SERIALGC
void ReceiverTypeData::follow_contents(ParCompactionManager* cm) {
- for (uint row = 0; row < row_limit(); row++) {
- if (receiver(row) != NULL) {
- PSParallelCompact::mark_and_push(cm, adr_receiver(row));
- }
- }
+ // This is a set of weak references that need
+ // to be followed at the end of the strong marking
+ // phase. Memoize this object so it can be visited
+ // in the weak roots processing phase.
+ PSParallelCompact::revisit_mdo(cm, data());
}
#endif // SERIALGC
void ReceiverTypeData::oop_iterate(OopClosure* blk) {
- for (uint row = 0; row < row_limit(); row++) {
- if (receiver(row) != NULL) {
- blk->do_oop(adr_receiver(row));
+ if (blk->should_remember_mdo()) {
+ // This is a set of weak references that need
+ // to be followed at the end of the strong marking
+ // phase. Memoize this object so it can be visited
+ // in the weak roots processing phase.
+ blk->remember_mdo(data());
+ } else { // normal scan
+ for (uint row = 0; row < row_limit(); row++) {
+ if (receiver(row) != NULL) {
+ oop* adr = adr_receiver(row);
+ blk->do_oop(adr);
+ }
}
}
}
void ReceiverTypeData::oop_iterate_m(OopClosure* blk, MemRegion mr) {
+ // Currently, this interface is called only during card-scanning for
+ // a young gen gc, in which case this object cannot contribute anything,
+ // since it does not contain any references that cross out of
+ // the perm gen. However, for future more general use we allow
+ // the possibility of calling for instance from more general
+ // iterators (for example, a future regionalized perm gen for G1,
+ // or the possibility of moving some references out of perm in
+ // the case of other collectors). In that case, you will need
+ // to relax or remove some of the assertions below.
+#ifdef ASSERT
+ // Verify that none of the embedded oop references cross out of
+ // this generation.
for (uint row = 0; row < row_limit(); row++) {
if (receiver(row) != NULL) {
oop* adr = adr_receiver(row);
- if (mr.contains(adr)) {
- blk->do_oop(adr);
+ CollectedHeap* h = Universe::heap();
+ assert(h->is_permanent(adr) && h->is_permanent_or_null(*adr), "Not intra-perm");
+ }
+ }
+#endif // ASSERT
+ assert(!blk->should_remember_mdo(), "Not expected to remember MDO");
+ return; // Nothing to do, see comment above
+#if 0
+ if (blk->should_remember_mdo()) {
+ // This is a set of weak references that need
+ // to be followed at the end of the strong marking
+ // phase. Memoize this object so it can be visited
+ // in the weak roots processing phase.
+ blk->remember_mdo(data());
+ } else { // normal scan
+ for (uint row = 0; row < row_limit(); row++) {
+ if (receiver(row) != NULL) {
+ oop* adr = adr_receiver(row);
+ if (mr.contains(adr)) {
+ blk->do_oop(adr);
+ } else if ((HeapWord*)adr >= mr.end()) {
+ // Test that the current cursor and the two ends of the range
+ // that we may have skipped iterating over are monotonically ordered;
+ // this is just a paranoid assertion, just in case represetations
+ // should change in the future rendering the short-circuit return
+ // here invalid.
+ assert((row+1 >= row_limit() || adr_receiver(row+1) > adr) &&
+ (row+2 >= row_limit() || adr_receiver(row_limit()-1) > adr_receiver(row+1)), "Reducing?");
+ break; // remaining should be outside this mr too
+ }
}
}
}
+#endif
}
void ReceiverTypeData::adjust_pointers() {
for (uint row = 0; row < row_limit(); row++) {
if (receiver(row) != NULL) {
MarkSweep::adjust_pointer(adr_receiver(row));
+ }
+ }
+}
+
+void ReceiverTypeData::follow_weak_refs(BoolObjectClosure* is_alive_cl) {
+ for (uint row = 0; row < row_limit(); row++) {
+ klassOop p = receiver(row);
+ if (p != NULL && !is_alive_cl->do_object_b(p)) {
+ clear_row(row);
}
}
}
@@ -625,30 +690,33 @@ ProfileData* methodDataOopDesc::data_at(
return NULL;
}
DataLayout* data_layout = data_layout_at(data_index);
-
- switch (data_layout->tag()) {
+ return data_layout->data_in();
+}
+
+ProfileData* DataLayout::data_in() {
+ switch (tag()) {
case DataLayout::no_tag:
default:
ShouldNotReachHere();
return NULL;
case DataLayout::bit_data_tag:
- return new BitData(data_layout);
+ return new BitData(this);
case DataLayout::counter_data_tag:
- return new CounterData(data_layout);
+ return new CounterData(this);
case DataLayout::jump_data_tag:
- return new JumpData(data_layout);
+ return new JumpData(this);
case DataLayout::receiver_type_data_tag:
- return new ReceiverTypeData(data_layout);
+ return new ReceiverTypeData(this);
case DataLayout::virtual_call_data_tag:
- return new VirtualCallData(data_layout);
+ return new VirtualCallData(this);
case DataLayout::ret_data_tag:
- return new RetData(data_layout);
+ return new RetData(this);
case DataLayout::branch_data_tag:
- return new BranchData(data_layout);
+ return new BranchData(this);
case DataLayout::multi_branch_data_tag:
- return new MultiBranchData(data_layout);
+ return new MultiBranchData(this);
case DataLayout::arg_info_data_tag:
- return new ArgInfoData(data_layout);
+ return new ArgInfoData(this);
};
}
--- a/src/share/vm/oops/methodDataOop.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/oops/methodDataOop.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -55,6 +55,9 @@ class BytecodeStream;
// with invocation counter incrementation. None of these races harm correct
// execution of the compiled code.
+// forward decl
+class ProfileData;
+
// DataLayout
//
// Overlay for generic profiling data.
@@ -231,6 +234,10 @@ public:
temp._header._struct._flags = byte_constant;
return temp._header._bits;
}
+
+ // GC support
+ ProfileData* data_in();
+ void follow_weak_refs(BoolObjectClosure* cl);
};
@@ -430,6 +437,7 @@ public:
virtual void oop_iterate(OopClosure* blk) {}
virtual void oop_iterate_m(OopClosure* blk, MemRegion mr) {}
virtual void adjust_pointers() {}
+ virtual void follow_weak_refs(BoolObjectClosure* is_alive_closure) {}
#ifndef SERIALGC
// Parallel old support
@@ -667,9 +675,25 @@ public:
return recv;
}
+ void set_receiver(uint row, oop p) {
+ assert((uint)row < row_limit(), "oob");
+ set_oop_at(receiver_cell_index(row), p);
+ }
+
uint receiver_count(uint row) {
assert(row < row_limit(), "oob");
return uint_at(receiver_count_cell_index(row));
+ }
+
+ void set_receiver_count(uint row, uint count) {
+ assert(row < row_limit(), "oob");
+ set_uint_at(receiver_count_cell_index(row), count);
+ }
+
+ void clear_row(uint row) {
+ assert(row < row_limit(), "oob");
+ set_receiver(row, NULL);
+ set_receiver_count(row, 0);
}
// Code generation support
@@ -688,6 +712,7 @@ public:
virtual void oop_iterate(OopClosure* blk);
virtual void oop_iterate_m(OopClosure* blk, MemRegion mr);
virtual void adjust_pointers();
+ virtual void follow_weak_refs(BoolObjectClosure* is_alive_closure);
#ifndef SERIALGC
// Parallel old support
--- a/src/share/vm/runtime/globals.hpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/runtime/globals.hpp Thu Sep 10 09:04:41 2009 -0400
@@ -1707,6 +1707,9 @@ class CommandLineFlags {
product(bool, TLABStats, true, \
"Print various TLAB related information") \
\
+ product(bool, PrintRevisitStats, false, \
+ "Print revisit (klass and MDO) stack related information") \
+ \
product_pd(bool, NeverActAsServerClassMachine, \
"Never act like a server-class machine") \
\
--- a/src/share/vm/runtime/sweeper.cpp Tue Sep 08 09:02:48 2009 +0100
+++ b/src/share/vm/runtime/sweeper.cpp Thu Sep 10 09:04:41 2009 -0400
@@ -125,8 +125,14 @@ void NMethodSweeper::process_nmethod(nme
// there are no inline caches that referes to it.
if (nm->is_marked_for_reclamation()) {
assert(!nm->is_locked_by_vm(), "must not flush locked nmethods");
+ if (PrintMethodFlushing && Verbose) {
+ tty->print_cr("### Nmethod 0x%x (marked for reclamation) being flushed", nm);
+ }
nm->flush();
} else {
+ if (PrintMethodFlushing && Verbose) {
+ tty->print_cr("### Nmethod 0x%x (zombie) being marked for reclamation", nm);
+ }
nm->mark_for_reclamation();
_rescan = true;
}
@@ -134,6 +140,9 @@ void NMethodSweeper::process_nmethod(nme
// If there is no current activations of this method on the
// stack we can safely convert it to a zombie method
if (nm->can_not_entrant_be_converted()) {
+ if (PrintMethodFlushing && Verbose) {
+ tty->print_cr("### Nmethod 0x%x (not entrant) being made zombie", nm);
+ }
nm->make_zombie();
_rescan = true;
} else {
@@ -146,7 +155,9 @@ void NMethodSweeper::process_nmethod(nme
}
} else if (nm->is_unloaded()) {
// Unloaded code, just make it a zombie
- if (nm->is_osr_only_method()) {
+ if (PrintMethodFlushing && Verbose)
+ tty->print_cr("### Nmethod 0x%x (unloaded) being made zombie", nm);
+ if (nm->is_osr_method()) {
// No inline caches will ever point to osr methods, so we can just remove it
nm->flush();
} else {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/test/gc/6845368/bigobj.java Thu Sep 10 09:04:41 2009 -0400
@@ -0,0 +1,65563 @@
+/*
+ @test
+ @bug 6845368
+ @summary ensure gc updates references > 64K bytes from the start of the obj
+ @author John Coomes
+ @run main/othervm -Xmx64m bigobj
+*/
+
+// Allocate an object with a block of reference fields that starts more
+// than 64K bytes from the start of the object. This is done with
+// inheritance because VMs typically rearrange the order fields appear in
+// memory, and group fields of the same type together within an object (i.e.,
+// in a single object, all reference fields could be put into a block near the
+// start of the object).
+//
+// A block of reference fields > 64K bytes from the start of the object would
+// cause HotSpot's OopMapBlock _offset field to overflow, so any references in
+// that block would not be updated properly after GC.
+//
+// After allocating the big object, set a reference field within the
+// block to a known object, provoke GC, then make sure the field was
+// updated properly.
+
+public class bigobj extends bigparent {
+ public static void main(String argv[]) {
+ bigobj c = new bigobj();
+ Object o = c.o = new Object();
+
+ // Provoke GC so o is moved (if this is a moving collector).
+ for (int i = 0; i < 64 * 1024 * 1024; i++) new Object();
+
+ if (o != c.o) {
+ System.out.println("failed: o=" + o + " != c.o=" + c.o);
+ throw new RuntimeException("failed - c.o was not updated");
+ }
+ }
+
+ Object o;
+}
+
+class bigparent {
+ public long l00001;
+ public long l00002;
+ public long l00003;
+ public long l00004;
+ public long l00005;
+ public long l00006;
+ public long l00007;
+ public long l00008;
+ public long l00009;
+ public long l00010;
+ public long l00011;
+ public long l00012;
+ public long l00013;
+ public long l00014;
+ public long l00015;
+ public long l00016;
+ public long l00017;
+ public long l00018;
+ public long l00019;
+ public long l00020;
+ public long l00021;
+ public long l00022;
+ public long l00023;
+ public long l00024;
+ public long l00025;
+ public long l00026;
+ public long l00027;
+ public long l00028;
+ public long l00029;
+ public long l00030;
+ public long l00031;
+ public long l00032;
+ public long l00033;
+ public long l00034;
+ public long l00035;
+ public long l00036;
+ public long l00037;
+ public long l00038;
+ public long l00039;
+ public long l00040;
+ public long l00041;
+ public long l00042;
+ public long l00043;
+ public long l00044;
+ public long l00045;
+ public long l00046;
+ public long l00047;
+ public long l00048;
+ public long l00049;
+ public long l00050;
+ public long l00051;
+ public long l00052;
+ public long l00053;
+ public long l00054;
+ public long l00055;
+ public long l00056;
+ public long l00057;
+ public long l00058;
+ public long l00059;
+ public long l00060;
+ public long l00061;
+ public long l00062;
+ public long l00063;
+ public long l00064;
+ public long l00065;
+ public long l00066;
+ public long l00067;
+ public long l00068;
+ public long l00069;
+ public long l00070;
+ public long l00071;
+ public long l00072;
+ public long l00073;
+ public long l00074;
+ public long l00075;
+ public long l00076;
+ public long l00077;
+ public long l00078;
+ public long l00079;
+ public long l00080;
+ public long l00081;
+ public long l00082;
+ public long l00083;
+ public long l00084;
+ public long l00085;
+ public long l00086;
+ public long l00087;
+ public long l00088;
+ public long l00089;
+ public long l00090;
+ public long l00091;
+ public long l00092;
+ public long l00093;
+ public long l00094;
+ public long l00095;
+ public long l00096;
+ public long l00097;
+ public long l00098;
+ public long l00099;
+ public long l00100;
+ public long l00101;
+ public long l00102;
+ public long l00103;
+ public long l00104;
+ public long l00105;
+ public long l00106;
+ public long l00107;
+ public long l00108;
+ public long l00109;
+ public long l00110;
+ public long l00111;
+ public long l00112;
+ public long l00113;
+ public long l00114;
+ public long l00115;
+ public long l00116;
+ public long l00117;
+ public long l00118;
+ public long l00119;
+ public long l00120;
+ public long l00121;
+ public long l00122;
+ public long l00123;
+ public long l00124;
+ public long l00125;
+ public long l00126;
+ public long l00127;
+ public long l00128;
+ public long l00129;
+ public long l00130;
+ public long l00131;
+ public long l00132;
+ public long l00133;
+ public long l00134;
+ public long l00135;
+ public long l00136;
+ public long l00137;
+ public long l00138;
+ public long l00139;
+ public long l00140;
+ public long l00141;
+ public long l00142;
+ public long l00143;
+ public long l00144;
+ public long l00145;
+ public long l00146;
+ public long l00147;
+ public long l00148;
+ public long l00149;
+ public long l00150;
+ public long l00151;
+ public long l00152;
+ public long l00153;
+ public long l00154;
+ public long l00155;
+ public long l00156;
+ public long l00157;
+ public long l00158;
+ public long l00159;
+ public long l00160;
+ public long l00161;
+ public long l00162;
+ public long l00163;
+ public long l00164;
+ public long l00165;
+ public long l00166;
+ public long l00167;
+ public long l00168;
+ public long l00169;
+ public long l00170;
+ public long l00171;
+ public long l00172;
+ public long l00173;
+ public long l00174;
+ public long l00175;
+ public long l00176;
+ public long l00177;
+ public long l00178;
+ public long l00179;
+ public long l00180;
+ public long l00181;
+ public long l00182;
+ public long l00183;
+ public long l00184;
+ public long l00185;
+ public long l00186;
+ public long l00187;
+ public long l00188;
+ public long l00189;
+ public long l00190;
+ public long l00191;
+ public long l00192;
+ public long l00193;
+ public long l00194;
+ public long l00195;
+ public long l00196;
+ public long l00197;
+ public long l00198;
+ public long l00199;
+ public long l00200;
+ public long l00201;
+ public long l00202;
+ public long l00203;
+ public long l00204;
+ public long l00205;
+ public long l00206;
+ public long l00207;
+ public long l00208;
+ public long l00209;
+ public long l00210;
+ public long l00211;
+ public long l00212;
+ public long l00213;
+ public long l00214;
+ public long l00215;
+ public long l00216;
+ public long l00217;
+ public long l00218;
+ public long l00219;
+ public long l00220;
+ public long l00221;
+ public long l00222;
+ public long l00223;
+ public long l00224;
+ public long l00225;
+ public long l00226;
+ public long l00227;
+ public long l00228;
+ public long l00229;
+ public long l00230;
+ public long l00231;
+ public long l00232;
+ public long l00233;
+ public long l00234;
+ public long l00235;
+ public long l00236;
+ public long l00237;
+ public long l00238;
+ public long l00239;
+ public long l00240;
+ public long l00241;
+ public long l00242;
+ public long l00243;
+ public long l00244;
+ public long l00245;
+ public long l00246;
+ public long l00247;
+ public long l00248;
+ public long l00249;
+ public long l00250;
+ public long l00251;
+ public long l00252;
+ public long l00253;
+ public long l00254;
+ public long l00255;
+ public long l00256;
+ public long l00257;
+ public long l00258;
+ public long l00259;
+ public long l00260;
+ public long l00261;
+ public long l00262;
+ public long l00263;
+ public long l00264;
+ public long l00265;
+ public long l00266;
+ public long l00267;
+ public long l00268;
+ public long l00269;
+ public long l00270;
+ public long l00271;
+ public long l00272;
+ public long l00273;
+ public long l00274;
+ public long l00275;
+ public long l00276;
+ public long l00277;
+ public long l00278;
+ public long l00279;
+ public long l00280;
+ public long l00281;
+ public long l00282;
+ public long l00283;
+ public long l00284;
+ public long l00285;
+ public long l00286;
+ public long l00287;
+ public long l00288;
+ public long l00289;
+ public long l00290;
+ public long l00291;
+ public long l00292;
+ public long l00293;
+ public long l00294;
+ public long l00295;
+ public long l00296;
+ public long l00297;
+ public long l00298;
+ public long l00299;
+ public long l00300;
+ public long l00301;
+ public long l00302;
+ public long l00303;
+ public long l00304;
+ public long l00305;
+ public long l00306;
+ public long l00307;
+ public long l00308;
+ public long l00309;
+ public long l00310;
+ public long l00311;
+ public long l00312;
+ public long l00313;
+ public long l00314;
+ public long l00315;
+ public long l00316;
+ public long l00317;
+ public long l00318;
+ public long l00319;
+ public long l00320;
+ public long l00321;
+ public long l00322;
+ public long l00323;
+ public long l00324;
+ public long l00325;
+ public long l00326;
+ public long l00327;
+ public long l00328;
+ public long l00329;
+ public long l00330;
+ public long l00331;
+ public long l00332;
+ public long l00333;
+ public long l00334;
+ public long l00335;
+ public long l00336;
+ public long l00337;
+ public long l00338;
+ public long l00339;
+ public long l00340;
+ public long l00341;
+ public long l00342;
+ public long l00343;
+ public long l00344;
+ public long l00345;
+ public long l00346;
+ public long l00347;
+ public long l00348;
+ public long l00349;
+ public long l00350;
+ public long l00351;
+ public long l00352;
+ public long l00353;
+ public long l00354;
+ public long l00355;
+ public long l00356;
+ public long l00357;
+ public long l00358;
+ public long l00359;
+ public long l00360;
+ public long l00361;
+ public long l00362;
+ public long l00363;
+ public long l00364;
+ public long l00365;
+ public long l00366;
+ public long l00367;
+ public long l00368;
+ public long l00369;
+ public long l00370;
+ public long l00371;
+ public long l00372;
+ public long l00373;
+ public long l00374;
+ public long l00375;
+ public long l00376;
+ public long l00377;
+ public long l00378;
+ public long l00379;
+ public long l00380;
+ public long l00381;
+ public long l00382;
+ public long l00383;
+ public long l00384;
+ public long l00385;
+ public long l00386;
+ public long l00387;
+ public long l00388;
+ public long l00389;
+ public long l00390;
+ public long l00391;
+ public long l00392;
+ public long l00393;
+ public long l00394;
+ public long l00395;
+ public long l00396;
+ public long l00397;
+ public long l00398;
+ public long l00399;
+ public long l00400;
+ public long l00401;
+ public long l00402;
+ public long l00403;
+ public long l00404;
+ public long l00405;
+ public long l00406;
+ public long l00407;
+ public long l00408;
+ public long l00409;
+ public long l00410;
+ public long l00411;
+ public long l00412;
+ public long l00413;
+ public long l00414;
+ public long l00415;
+ public long l00416;
+ public long l00417;
+ public long l00418;
+ public long l00419;
+ public long l00420;
+ public long l00421;
+ public long l00422;
+ public long l00423;
+ public long l00424;
+ public long l00425;
+ public long l00426;
+ public long l00427;
+ public long l00428;
+ public long l00429;
+ public long l00430;
+ public long l00431;
+ public long l00432;
+ public long l00433;
+ public long l00434;
+ public long l00435;
+ public long l00436;
+ public long l00437;
+ public long l00438;
+ public long l00439;
+ public long l00440;
+ public long l00441;
+ public long l00442;
+ public long l00443;
+ public long l00444;
+ public long l00445;
+ public long l00446;
+ public long l00447;
+ public long l00448;
+ public long l00449;
+ public long l00450;
+ public long l00451;
+ public long l00452;
+ public long l00453;
+ public long l00454;
+ public long l00455;
+ public long l00456;
+ public long l00457;
+ public long l00458;
+ public long l00459;
+ public long l00460;
+ public long l00461;
+ public long l00462;
+ public long l00463;
+ public long l00464;
+ public long l00465;
+ public long l00466;
+ public long l00467;
+ public long l00468;
+ public long l00469;
+ public long l00470;
+ public long l00471;
+ public long l00472;
+ public long l00473;
+ public long l00474;
+ public long l00475;
+ public long l00476;
+ public long l00477;
+ public long l00478;
+ public long l00479;
+ public long l00480;
+ public long l00481;
+ public long l00482;
+ public long l00483;
+ public long l00484;
+ public long l00485;
+ public long l00486;
+ public long l00487;
+ public long l00488;
+ public long l00489;
+ public long l00490;
+ public long l00491;
+ public long l00492;
+ public long l00493;
+ public long l00494;
+ public long l00495;
+ public long l00496;
+ public long l00497;
+ public long l00498;
+ public long l00499;
+ public long l00500;
+ public long l00501;
+ public long l00502;
+ public long l00503;
+ public long l00504;
+ public long l00505;
+ public long l00506;
+ public long l00507;
+ public long l00508;
+ public long l00509;
+ public long l00510;
+ public long l00511;
+ public long l00512;
+ public long l00513;
+ public long l00514;
+ public long l00515;
+ public long l00516;
+ public long l00517;
+ public long l00518;
+ public long l00519;
+ public long l00520;
+ public long l00521;
+ public long l00522;
+ public long l00523;
+ public long l00524;
+ public long l00525;
+ public long l00526;
+ public long l00527;
+ public long l00528;
+ public long l00529;
+ public long l00530;
+ public long l00531;
+ public long l00532;
+ public long l00533;
+ public long l00534;
+ public long l00535;
+ public long l00536;
+ public long l00537;
+ public long l00538;
+ public long l00539;
+ public long l00540;
+ public long l00541;
+ public long l00542;
+ public long l00543;
+ public long l00544;
+ public long l00545;
+ public long l00546;
+ public long l00547;
+ public long l00548;
+ public long l00549;
+ public long l00550;
+ public long l00551;
+ public long l00552;
+ public long l00553;
+ public long l00554;
+ public long l00555;
+ public long l00556;
+ public long l00557;
+ public long l00558;
+ public long l00559;
+ public long l00560;
+ public long l00561;
+ public long l00562;
+ public long l00563;
+ public long l00564;
+ public long l00565;
+ public long l00566;
+ public long l00567;
+ public long l00568;
+ public long l00569;
+ public long l00570;
+ public long l00571;
+ public long l00572;
+ public long l00573;
+ public long l00574;
+ public long l00575;
+ public long l00576;
+ public long l00577;
+ public long l00578;
+ public long l00579;
+ public long l00580;
+ public long l00581;
+ public long l00582;
+ public long l00583;
+ public long l00584;
+ public long l00585;
+ public long l00586;
+ public long l00587;
+ public long l00588;
+ public long l00589;
+ public long l00590;
+ public long l00591;
+ public long l00592;
+ public long l00593;
+ public long l00594;
+ public long l00595;
+ public long l00596;
+ public long l00597;
+ public long l00598;
+ public long l00599;
+ public long l00600;
+ public long l00601;
+ public long l00602;
+ public long l00603;
+ public long l00604;
+ public long l00605;
+ public long l00606;
+ public long l00607;
+ public long l00608;
+ public long l00609;
+ public long l00610;
+ public long l00611;
+ public long l00612;
+ public long l00613;
+ public long l00614;
+ public long l00615;
+ public long l00616;
+ public long l00617;
+ public long l00618;
+ public long l00619;
+ public long l00620;
+ public long l00621;
+ public long l00622;
+ public long l00623;
+ public long l00624;
+ public long l00625;
+ public long l00626;
+ public long l00627;
+ public long l00628;
+ public long l00629;
+ public long l00630;
+ public long l00631;
+ public long l00632;
+ public long l00633;
+ public long l00634;
+ public long l00635;
+ public long l00636;
+ public long l00637;
+ public long l00638;
+ public long l00639;
+ public long l00640;
+ public long l00641;
+ public long l00642;
+ public long l00643;
+ public long l00644;
+ public long l00645;
+ public long l00646;
+ public long l00647;
+ public long l00648;
+ public long l00649;
+ public long l00650;
+ public long l00651;
+ public long l00652;
+ public long l00653;
+ public long l00654;
+ public long l00655;
+ public long l00656;
+ public long l00657;
+ public long l00658;
+ public long l00659;
+ public long l00660;
+ public long l00661;
+ public long l00662;
+ public long l00663;
+ public long l00664;
+ public long l00665;
+ public long l00666;
+ public long l00667;
+ public long l00668;
+ public long l00669;
+ public long l00670;
+ public long l00671;
+ public long l00672;
+ public long l00673;
+ public long l00674;
+ public long l00675;
+ public long l00676;
+ public long l00677;
+ public long l00678;
+ public long l00679;
+ public long l00680;
+ public long l00681;
+ public long l00682;
+ public long l00683;
+ public long l00684;
+ public long l00685;
+ public long l00686;
+ public long l00687;
+ public long l00688;
+ public long l00689;
+ public long l00690;
+ public long l00691;
+ public long l00692;
+ public long l00693;
+ public long l00694;
+ public long l00695;
+ public long l00696;
+ public long l00697;
+ public long l00698;
+ public long l00699;
+ public long l00700;
+ public long l00701;
+ public long l00702;
+ public long l00703;
+ public long l00704;
+ public long l00705;
+ public long l00706;
+ public long l00707;
+ public long l00708;
+ public long l00709;
+ public long l00710;
+ public long l00711;
+ public long l00712;
+ public long l00713;
+ public long l00714;
+ public long l00715;
+ public long l00716;
+ public long l00717;
+ public long l00718;
+ public long l00719;
+ public long l00720;
+ public long l00721;
+ public long l00722;
+ public long l00723;
+ public long l00724;
+ public long l00725;
+ public long l00726;
+ public long l00727;
+ public long l00728;
+ public long l00729;
+ public long l00730;
+ public long l00731;
+ public long l00732;
+ public long l00733;
+ public long l00734;
+ public long l00735;
+ public long l00736;
+ public long l00737;
+ public long l00738;
+ public long l00739;
+ public long l00740;
+ public long l00741;
+ public long l00742;
+ public long l00743;
+ public long l00744;
+ public long l00745;
+ public long l00746;
+ public long l00747;
+ public long l00748;
+ public long l00749;
+ public long l00750;
+ public long l00751;
+ public long l00752;
+ public long l00753;
+ public long l00754;
+ public long l00755;
+ public long l00756;
+ public long l00757;
+ public long l00758;
+ public long l00759;
+ public long l00760;
+ public long l00761;
+ public long l00762;
+ public long l00763;
+ public long l00764;
+ public long l00765;
+ public long l00766;
+ public long l00767;
+ public long l00768;
+ public long l00769;
+ public long l00770;
+ public long l00771;
+ public long l00772;
+ public long l00773;
+ public long l00774;
+ public long l00775;
+ public long l00776;
+ public long l00777;
+ public long l00778;
+ public long l00779;
+ public long l00780;
+ public long l00781;
+ public long l00782;
+ public long l00783;
+ public long l00784;
+ public long l00785;
+ public long l00786;
+ public long l00787;
+ public long l00788;
+ public long l00789;
+ public long l00790;
+ public long l00791;
+ public long l00792;
+ public long l00793;
+ public long l00794;
+ public long l00795;
+ public long l00796;
+ public long l00797;
+ public long l00798;
+ public long l00799;
+ public long l00800;
+ public long l00801;
+ public long l00802;
+ public long l00803;
+ public long l00804;
+ public long l00805;
+ public long l00806;
+ public long l00807;
+ public long l00808;
+ public long l00809;
+ public long l00810;
+ public long l00811;
+ public long l00812;
+ public long l00813;
+ public long l00814;
+ public long l00815;
+ public long l00816;
+ public long l00817;
+ public long l00818;
+ public long l00819;
+ public long l00820;
+ public long l00821;
+ public long l00822;
+ public long l00823;
+ public long l00824;
+ public long l00825;
+ public long l00826;
+ public long l00827;
+ public long l00828;
+ public long l00829;
+ public long l00830;
+ public long l00831;
+ public long l00832;
+ public long l00833;
+ public long l00834;
+ public long l00835;
+ public long l00836;
+ public long l00837;
+ public long l00838;
+ public long l00839;
+ public long l00840;
+ public long l00841;
+ public long l00842;
+ public long l00843;
+ public long l00844;
+ public long l00845;
+ public long l00846;
+ public long l00847;
+ public long l00848;
+ public long l00849;
+ public long l00850;
+ public long l00851;
+ public long l00852;
+ public long l00853;
+ public long l00854;
+ public long l00855;
+ public long l00856;
+ public long l00857;
+ public long l00858;
+ public long l00859;
+ public long l00860;
+ public long l00861;
+ public long l00862;
+ public long l00863;
+ public long l00864;
+ public long l00865;
+ public long l00866;
+ public long l00867;
+ public long l00868;
+ public long l00869;
+ public long l00870;
+ public long l00871;
+ public long l00872;
+ public long l00873;
+ public long l00874;
+ public long l00875;
+ public long l00876;
+ public long l00877;
+ public long l00878;
+ public long l00879;
+ public long l00880;
+ public long l00881;
+ public long l00882;
+ public long l00883;
+ public long l00884;
+ public long l00885;
+ public long l00886;
+ public long l00887;
+ public long l00888;
+ public long l00889;
+ public long l00890;
+ public long l00891;
+ public long l00892;
+ public long l00893;
+ public long l00894;
+ public long l00895;
+ public long l00896;
+ public long l00897;
+ public long l00898;
+ public long l00899;
+ public long l00900;
+ public long l00901;
+ public long l00902;
+ public long l00903;
+ public long l00904;
+ public long l00905;
+ public long l00906;
+ public long l00907;
+ public long l00908;
+ public long l00909;
+ public long l00910;
+ public long l00911;
+ public long l00912;
+ public long l00913;
+ public long l00914;
+ public long l00915;
+ public long l00916;
+ public long l00917;
+ public long l00918;
+ public long l00919;
+ public long l00920;
+ public long l00921;
+ public long l00922;
+ public long l00923;
+ public long l00924;
+ public long l00925;
+ public long l00926;
+ public long l00927;
+ public long l00928;
+ public long l00929;
+ public long l00930;
+ public long l00931;
+ public long l00932;
+ public long l00933;
+ public long l00934;
+ public long l00935;
+ public long l00936;
+ public long l00937;
+ public long l00938;
+ public long l00939;
+ public long l00940;
+ public long l00941;
+ public long l00942;
+ public long l00943;
+ public long l00944;
+ public long l00945;
+ public long l00946;
+ public long l00947;
+ public long l00948;
+ public long l00949;
+ public long l00950;
+ public long l00951;
+ public long l00952;
+ public long l00953;
+ public long l00954;
+ public long l00955;
+ public long l00956;
+ public long l00957;
+ public long l00958;
+ public long l00959;
+ public long l00960;
+ public long l00961;
+ public long l00962;
+ public long l00963;
+ public long l00964;
+ public long l00965;
+ public long l00966;
+ public long l00967;
+ public long l00968;
+ public long l00969;
+ public long l00970;
+ public long l00971;
+ public long l00972;
+ public long l00973;
+ public long l00974;
+ public long l00975;
+ public long l00976;
+ public long l00977;
+ public long l00978;
+ public long l00979;
+ public long l00980;
+ public long l00981;
+ public long l00982;
+ public long l00983;
+ public long l00984;
+ public long l00985;
+ public long l00986;
+ public long l00987;
+ public long l00988;
+ public long l00989;
+ public long l00990;
+ public long l00991;
+ public long l00992;
+ public long l00993;
+ public long l00994;
+ public long l00995;
+ public long l00996;
+ public long l00997;
+ public long l00998;
+ public long l00999;
+ public long l01000;
+ public long l01001;
+ public long l01002;
+ public long l01003;
+ public long l01004;
+ public long l01005;
+ public long l01006;
+ public long l01007;
+ public long l01008;
+ public long l01009;
+ public long l01010;
+ public long l01011;
+ public long l01012;
+ public long l01013;
+ public long l01014;
+ public long l01015;
+ public long l01016;
+ public long l01017;
+ public long l01018;
+ public long l01019;
+ public long l01020;
+ public long l01021;
+ public long l01022;
+ public long l01023;
+ public long l01024;
+ public long l01025;
+ public long l01026;
+ public long l01027;
+ public long l01028;
+ public long l01029;
+ public long l01030;
+ public long l01031;
+ public long l01032;
+ public long l01033;
+ public long l01034;
+ public long l01035;
+ public long l01036;
+ public long l01037;
+ public long l01038;
+ public long l01039;
+ public long l01040;
+ public long l01041;
+ public long l01042;
+ public long l01043;
+ public long l01044;
+ public long l01045;
+ public long l01046;
+ public long l01047;
+ public long l01048;
+ public long l01049;
+ public long l01050;
+ public long l01051;
+ public long l01052;
+ public long l01053;
+ public long l01054;
+ public long l01055;
+ public long l01056;
+ public long l01057;
+ public long l01058;
+ public long l01059;
+ public long l01060;
+ public long l01061;
+ public long l01062;
+ public long l01063;
+ public long l01064;
+ public long l01065;
+ public long l01066;
+ public long l01067;
+ public long l01068;
+ public long l01069;
+ public long l01070;
+ public long l01071;
+ public long l01072;
+ public long l01073;
+ public long l01074;
+ public long l01075;
+ public long l01076;
+ public long l01077;
+ public long l01078;
+ public long l01079;
+ public long l01080;
+ public long l01081;
+ public long l01082;
+ public long l01083;
+ public long l01084;
+ public long l01085;
+ public long l01086;
+ public long l01087;
+ public long l01088;
+ public long l01089;
+ public long l01090;
+ public long l01091;
+ public long l01092;
+ public long l01093;
+ public long l01094;
+ public long l01095;
+ public long l01096;
+ public long l01097;
+ public long l01098;
+ public long l01099;
+ public long l01100;
+ public long l01101;
+ public long l01102;
+ public long l01103;
+ public long l01104;
+ public long l01105;
+ public long l01106;
+ public long l01107;
+ public long l01108;
+ public long l01109;
+ public long l01110;
+ public long l01111;
+ public long l01112;
+ public long l01113;
+ public long l01114;
+ public long l01115;
+ public long l01116;
+ public long l01117;
+ public long l01118;
+ public long l01119;
+ public long l01120;
+ public long l01121;
+ public long l01122;
+ public long l01123;
+ public long l01124;
+ public long l01125;
+ public long l01126;
+ public long l01127;
+ public long l01128;
+ public long l01129;
+ public long l01130;
+ public long l01131;
+ public long l01132;
+ public long l01133;
+ public long l01134;
+ public long l01135;
+ public long l01136;
+ public long l01137;
+ public long l01138;
+ public long l01139;
+ public long l01140;
+ public long l01141;
+ public long l01142;
+ public long l01143;
+ public long l01144;
+ public long l01145;
+ public long l01146;
+ public long l01147;
+ public long l01148;
+ public long l01149;
+ public long l01150;
+ public long l01151;
+ public long l01152;
+ public long l01153;
+ public long l01154;
+ public long l01155;
+ public long l01156;
+ public long l01157;
+ public long l01158;
+ public long l01159;
+ public long l01160;
+ public long l01161;
+ public long l01162;
+ public long l01163;
+ public long l01164;
+ public long l01165;
+ public long l01166;
+ public long l01167;
+ public long l01168;
+ public long l01169;
+ public long l01170;
+ public long l01171;
+ public long l01172;
+ public long l01173;
+ public long l01174;
+ public long l01175;
+ public long l01176;
+ public long l01177;
+ public long l01178;
+ public long l01179;
+ public long l01180;
+ public long l01181;
+ public long l01182;
+ public long l01183;
+ public long l01184;
+ public long l01185;
+ public long l01186;
+ public long l01187;
+ public long l01188;
+ public long l01189;
+ public long l01190;
+ public long l01191;
+ public long l01192;
+ public long l01193;
+ public long l01194;
+ public long l01195;
+ public long l01196;
+ public long l01197;
+ public long l01198;
+ public long l01199;
+ public long l01200;
+ public long l01201;
+ public long l01202;
+ public long l01203;
+ public long l01204;
+ public long l01205;
+ public long l01206;
+ public long l01207;
+ public long l01208;
+ public long l01209;
+ public long l01210;
+ public long l01211;
+ public long l01212;
+ public long l01213;
+ public long l01214;
+ public long l01215;
+ public long l01216;
+ public long l01217;
+ public long l01218;
+ public long l01219;
+ public long l01220;
+ public long l01221;
+ public long l01222;
+ public long l01223;
+ public long l01224;
+ public long l01225;
+ public long l01226;
+ public long l01227;
+ public long l01228;
+ public long l01229;
+ public long l01230;
+ public long l01231;
+ public long l01232;
+ public long l01233;
+ public long l01234;
+ public long l01235;
+ public long l01236;
+ public long l01237;
+ public long l01238;
+ public long l01239;
+ public long l01240;
+ public long l01241;
+ public long l01242;
+ public long l01243;
+ public long l01244;
+ public long l01245;
+ public long l01246;
+ public long l01247;
+ public long l01248;
+ public long l01249;
+ public long l01250;
+ public long l01251;
+ public long l01252;
+ public long l01253;
+ public long l01254;
+ public long l01255;
+ public long l01256;
+ public long l01257;
+ public long l01258;
+ public long l01259;
+ public long l01260;
+ public long l01261;
+ public long l01262;
+ public long l01263;
+ public long l01264;
+ public long l01265;
+ public long l01266;
+ public long l01267;
+ public long l01268;
+ public long l01269;
+ public long l01270;
+ public long l01271;
+ public long l01272;
+ public long l01273;
+ public long l01274;
+ public long l01275;
+ public long l01276;
+ public long l01277;
+ public long l01278;
+ public long l01279;
+ public long l01280;
+ public long l01281;
+ public long l01282;
+ public long l01283;
+ public long l01284;
+ public long l01285;
+ public long l01286;
+ public long l01287;
+ public long l01288;
+ public long l01289;
+ public long l01290;
+ public long l01291;
+ public long l01292;
+ public long l01293;
+ public long l01294;
+ public long l01295;
+ public long l01296;
+ public long l01297;
+ public long l01298;
+ public long l01299;
+ public long l01300;
+ public long l01301;
+ public long l01302;
+ public long l01303;
+ public long l01304;
+ public long l01305;
+ public long l01306;
+ public long l01307;
+ public long l01308;
+ public long l01309;
+ public long l01310;
+ public long l01311;
+ public long l01312;
+ public long l01313;
+ public long l01314;
+ public long l01315;
+ public long l01316;
+ public long l01317;
+ public long l01318;
+ public long l01319;
+ public long l01320;
+ public long l01321;
+ public long l01322;
+ public long l01323;
+ public long l01324;
+ public long l01325;
+ public long l01326;
+ public long l01327;
+ public long l01328;
+ public long l01329;
+ public long l01330;
+ public long l01331;
+ public long l01332;
+ public long l01333;
+ public long l01334;
+ public long l01335;
+ public long l01336;
+ public long l01337;
+ public long l01338;
+ public long l01339;
+ public long l01340;
+ public long l01341;
+ public long l01342;
+ public long l01343;
+ public long l01344;
+ public long l01345;
+ public long l01346;
+ public long l01347;
+ public long l01348;
+ public long l01349;
+ public long l01350;
+ public long l01351;
+ public long l01352;
+ public long l01353;
+ public long l01354;
+ public long l01355;
+ public long l01356;
+ public long l01357;
+ public long l01358;
+ public long l01359;
+ public long l01360;
+ public long l01361;
+ public long l01362;
+ public long l01363;
+ public long l01364;
+ public long l01365;
+ public long l01366;
+ public long l01367;
+ public long l01368;
+ public long l01369;
+ public long l01370;
+ public long l01371;
+ public long l01372;
+ public long l01373;
+ public long l01374;
+ public long l01375;
+ public long l01376;
+ public long l01377;
+ public long l01378;
+ public long l01379;
+ public long l01380;
+ public long l01381;
+ public long l01382;
+ public long l01383;
+ public long l01384;
+ public long l01385;
+ public long l01386;
+ public long l01387;
+ public long l01388;
+ public long l01389;
+ public long l01390;
+ public long l01391;
+ public long l01392;
+ public long l01393;
+ public long l01394;
+ public long l01395;
+ public long l01396;
+ public long l01397;
+ public long l01398;
+ public long l01399;
+ public long l01400;
+ public long l01401;
+ public long l01402;
+ public long l01403;
+ public long l01404;
+ public long l01405;
+ public long l01406;
+ public long l01407;
+ public long l01408;
+ public long l01409;
+ public long l01410;
+ public long l01411;
+ public long l01412;
+ public long l01413;
+ public long l01414;
+ public long l01415;
+ public long l01416;
+ public long l01417;
+ public long l01418;
+ public long l01419;
+ public long l01420;
+ public long l01421;
+ public long l01422;
+ public long l01423;
+ public long l01424;
+ public long l01425;
+ public long l01426;
+ public long l01427;
+ public long l01428;
+ public long l01429;
+ public long l01430;
+ public long l01431;
+ public long l01432;
+ public long l01433;
+ public long l01434;
+ public long l01435;
+ public long l01436;
+ public long l01437;
+ public long l01438;
+ public long l01439;
+ public long l01440;
+ public long l01441;
+ public long l01442;
+ public long l01443;
+ public long l01444;
+ public long l01445;
+ public long l01446;
+ public long l01447;
+ public long l01448;
+ public long l01449;
+ public long l01450;
+ public long l01451;
+ public long l01452;
+ public long l01453;
+ public long l01454;
+ public long l01455;
+ public long l01456;
+ public long l01457;
+ public long l01458;
+ public long l01459;
+ public long l01460;
+ public long l01461;
+ public long l01462;
+ public long l01463;
+ public long l01464;
+ public long l01465;
+ public long l01466;
+ public long l01467;
+ public long l01468;
+ public long l01469;
+ public long l01470;
+ public long l01471;
+ public long l01472;
+ public long l01473;
+ public long l01474;
+ public long l01475;
+ public long l01476;
+ public long l01477;
+ public long l01478;
+ public long l01479;
+ public long l01480;
+ public long l01481;
+ public long l01482;
+ public long l01483;
+ public long l01484;
+ public long l01485;
+ public long l01486;
+ public long l01487;
+ public long l01488;
+ public long l01489;
+ public long l01490;
+ public long l01491;
+ public long l01492;
+ public long l01493;
+ public long l01494;
+ public long l01495;
+ public long l01496;
+ public long l01497;
+ public long l01498;
+ public long l01499;
+ public long l01500;
+ public long l01501;
+ public long l01502;
+ public long l01503;
+ public long l01504;
+ public long l01505;
+ public long l01506;
+ public long l01507;
+ public long l01508;
+ public long l01509;
+ public long l01510;
+ public long l01511;
+ public long l01512;
+ public long l01513;
+ public long l01514;
+ public long l01515;
+ public long l01516;
+ public long l01517;
+ public long l01518;
+ public long l01519;
+ public long l01520;
+ public long l01521;
+ public long l01522;
+ public long l01523;
+ public long l01524;
+ public long l01525;
+ public long l01526;
+ public long l01527;
+ public long l01528;
+ public long l01529;
+ public long l01530;
+ public long l01531;
+ public long l01532;
+ public long l01533;
+ public long l01534;
+ public long l01535;
+ public long l01536;
+ public long l01537;
+ public long l01538;
+ public long l01539;
+ public long l01540;
+ public long l01541;
+ public long l01542;
+ public long l01543;
+ public long l01544;
+ public long l01545;
+ public long l01546;
+ public long l01547;
+ public long l01548;
+ public long l01549;
+ public long l01550;
+ public long l01551;
+ public long l01552;
+ public long l01553;
+ public long l01554;
+ public long l01555;
+ public long l01556;
+ public long l01557;
+ public long l01558;
+ public long l01559;
+ public long l01560;
+ public long l01561;
+ public long l01562;
+ public long l01563;
+ public long l01564;
+ public long l01565;
+ public long l01566;
+ public long l01567;
+ public long l01568;
+ public long l01569;
+ public long l01570;
+ public long l01571;
+ public long l01572;
+ public long l01573;
+ public long l01574;
+ public long l01575;
+ public long l01576;
+ public long l01577;
+ public long l01578;
+ public long l01579;
+ public long l01580;
+ public long l01581;
+ public long l01582;
+ public long l01583;
+ public long l01584;
+ public long l01585;
+ public long l01586;
+ public long l01587;
+ public long l01588;
+ public long l01589;
+ public long l01590;
+ public long l01591;
+ public long l01592;
+ public long l01593;
+ public long l01594;
+ public long l01595;
+ public long l01596;
+ public long l01597;
+ public long l01598;
+ public long l01599;
+ public long l01600;
+ public long l01601;
+ public long l01602;
+ public long l01603;
+ public long l01604;
+ public long l01605;
+ public long l01606;
+ public long l01607;
+ public long l01608;
+ public long l01609;
+ public long l01610;
+ public long l01611;
+ public long l01612;
+ public long l01613;
+ public long l01614;
+ public long l01615;
+ public long l01616;
+ public long l01617;
+ public long l01618;
+ public long l01619;
+ public long l01620;
+ public long l01621;
+ public long l01622;
+ public long l01623;
+ public long l01624;
+ public long l01625;
+ public long l01626;
+ public long l01627;
+ public long l01628;
+ public long l01629;
+ public long l01630;
+ public long l01631;
+ public long l01632;
+ public long l01633;
+ public long l01634;
+ public long l01635;
+ public long l01636;
+ public long l01637;
+ public long l01638;
+ public long l01639;
+ public long l01640;
+ public long l01641;
+ public long l01642;
+ public long l01643;
+ public long l01644;
+ public long l01645;
+ public long l01646;
+ public long l01647;
+ public long l01648;
+ public long l01649;
+ public long l01650;
+ public long l01651;
+ public long l01652;
+ public long l01653;
+ public long l01654;
+ public long l01655;
+ public long l01656;
+ public long l01657;
+ public long l01658;
+ public long l01659;
+ public long l01660;
+ public long l01661;
+ public long l01662;
+ public long l01663;
+ public long l01664;
+ public long l01665;
+ public long l01666;
+ public long l01667;
+ public long l01668;
+ public long l01669;
+ public long l01670;
+ public long l01671;
+ public long l01672;
+ public long l01673;
+ public long l01674;
+ public long l01675;
+ public long l01676;
+ public long l01677;
+ public long l01678;
+ public long l01679;
+ public long l01680;
+ public long l01681;
+ public long l01682;
+ public long l01683;
+ public long l01684;
+ public long l01685;
+ public long l01686;
+ public long l01687;
+ public long l01688;
+ public long l01689;
+ public long l01690;
+ public long l01691;
+ public long l01692;
+ public long l01693;
+ public long l01694;
+ public long l01695;
+ public long l01696;
+ public long l01697;
+ public long l01698;
+ public long l01699;
+ public long l01700;
+ public long l01701;
+ public long l01702;
+ public long l01703;
+ public long l01704;
+ public long l01705;
+ public long l01706;
+ public long l01707;
+ public long l01708;
+ public long l01709;
+ public long l01710;
+ public long l01711;
+ public long l01712;
+ public long l01713;
+ public long l01714;
+ public long l01715;
+ public long l01716;
+ public long l01717;
+ public long l01718;
+ public long l01719;
+ public long l01720;
+ public long l01721;
+ public long l01722;
+ public long l01723;
+ public long l01724;
+ public long l01725;
+ public long l01726;
+ public long l01727;
+ public long l01728;
+ public long l01729;
+ public long l01730;
+ public long l01731;
+ public long l01732;
+ public long l01733;
+ public long l01734;
+ public long l01735;
+ public long l01736;
+ public long l01737;
+ public long l01738;
+ public long l01739;
+ public long l01740;
+ public long l01741;
+ public long l01742;
+ public long l01743;
+ public long l01744;
+ public long l01745;
+ public long l01746;
+ public long l01747;
+ public long l01748;
+ public long l01749;
+ public long l01750;
+ public long l01751;
+ public long l01752;
+ public long l01753;
+ public long l01754;
+ public long l01755;
+ public long l01756;
+ public long l01757;
+ public long l01758;
+ public long l01759;
+ public long l01760;
+ public long l01761;
+ public long l01762;
+ public long l01763;
+ public long l01764;
+ public long l01765;
+ public long l01766;
+ public long l01767;
+ public long l01768;
+ public long l01769;
+ public long l01770;
+ public long l01771;
+ public long l01772;
+ public long l01773;
+ public long l01774;
+ public long l01775;
+ public long l01776;
+ public long l01777;
+ public long l01778;
+ public long l01779;
+ public long l01780;
+ public long l01781;
+ public long l01782;
+ public long l01783;
+ public long l01784;
+ public long l01785;
+ public long l01786;
+ public long l01787;
+ public long l01788;
+ public long l01789;
+ public long l01790;
+ public long l01791;
+ public long l01792;
+ public long l01793;
+ public long l01794;
+ public long l01795;
+ public long l01796;
+ public long l01797;
+ public long l01798;
+ public long l01799;
+ public long l01800;
+ public long l01801;
+ public long l01802;
+ public long l01803;
+ public long l01804;
+ public long l01805;
+ public long l01806;
+ public long l01807;
+ public long l01808;
+ public long l01809;
+ public long l01810;
+ public long l01811;
+ public long l01812;
+ public long l01813;
+ public long l01814;
+ public long l01815;
+ public long l01816;
+ public long l01817;
+ public long l01818;
+ public long l01819;
+ public long l01820;
+ public long l01821;
+ public long l01822;
+ public long l01823;
+ public long l01824;
+ public long l01825;
+ public long l01826;
+ public long l01827;
+ public long l01828;
+ public long l01829;
+ public long l01830;
+ public long l01831;
+ public long l01832;
+ public long l01833;
+ public long l01834;
+ public long l01835;
+ public long l01836;
+ public long l01837;
+ public long l01838;
+ public long l01839;
+ public long l01840;
+ public long l01841;
+ public long l01842;
+ public long l01843;
+ public long l01844;
+ public long l01845;
+ public long l01846;
+ public long l01847;
+ public long l01848;
+ public long l01849;
+ public long l01850;
+ public long l01851;
+ public long l01852;
+ public long l01853;
+ public long l01854;
+ public long l01855;
+ public long l01856;
+ public long l01857;
+ public long l01858;
+ public long l01859;
+ public long l01860;
+ public long l01861;
+ public long l01862;
+ public long l01863;
+ public long l01864;
+ public long l01865;
+ public long l01866;
+ public long l01867;
+ public long l01868;
+ public long l01869;
+ public long l01870;
+ public long l01871;
+ public long l01872;
+ public long l01873;
+ public long l01874;
+ public long l01875;
+ public long l01876;
+ public long l01877;
+ public long l01878;
+ public long l01879;
+ public long l01880;
+ public long l01881;
+ public long l01882;
+ public long l01883;
+ public long l01884;
+ public long l01885;
+ public long l01886;
+ public long l01887;
+ public long l01888;
+ public long l01889;
+ public long l01890;
+ public long l01891;
+ public long l01892;
+ public long l01893;
+ public long l01894;
+ public long l01895;
+ public long l01896;
+ public long l01897;
+ public long l01898;
+ public long l01899;
+ public long l01900;
+ public long l01901;
+ public long l01902;
+ public long l01903;
+ public long l01904;
+ public long l01905;
+ public long l01906;
+ public long l01907;
+ public long l01908;
+ public long l01909;
+ public long l01910;
+ public long l01911;
+ public long l01912;
+ public long l01913;
+ public long l01914;
+ public long l01915;
+ public long l01916;
+ public long l01917;
+ public long l01918;
+ public long l01919;
+ public long l01920;
+ public long l01921;
+ public long l01922;
+ public long l01923;
+ public long l01924;
+ public long l01925;
+ public long l01926;
+ public long l01927;
+ public long l01928;
+ public long l01929;
+ public long l01930;
+ public long l01931;
+ public long l01932;
+ public long l01933;
+ public long l01934;
+ public long l01935;
+ public long l01936;
+ public long l01937;
+ public long l01938;
+ public long l01939;
+ public long l01940;
+ public long l01941;
+ public long l01942;
+ public long l01943;
+ public long l01944;
+ public long l01945;
+ public long l01946;
+ public long l01947;
+ public long l01948;
+ public long l01949;
+ public long l01950;
+ public long l01951;
+ public long l01952;
+ public long l01953;
+ public long l01954;
+ public long l01955;
+ public long l01956;
+ public long l01957;
+ public long l01958;
+ public long l01959;
+ public long l01960;
+ public long l01961;
+ public long l01962;
+ public long l01963;
+ public long l01964;
+ public long l01965;
+ public long l01966;
+ public long l01967;
+ public long l01968;
+ public long l01969;
+ public long l01970;
+ public long l01971;
+ public long l01972;
+ public long l01973;
+ public long l01974;
+ public long l01975;
+ public long l01976;
+ public long l01977;
+ public long l01978;
+ public long l01979;
+ public long l01980;
+ public long l01981;
+ public long l01982;
+ public long l01983;
+ public long l01984;
+ public long l01985;
+ public long l01986;
+ public long l01987;
+ public long l01988;
+ public long l01989;
+ public long l01990;
+ public long l01991;
+ public long l01992;
+ public long l01993;
+ public long l01994;
+ public long l01995;
+ public long l01996;
+ public long l01997;
+ public long l01998;
+ public long l01999;
+ public long l02000;
+ public long l02001;
+ public long l02002;
+ public long l02003;
+ public long l02004;
+ public long l02005;
+ public long l02006;
+ public long l02007;
+ public long l02008;
+ public long l02009;
+ public long l02010;
+ public long l02011;
+ public long l02012;
+ public long l02013;
+ public long l02014;
+ public long l02015;
+ public long l02016;
+ public long l02017;
+ public long l02018;
+ public long l02019;
+ public long l02020;
+ public long l02021;
+ public long l02022;
+ public long l02023;
+ public long l02024;
+ public long l02025;
+ public long l02026;
+ public long l02027;
+ public long l02028;
+ public long l02029;
+ public long l02030;
+ public long l02031;
+ public long l02032;
+ public long l02033;
+ public long l02034;
+ public long l02035;
+ public long l02036;
+ public long l02037;
+ public long l02038;
+ public long l02039;
+ public long l02040;
+ public long l02041;
+ public long l02042;
+ public long l02043;
+ public long l02044;
+ public long l02045;
+ public long l02046;
+ public long l02047;
+ public long l02048;
+ public long l02049;
+ public long l02050;
+ public long l02051;
+ public long l02052;
+ public long l02053;
+ public long l02054;
+ public long l02055;
+ public long l02056;
+ public long l02057;
+ public long l02058;
+ public long l02059;
+ public long l02060;
+ public long l02061;
+ public long l02062;
+ public long l02063;
+ public long l02064;
+ public long l02065;
+ public long l02066;
+ public long l02067;
+ public long l02068;
+ public long l02069;
+ public long l02070;
+ public long l02071;
+ public long l02072;
+ public long l02073;
+ public long l02074;
+ public long l02075;
+ public long l02076;
+ public long l02077;
+ public long l02078;
+ public long l02079;
+ public long l02080;
+ public long l02081;
+ public long l02082;
+ public long l02083;
+ public long l02084;
+ public long l02085;
+ public long l02086;
+ public long l02087;
+ public long l02088;
+ public long l02089;
+ public long l02090;
+ public long l02091;
+ public long l02092;
+ public long l02093;
+ public long l02094;
+ public long l02095;
+ public long l02096;
+ public long l02097;
+ public long l02098;
+ public long l02099;
+ public long l02100;
+ public long l02101;
+ public long l02102;
+ public long l02103;
+ public long l02104;
+ public long l02105;
+ public long l02106;
+ public long l02107;
+ public long l02108;
+ public long l02109;
+ public long l02110;
+ public long l02111;
+ public long l02112;
+ public long l02113;
+ public long l02114;
+ public long l02115;
+ public long l02116;
+ public long l02117;
+ public long l02118;
+ public long l02119;
+ public long l02120;
+ public long l02121;
+ public long l02122;
+ public long l02123;
+ public long l02124;
+ public long l02125;
+ public long l02126;
+ public long l02127;
+ public long l02128;
+ public long l02129;
+ public long l02130;
+ public long l02131;
+ public long l02132;
+ public long l02133;
+ public long l02134;
+ public long l02135;
+ public long l02136;
+ public long l02137;
+ public long l02138;
+ public long l02139;
+ public long l02140;
+ public long l02141;
+ public long l02142;
+ public long l02143;
+ public long l02144;
+ public long l02145;
+ public long l02146;
+ public long l02147;
+ public long l02148;
+ public long l02149;
+ public long l02150;
+ public long l02151;
+ public long l02152;
+ public long l02153;
+ public long l02154;
+ public long l02155;
+ public long l02156;
+ public long l02157;
+ public long l02158;
+ public long l02159;
+ public long l02160;
+ public long l02161;
+ public long l02162;
+ public long l02163;
+ public long l02164;
+ public long l02165;
+ public long l02166;
+ public long l02167;
+ public long l02168;
+ public long l02169;
+ public long l02170;
+ public long l02171;
+ public long l02172;
+ public long l02173;
+ public long l02174;
+ public long l02175;
+ public long l02176;
+ public long l02177;
+ public long l02178;
+ public long l02179;
+ public long l02180;
+ public long l02181;
+ public long l02182;
+ public long l02183;
+ public long l02184;
+ public long l02185;
+ public long l02186;
+ public long l02187;
+ public long l02188;
+ public long l02189;
+ public long l02190;
+ public long l02191;
+ public long l02192;
+ public long l02193;
+ public long l02194;
+ public long l02195;
+ public long l02196;
+ public long l02197;
+ public long l02198;
+ public long l02199;
+ public long l02200;
+ public long l02201;
+ public long l02202;
+ public long l02203;
+ public long l02204;
+ public long l02205;
+ public long l02206;
+ public long l02207;
+ public long l02208;
+ public long l02209;
+ public long l02210;
+ public long l02211;
+ public long l02212;
+ public long l02213;
+ public long l02214;
+ public long l02215;
+ public long l02216;
+ public long l02217;
+ public long l02218;
+ public long l02219;
+ public long l02220;
+ public long l02221;
+ public long l02222;
+ public long l02223;
+ public long l02224;
+ public long l02225;
+ public long l02226;
+ public long l02227;
+ public long l02228;
+ public long l02229;
+ public long l02230;
+ public long l02231;
+ public long l02232;
+ public long l02233;
+ public long l02234;
+ public long l02235;
+ public long l02236;
+ public long l02237;
+ public long l02238;
+ public long l02239;
+ public long l02240;
+ public long l02241;
+ public long l02242;
+ public long l02243;
+ public long l02244;
+ public long l02245;
+ public long l02246;
+ public long l02247;
+ public long l02248;
+ public long l02249;
+ public long l02250;
+ public long l02251;
+ public long l02252;
+ public long l02253;
+ public long l02254;
+ public long l02255;
+ public long l02256;
+ public long l02257;
+ public long l02258;
+ public long l02259;
+ public long l02260;
+ public long l02261;
+ public long l02262;
+ public long l02263;
+ public long l02264;
+ public long l02265;
+ public long l02266;
+ public long l02267;
+ public long l02268;
+ public long l02269;
+ public long l02270;
+ public long l02271;
+ public long l02272;
+ public long l02273;
+ public long l02274;
+ public long l02275;
+ public long l02276;
+ public long l02277;
+ public long l02278;
+ public long l02279;
+ public long l02280;
+ public long l02281;
+ public long l02282;
+ public long l02283;
+ public long l02284;
+ public long l02285;
+ public long l02286;
+ public long l02287;
+ public long l02288;
+ public long l02289;
+ public long l02290;
+ public long l02291;
+ public long l02292;
+ public long l02293;
+ public long l02294;
+ public long l02295;
+ public long l02296;
+ public long l02297;
+ public long l02298;
+ public long l02299;
+ public long l02300;
+ public long l02301;
+ public long l02302;
+ public long l02303;
+ public long l02304;
+ public long l02305;
+ public long l02306;
+ public long l02307;
+ public long l02308;
+ public long l02309;
+ public long l02310;
+ public long l02311;
+ public long l02312;
+ public long l02313;
+ public long l02314;
+ public long l02315;
+ public long l02316;
+ public long l02317;
+ public long l02318;
+ public long l02319;
+ public long l02320;
+ public long l02321;
+ public long l02322;
+ public long l02323;
+ public long l02324;
+ public long l02325;
+ public long l02326;
+ public long l02327;
+ public long l02328;
+ public long l02329;
+ public long l02330;
+ public long l02331;
+ public long l02332;
+ public long l02333;
+ public long l02334;
+ public long l02335;
+ public long l02336;
+ public long l02337;
+ public long l02338;
+ public long l02339;
+ public long l02340;
+ public long l02341;
+ public long l02342;
+ public long l02343;
+ public long l02344;
+ public long l02345;
+ public long l02346;
+ public long l02347;
+ public long l02348;
+ public long l02349;
+ public long l02350;
+ public long l02351;
+ public long l02352;
+ public long l02353;
+ public long l02354;
+ public long l02355;
+ public long l02356;
+ public long l02357;
+ public long l02358;
+ public long l02359;
+ public long l02360;
+ public long l02361;
+ public long l02362;
+ public long l02363;
+ public long l02364;
+ public long l02365;
+ public long l02366;
+ public long l02367;
+ public long l02368;
+ public long l02369;
+ public long l02370;
+ public long l02371;
+ public long l02372;
+ public long l02373;
+ public long l02374;
+ public long l02375;
+ public long l02376;
+ public long l02377;
+ public long l02378;
+ public long l02379;
+ public long l02380;
+ public long l02381;
+ public long l02382;
+ public long l02383;
+ public long l02384;
+ public long l02385;
+ public long l02386;
+ public long l02387;
+ public long l02388;
+ public long l02389;
+ public long l02390;
+ public long l02391;
+ public long l02392;
+ public long l02393;
+ public long l02394;
+ public long l02395;
+ public long l02396;
+ public long l02397;
+ public long l02398;
+ public long l02399;
+ public long l02400;
+ public long l02401;
+ public long l02402;
+ public long l02403;
+ public long l02404;
+ public long l02405;
+ public long l02406;
+ public long l02407;
+ public long l02408;
+ public long l02409;
+ public long l02410;
+ public long l02411;
+ public long l02412;
+ public long l02413;
+ public long l02414;
+ public long l02415;
+ public long l02416;
+ public long l02417;
+ public long l02418;
+ public long l02419;
+ public long l02420;
+ public long l02421;
+ public long l02422;
+ public long l02423;
+ public long l02424;
+ public long l02425;
+ public long l02426;
+ public long l02427;
+ public long l02428;
+ public long l02429;
+ public long l02430;
+ public long l02431;
+ public long l02432;
+ public long l02433;
+ public long l02434;
+ public long l02435;
+ public long l02436;
+ public long l02437;
+ public long l02438;
+ public long l02439;
+ public long l02440;
+ public long l02441;
+ public long l02442;
+ public long l02443;
+ public long l02444;
+ public long l02445;
+ public long l02446;
+ public long l02447;
+ public long l02448;
+ public long l02449;
+ public long l02450;
+ public long l02451;
+ public long l02452;
+ public long l02453;
+ public long l02454;
+ public long l02455;
+ public long l02456;
+ public long l02457;
+ public long l02458;
+ public long l02459;
+ public long l02460;
+ public long l02461;
+ public long l02462;
+ public long l02463;
+ public long l02464;
+ public long l02465;
+ public long l02466;
+ public long l02467;
+ public long l02468;
+ public long l02469;
+ public long l02470;
+ public long l02471;
+ public long l02472;
+ public long l02473;
+ public long l02474;
+ public long l02475;
+ public long l02476;
+ public long l02477;
+ public long l02478;
+ public long l02479;
+ public long l02480;
+ public long l02481;
+ public long l02482;
+ public long l02483;
+ public long l02484;
+ public long l02485;
+ public long l02486;
+ public long l02487;
+ public long l02488;
+ public long l02489;
+ public long l02490;
+ public long l02491;
+ public long l02492;
+ public long l02493;
+ public long l02494;
+ public long l02495;
+ public long l02496;
+ public long l02497;
+ public long l02498;
+ public long l02499;
+ public long l02500;
+ public long l02501;
+ public long l02502;
+ public long l02503;
+ public long l02504;
+ public long l02505;
+ public long l02506;
+ public long l02507;
+ public long l02508;
+ public long l02509;
+ public long l02510;
+ public long l02511;
+ public long l02512;
+ public long l02513;
+ public long l02514;
+ public long l02515;
+ public long l02516;
+ public long l02517;
+ public long l02518;
+ public long l02519;
+ public long l02520;
+ public long l02521;
+ public long l02522;
+ public long l02523;
+ public long l02524;
+ public long l02525;
+ public long l02526;
+ public long l02527;
+ public long l02528;
+ public long l02529;
+ public long l02530;
+ public long l02531;
+ public long l02532;
+ public long l02533;
+ public long l02534;
+ public long l02535;
+ public long l02536;
+ public long l02537;
+ public long l02538;
+ public long l02539;
+ public long l02540;
+ public long l02541;
+ public long l02542;
+ public long l02543;
+ public long l02544;
+ public long l02545;
+ public long l02546;
+ public long l02547;
+ public long l02548;
+ public long l02549;
+ public long l02550;
+ public long l02551;
+ public long l02552;
+ public long l02553;
+ public long l02554;
+ public long l02555;
+ public long l02556;
+ public long l02557;
+ public long l02558;
+ public long l02559;
+ public long l02560;
+ public long l02561;
+ public long l02562;
+ public long l02563;
+ public long l02564;
+ public long l02565;
+ public long l02566;
+ public long l02567;
+ public long l02568;
+ public long l02569;
+ public long l02570;
+ public long l02571;
+ public long l02572;
+ public long l02573;
+ public long l02574;
+ public long l02575;
+ public long l02576;
+ public long l02577;
+ public long l02578;
+ public long l02579;
+ public long l02580;
+ public long l02581;
+ public long l02582;
+ public long l02583;
+ public long l02584;
+ public long l02585;
+ public long l02586;
+ public long l02587;
+ public long l02588;
+ public long l02589;
+ public long l02590;
+ public long l02591;
+ public long l02592;
+ public long l02593;
+ public long l02594;
+ public long l02595;
+ public long l02596;
+ public long l02597;
+ public long l02598;
+ public long l02599;
+ public long l02600;
+ public long l02601;
+ public long l02602;
+ public long l02603;
+ public long l02604;
+ public long l02605;
+ public long l02606;
+ public long l02607;
+ public long l02608;
+ public long l02609;
+ public long l02610;
+ public long l02611;
+ public long l02612;
+ public long l02613;
+ public long l02614;
+ public long l02615;
+ public long l02616;
+ public long l02617;
+ public long l02618;
+ public long l02619;
+ public long l02620;
+ public long l02621;
+ public long l02622;
+ public long l02623;
+ public long l02624;
+ public long l02625;
+ public long l02626;
+ public long l02627;
+ public long l02628;
+ public long l02629;
+ public long l02630;
+ public long l02631;
+ public long l02632;
+ public long l02633;
+ public long l02634;
+ public long l02635;
+ public long l02636;
+ public long l02637;
+ public long l02638;
+ public long l02639;
+ public long l02640;
+ public long l02641;
+ public long l02642;
+ public long l02643;
+ public long l02644;
+ public long l02645;
+ public long l02646;
+ public long l02647;
+ public long l02648;
+ public long l02649;
+ public long l02650;
+ public long l02651;
+ public long l02652;
+ public long l02653;
+ public long l02654;
+ public long l02655;
+ public long l02656;
+ public long l02657;
+ public long l02658;
+ public long l02659;
+ public long l02660;
+ public long l02661;
+ public long l02662;
+ public long l02663;
+ public long l02664;
+ public long l02665;
+ public long l02666;
+ public long l02667;
+ public long l02668;
+ public long l02669;
+ public long l02670;
+ public long l02671;
+ public long l02672;
+ public long l02673;
+ public long l02674;
+ public long l02675;
+ public long l02676;
+ public long l02677;
+ public long l02678;
+ public long l02679;
+ public long l02680;
+ public long l02681;
+ public long l02682;
+ public long l02683;
+ public long l02684;
+ public long l02685;
+ public long l02686;
+ public long l02687;
+ public long l02688;
+ public long l02689;
+ public long l02690;
+ public long l02691;
+ public long l02692;
+ public long l02693;
+ public long l02694;
+ public long l02695;
+ public long l02696;
+ public long l02697;
+ public long l02698;
+ public long l02699;
+ public long l02700;
+ public long l02701;
+ public long l02702;
+ public long l02703;
+ public long l02704;
+ public long l02705;
+ public long l02706;
+ public long l02707;
+ public long l02708;
+ public long l02709;
+ public long l02710;
+ public long l02711;
+ public long l02712;
+ public long l02713;
+ public long l02714;
+ public long l02715;
+ public long l02716;
+ public long l02717;
+ public long l02718;
+ public long l02719;
+ public long l02720;
+ public long l02721;
+ public long l02722;
+ public long l02723;
+ public long l02724;
+ public long l02725;
+ public long l02726;
+ public long l02727;
+ public long l02728;
+ public long l02729;
+ public long l02730;
+ public long l02731;
+ public long l02732;
+ public long l02733;
+ public long l02734;
+ public long l02735;
+ public long l02736;
+ public long l02737;
+ public long l02738;
+ public long l02739;
+ public long l02740;
+ public long l02741;
+ public long l02742;
+ public long l02743;
+ public long l02744;
+ public long l02745;
+ public long l02746;
+ public long l02747;
+ public long l02748;
+ public long l02749;
+ public long l02750;
+ public long l02751;
+ public long l02752;
+ public long l02753;
+ public long l02754;
+ public long l02755;
+ public long l02756;
+ public long l02757;
+ public long l02758;
+ public long l02759;
+ public long l02760;
+ public long l02761;
+ public long l02762;
+ public long l02763;
+ public long l02764;
+ public long l02765;
+ public long l02766;
+ public long l02767;
+ public long l02768;
+ public long l02769;
+ public long l02770;
+ public long l02771;
+ public long l02772;
+ public long l02773;
+ public long l02774;
+ public long l02775;
+ public long l02776;
+ public long l02777;
+ public long l02778;
+ public long l02779;
+ public long l02780;
+ public long l02781;
+ public long l02782;
+ public long l02783;
+ public long l02784;
+ public long l02785;
+ public long l02786;
+ public long l02787;
+ public long l02788;
+ public long l02789;
+ public long l02790;
+ public long l02791;
+ public long l02792;
+ public long l02793;
+ public long l02794;
+ public long l02795;
+ public long l02796;
+ public long l02797;
+ public long l02798;
+ public long l02799;
+ public long l02800;
+ public long l02801;
+ public long l02802;
+ public long l02803;
+ public long l02804;
+ public long l02805;
+ public long l02806;
+ public long l02807;
+ public long l02808;
+ public long l02809;
+ public long l02810;
+ public long l02811;
+ public long l02812;
+ public long l02813;
+ public long l02814;
+ public long l02815;
+ public long l02816;
+ public long l02817;
+ public long l02818;
+ public long l02819;
+ public long l02820;
+ public long l02821;
+ public long l02822;
+ public long l02823;
+ public long l02824;
+ public long l02825;
+ public long l02826;
+ public long l02827;
+ public long l02828;
+ public long l02829;
+ public long l02830;
+ public long l02831;
+ public long l02832;
+ public long l02833;
+ public long l02834;
+ public long l02835;
+ public long l02836;
+ public long l02837;
+ public long l02838;
+ public long l02839;
+ public long l02840;
+ public long l02841;
+ public long l02842;
+ public long l02843;
+ public long l02844;
+ public long l02845;
+ public long l02846;
+ public long l02847;
+ public long l02848;
+ public long l02849;
+ public long l02850;
+ public long l02851;
+ public long l02852;
+ public long l02853;
+ public long l02854;
+ public long l02855;
+ public long l02856;
+ public long l02857;
+ public long l02858;
+ public long l02859;
+ public long l02860;
+ public long l02861;
+ public long l02862;
+ public long l02863;
+ public long l02864;
+ public long l02865;
+ public long l02866;
+ public long l02867;
+ public long l02868;
+ public long l02869;
+ public long l02870;
+ public long l02871;
+ public long l02872;
+ public long l02873;
+ public long l02874;
+ public long l02875;
+ public long l02876;
+ public long l02877;
+ public long l02878;
+ public long l02879;
+ public long l02880;
+ public long l02881;
+ public long l02882;
+ public long l02883;
+ public long l02884;
+ public long l02885;
+ public long l02886;
+ public long l02887;
+ public long l02888;
+ public long l02889;
+ public long l02890;
+ public long l02891;
+ public long l02892;
+ public long l02893;
+ public long l02894;
+ public long l02895;
+ public long l02896;
+ public long l02897;
+ public long l02898;
+ public long l02899;
+ public long l02900;
+ public long l02901;
+ public long l02902;
+ public long l02903;
+ public long l02904;
+ public long l02905;
+ public long l02906;
+ public long l02907;
+ public long l02908;
+ public long l02909;
+ public long l02910;
+ public long l02911;
+ public long l02912;
+ public long l02913;
+ public long l02914;
+ public long l02915;
+ public long l02916;
+ public long l02917;
+ public long l02918;
+ public long l02919;
+ public long l02920;
+ public long l02921;
+ public long l02922;
+ public long l02923;
+ public long l02924;
+ public long l02925;
+ public long l02926;
+ public long l02927;
+ public long l02928;
+ public long l02929;
+ public long l02930;
+ public long l02931;
+ public long l02932;
+ public long l02933;
+ public long l02934;
+ public long l02935;
+ public long l02936;
+ public long l02937;
+ public long l02938;
+ public long l02939;
+ public long l02940;
+ public long l02941;
+ public long l02942;
+ public long l02943;
+ public long l02944;
+ public long l02945;
+ public long l02946;
+ public long l02947;
+ public long l02948;
+ public long l02949;
+ public long l02950;
+ public long l02951;
+ public long l02952;
+ public long l02953;
+ public long l02954;
+ public long l02955;
+ public long l02956;
+ public long l02957;
+ public long l02958;
+ public long l02959;
+ public long l02960;
+ public long l02961;
+ public long l02962;
+ public long l02963;
+ public long l02964;
+ public long l02965;
+ public long l02966;
+ public long l02967;
+ public long l02968;
+ public long l02969;
+ public long l02970;
+ public long l02971;
+ public long l02972;
+ public long l02973;
+ public long l02974;
+ public long l02975;
+ public long l02976;
+ public long l02977;
+ public long l02978;
+ public long l02979;
+ public long l02980;
+ public long l02981;
+ public long l02982;
+ public long l02983;
+ public long l02984;
+ public long l02985;
+ public long l02986;
+ public long l02987;
+ public long l02988;
+ public long l02989;
+ public long l02990;
+ public long l02991;
+ public long l02992;
+ public long l02993;
+ public long l02994;
+ public long l02995;
+ public long l02996;
+ public long l02997;
+ public long l02998;
+ public long l02999;
+ public long l03000;
+ public long l03001;
+ public long l03002;
+ public long l03003;
+ public long l03004;
+ public long l03005;
+ public long l03006;
+ public long l03007;
+ public long l03008;
+ public long l03009;
+ public long l03010;
+ public long l03011;
+ public long l03012;
+ public long l03013;
+ public long l03014;
+ public long l03015;
+ public long l03016;
+ public long l03017;
+ public long l03018;
+ public long l03019;
+ public long l03020;
+ public long l03021;
+ public long l03022;
+ public long l03023;
+ public long l03024;
+ public long l03025;
+ public long l03026;
+ public long l03027;
+ public long l03028;
+ public long l03029;
+ public long l03030;
+ public long l03031;
+ public long l03032;
+ public long l03033;
+ public long l03034;
+ public long l03035;
+ public long l03036;
+ public long l03037;
+ public long l03038;
+ public long l03039;
+ public long l03040;
+ public long l03041;
+ public long l03042;
+ public long l03043;
+ public long l03044;
+ public long l03045;
+ public long l03046;
+ public long l03047;
+ public long l03048;
+ public long l03049;
+ public long l03050;
+ public long l03051;
+ public long l03052;
+ public long l03053;
+ public long l03054;
+ public long l03055;
+ public long l03056;
+ public long l03057;
+ public long l03058;
+ public long l03059;
+ public long l03060;
+ public long l03061;
+ public long l03062;
+ public long l03063;
+ public long l03064;
+ public long l03065;
+ public long l03066;
+ public long l03067;
+ public long l03068;
+ public long l03069;
+ public long l03070;
+ public long l03071;
+ public long l03072;
+ public long l03073;
+ public long l03074;
+ public long l03075;
+ public long l03076;
+ public long l03077;
+ public long l03078;
+ public long l03079;
+ public long l03080;
+ public long l03081;
+ public long l03082;
+ public long l03083;
+ public long l03084;
+ public long l03085;
+ public long l03086;
+ public long l03087;
+ public long l03088;
+ public long l03089;
+ public long l03090;
+ public long l03091;
+ public long l03092;
+ public long l03093;
+ public long l03094;
+ public long l03095;
+ public long l03096;
+ public long l03097;
+ public long l03098;
+ public long l03099;
+ public long l03100;
+ public long l03101;
+ public long l03102;
+ public long l03103;
+ public long l03104;
+ public long l03105;
+ public long l03106;
+ public long l03107;
+ public long l03108;
+ public long l03109;
+ public long l03110;
+ public long l03111;
+ public long l03112;
+ public long l03113;
+ public long l03114;
+ public long l03115;
+ public long l03116;
+ public long l03117;
+ public long l03118;
+ public long l03119;
+ public long l03120;
+ public long l03121;
+ public long l03122;
+ public long l03123;
+ public long l03124;
+ public long l03125;
+ public long l03126;
+ public long l03127;
+ public long l03128;
+ public long l03129;
+ public long l03130;
+ public long l03131;
+ public long l03132;
+ public long l03133;
+ public long l03134;
+ public long l03135;
+ public long l03136;
+ public long l03137;
+ public long l03138;
+ public long l03139;
+ public long l03140;
+ public long l03141;
+ public long l03142;
+ public long l03143;
+ public long l03144;
+ public long l03145;
+ public long l03146;
+ public long l03147;
+ public long l03148;
+ public long l03149;
+ public long l03150;
+ public long l03151;
+ public long l03152;
+ public long l03153;
+ public long l03154;
+ public long l03155;
+ public long l03156;
+ public long l03157;
+ public long l03158;
+ public long l03159;
+ public long l03160;
+ public long l03161;
+ public long l03162;
+ public long l03163;
+ public long l03164;
+ public long l03165;
+ public long l03166;
+ public long l03167;
+ public long l03168;
+ public long l03169;
+ public long l03170;
+ public long l03171;
+ public long l03172;
+ public long l03173;
+ public long l03174;
+ public long l03175;
+ public long l03176;
+ public long l03177;
+ public long l03178;
+ public long l03179;
+ public long l03180;
+ public long l03181;
+ public long l03182;
+ public long l03183;
+ public long l03184;
+ public long l03185;
+ public long l03186;
+ public long l03187;
+ public long l03188;
+ public long l03189;
+ public long l03190;
+ public long l03191;
+ public long l03192;
+ public long l03193;
+ public long l03194;
+ public long l03195;
+ public long l03196;
+ public long l03197;
+ public long l03198;
+ public long l03199;
+ public long l03200;
+ public long l03201;
+ public long l03202;
+ public long l03203;
+ public long l03204;
+ public long l03205;
+ public long l03206;
+ public long l03207;
+ public long l03208;
+ public long l03209;
+ public long l03210;
+ public long l03211;
+ public long l03212;
+ public long l03213;
+ public long l03214;
+ public long l03215;
+ public long l03216;
+ public long l03217;
+ public long l03218;
+ public long l03219;
+ public long l03220;
+ public long l03221;
+ public long l03222;
+ public long l03223;
+ public long l03224;
+ public long l03225;
+ public long l03226;
+ public long l03227;
+ public long l03228;
+ public long l03229;
+ public long l03230;
+ public long l03231;
+ public long l03232;
+ public long l03233;
+ public long l03234;
+ public long l03235;
+ public long l03236;
+ public long l03237;
+ public long l03238;
+ public long l03239;
+ public long l03240;
+ public long l03241;
+ public long l03242;
+ public long l03243;
+ public long l03244;
+ public long l03245;
+ public long l03246;
+ public long l03247;
+ public long l03248;
+ public long l03249;
+ public long l03250;
+ public long l03251;
+ public long l03252;
+ public long l03253;
+ public long l03254;
+ public long l03255;
+ public long l03256;
+ public long l03257;
+ public long l03258;
+ public long l03259;
+ public long l03260;
+ public long l03261;
+ public long l03262;
+ public long l03263;
+ public long l03264;
+ public long l03265;
+ public long l03266;
+ public long l03267;
+ public long l03268;
+ public long l03269;
+ public long l03270;
+ public long l03271;
+ public long l03272;
+ public long l03273;
+ public long l03274;
+ public long l03275;
+ public long l03276;
+ public long l03277;
+ public long l03278;
+ public long l03279;
+ public long l03280;
+ public long l03281;
+ public long l03282;
+ public long l03283;
+ public long l03284;
+ public long l03285;
+ public long l03286;
+ public long l03287;
+ public long l03288;
+ public long l03289;
+ public long l03290;
+ public long l03291;
+ public long l03292;
+ public long l03293;
+ public long l03294;
+ public long l03295;
+ public long l03296;
+ public long l03297;
+ public long l03298;
+ public long l03299;
+ public long l03300;
+ public long l03301;
+ public long l03302;
+ public long l03303;
+ public long l03304;
+ public long l03305;
+ public long l03306;
+ public long l03307;
+ public long l03308;
+ public long l03309;
+ public long l03310;
+ public long l03311;
+ public long l03312;
+ public long l03313;
+ public long l03314;
+ public long l03315;
+ public long l03316;
+ public long l03317;
+ public long l03318;
+ public long l03319;
+ public long l03320;
+ public long l03321;
+ public long l03322;
+ public long l03323;
+ public long l03324;
+ public long l03325;
+ public long l03326;
+ public long l03327;
+ public long l03328;
+ public long l03329;
+ public long l03330;
+ public long l03331;
+ public long l03332;
+ public long l03333;
+ public long l03334;
+ public long l03335;
+ public long l03336;
+ public long l03337;
+ public long l03338;
+ public long l03339;
+ public long l03340;
+ public long l03341;
+ public long l03342;
+ public long l03343;
+ public long l03344;
+ public long l03345;
+ public long l03346;
+ public long l03347;
+ public long l03348;
+ public long l03349;
+ public long l03350;
+ public long l03351;
+ public long l03352;
+ public long l03353;
+ public long l03354;
+ public long l03355;
+ public long l03356;
+ public long l03357;
+ public long l03358;
+ public long l03359;
+ public long l03360;
+ public long l03361;
+ public long l03362;
+ public long l03363;
+ public long l03364;
+ public long l03365;
+ public long l03366;
+ public long l03367;
+ public long l03368;
+ public long l03369;
+ public long l03370;
+ public long l03371;
+ public long l03372;
+ public long l03373;
+ public long l03374;
+ public long l03375;
+ public long l03376;
+ public long l03377;
+ public long l03378;
+ public long l03379;
+ public long l03380;
+ public long l03381;
+ public long l03382;
+ public long l03383;
+ public long l03384;
+ public long l03385;
+ public long l03386;
+ public long l03387;
+ public long l03388;
+ public long l03389;
+ public long l03390;
+ public long l03391;
+ public long l03392;
+ public long l03393;
+ public long l03394;
+ public long l03395;
+ public long l03396;
+ public long l03397;
+ public long l03398;
+ public long l03399;
+ public long l03400;
+ public long l03401;
+ public long l03402;
+ public long l03403;
+ public long l03404;
+ public long l03405;
+ public long l03406;
+ public long l03407;
+ public long l03408;
+ public long l03409;
+ public long l03410;
+ public long l03411;
+ public long l03412;
+ public long l03413;
+ public long l03414;
+ public long l03415;
+ public long l03416;
+ public long l03417;
+ public long l03418;
+ public long l03419;
+ public long l03420;
+ public long l03421;
+ public long l03422;
+ public long l03423;
+ public long l03424;
+ public long l03425;
+ public long l03426;
+ public long l03427;
+ public long l03428;
+ public long l03429;
+ public long l03430;
+ public long l03431;
+ public long l03432;
+ public long l03433;
+ public long l03434;
+ public long l03435;
+ public long l03436;
+ public long l03437;
+ public long l03438;
+ public long l03439;
+ public long l03440;
+ public long l03441;
+ public long l03442;
+ public long l03443;
+ public long l03444;
+ public long l03445;
+ public long l03446;
+ public long l03447;
+ public long l03448;
+ public long l03449;
+ public long l03450;
+ public long l03451;
+ public long l03452;
+ public long l03453;
+ public long l03454;
+ public long l03455;
+ public long l03456;