--- old/agent/src/share/classes/sun/jvm/hotspot/memory/GenCollectedHeap.java 2014-10-17 15:34:48.000000000 +0200 +++ new/agent/src/share/classes/sun/jvm/hotspot/memory/GenCollectedHeap.java 2014-10-17 15:34:48.000000000 +0200 @@ -37,7 +37,9 @@ private static CIntegerField nGensField; private static AddressField youngGenField; private static AddressField oldGenField; - private static AddressField genSpecsField; + + private static AddressField youngGenSpecField; + private static AddressField oldGenSpecField; private static GenerationFactory genFactory; @@ -55,9 +57,12 @@ nGensField = type.getCIntegerField("_n_gens"); youngGenField = type.getAddressField("_young_gen"); oldGenField = type.getAddressField("_old_gen"); - genSpecsField = type.getAddressField("_gen_specs"); genFactory = new GenerationFactory(); + + Type colPolType = db.lookupType("GenCollectorPolicy"); + youngGenSpecField = colPolType.getAddressField("_young_gen_spec"); + oldGenSpecField = colPolType.getAddressField("_old_gen_spec"); } public GenCollectedHeap(Address addr) { @@ -123,13 +128,15 @@ return null; } - Address ptrList = genSpecsField.getValue(addr); - if (ptrList == null) { - return null; + if (level == 0) { + return (GenerationSpec) + VMObjectFactory.newObject(GenerationSpec.class, + youngGenSpecField.getAddress()); + } else { + return (GenerationSpec) + VMObjectFactory.newObject(GenerationSpec.class, + oldGenSpecField.getAddress()); } - return (GenerationSpec) - VMObjectFactory.newObject(GenerationSpec.class, - ptrList.getAddressAt(level * VM.getVM().getAddressSize())); } public CollectedHeapName kind() { --- old/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.cpp 2014-10-17 15:34:49.000000000 +0200 +++ new/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.cpp 2014-10-17 15:34:49.000000000 +0200 @@ -52,19 +52,14 @@ } void ConcurrentMarkSweepPolicy::initialize_generations() { - _generations = NEW_C_HEAP_ARRAY3(GenerationSpecPtr, number_of_generations(), mtGC, - CURRENT_PC, AllocFailStrategy::RETURN_NULL); - if (_generations == NULL) - vm_exit_during_initialization("Unable to allocate gen spec"); - Generation::Name yg_name = UseParNewGC ? Generation::ParNew : Generation::DefNew; - _generations[0] = new GenerationSpec(yg_name, _initial_young_size, - _max_young_size); - _generations[1] = new GenerationSpec(Generation::ConcurrentMarkSweep, - _initial_old_size, _max_old_size); + _young_gen_spec = new GenerationSpec(yg_name, _initial_young_size, + _max_young_size, _gen_alignment); + _old_gen_spec = new GenerationSpec(Generation::ConcurrentMarkSweep, + _initial_old_size, _max_old_size, _gen_alignment); - if (_generations[0] == NULL || _generations[1] == NULL) { + if (_young_gen_spec == NULL || _old_gen_spec == NULL) { vm_exit_during_initialization("Unable to allocate gen spec"); } } --- old/src/share/vm/memory/collectorPolicy.cpp 2014-10-17 15:34:50.000000000 +0200 +++ new/src/share/vm/memory/collectorPolicy.cpp 2014-10-17 15:34:50.000000000 +0200 @@ -191,11 +191,12 @@ _min_young_size(0), _initial_young_size(0), _max_young_size(0), - _gen_alignment(0), _min_old_size(0), _initial_old_size(0), _max_old_size(0), - _generations(NULL) + _gen_alignment(0), + _young_gen_spec(NULL), + _old_gen_spec(NULL) {} size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) { @@ -913,20 +914,14 @@ } void MarkSweepPolicy::initialize_generations() { - _generations = NEW_C_HEAP_ARRAY3(GenerationSpecPtr, number_of_generations(), mtGC, CURRENT_PC, - AllocFailStrategy::RETURN_NULL); - if (_generations == NULL) { - vm_exit_during_initialization("Unable to allocate gen spec"); - } - if (UseParNewGC) { - _generations[0] = new GenerationSpec(Generation::ParNew, _initial_young_size, _max_young_size); + _young_gen_spec = new GenerationSpec(Generation::ParNew, _initial_young_size, _max_young_size, _gen_alignment); } else { - _generations[0] = new GenerationSpec(Generation::DefNew, _initial_young_size, _max_young_size); + _young_gen_spec = new GenerationSpec(Generation::DefNew, _initial_young_size, _max_young_size, _gen_alignment); } - _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_old_size, _max_old_size); + _old_gen_spec = new GenerationSpec(Generation::MarkSweepCompact, _initial_old_size, _max_old_size, _gen_alignment); - if (_generations[0] == NULL || _generations[1] == NULL) { + if (_young_gen_spec == NULL || _old_gen_spec == NULL) { vm_exit_during_initialization("Unable to allocate gen spec"); } } --- old/src/share/vm/memory/collectorPolicy.hpp 2014-10-17 15:34:50.000000000 +0200 +++ new/src/share/vm/memory/collectorPolicy.hpp 2014-10-17 15:34:50.000000000 +0200 @@ -216,7 +216,8 @@ }; class GenCollectorPolicy : public CollectorPolicy { -friend class TestGenCollectorPolicy; + friend class TestGenCollectorPolicy; + friend class VMStructs; protected: size_t _min_young_size; size_t _initial_young_size; @@ -229,7 +230,8 @@ // time. When using large pages they can differ. size_t _gen_alignment; - GenerationSpec **_generations; + GenerationSpec* _young_gen_spec; + GenerationSpec* _old_gen_spec; // Return true if an allocation should be attempted in the older generation // if it fails in the younger generation. Return false, otherwise. @@ -269,9 +271,14 @@ int number_of_generations() { return 2; } - virtual GenerationSpec **generations() { - assert(_generations != NULL, "Sanity check"); - return _generations; + virtual GenerationSpec* young_gen_spec() const { + assert(_young_gen_spec != NULL, "Sanity check"); + return _young_gen_spec; + } + + virtual GenerationSpec* old_gen_spec() const { + assert(_old_gen_spec != NULL, "Sanity check"); + return _old_gen_spec; } virtual GenCollectorPolicy* as_generation_policy() { return this; } --- old/src/share/vm/memory/defNewGeneration.cpp 2014-10-17 15:34:51.000000000 +0200 +++ new/src/share/vm/memory/defNewGeneration.cpp 2014-10-17 15:34:51.000000000 +0200 @@ -384,7 +384,7 @@ int next_level = level() + 1; GenCollectedHeap* gch = GenCollectedHeap::heap(); - assert(next_level < gch->_n_gens, + assert(next_level < gch->n_gens(), "DefNewGeneration cannot be an oldest gen"); Generation* old_gen = gch->old_gen(); --- old/src/share/vm/memory/genCollectedHeap.cpp 2014-10-17 15:34:52.000000000 +0200 +++ new/src/share/vm/memory/genCollectedHeap.cpp 2014-10-17 15:34:52.000000000 +0200 @@ -95,16 +95,6 @@ // HeapWordSize). guarantee(HeapWordSize == wordSize, "HeapWordSize must equal wordSize"); - // The heap must be at least as aligned as generations. - size_t gen_alignment = Generation::GenGrain; - - _gen_specs = gen_policy()->generations(); - - // Make sure the sizes are all aligned. - for (i = 0; i < _n_gens; i++) { - _gen_specs[i]->align(gen_alignment); - } - // Allocate space for the heap. char* heap_address; @@ -130,13 +120,14 @@ _gch = this; - ReservedSpace young_rs = heap_rs.first_part(_gen_specs[0]->max_size(), false, false); - _young_gen = _gen_specs[0]->init(young_rs, 0, rem_set()); - heap_rs = heap_rs.last_part(_gen_specs[0]->max_size()); - - ReservedSpace old_rs = heap_rs.first_part(_gen_specs[1]->max_size(), false, false); - _old_gen = _gen_specs[1]->init(old_rs, 1, rem_set()); - heap_rs = heap_rs.last_part(_gen_specs[1]->max_size()); + ReservedSpace young_rs = heap_rs.first_part(gen_policy()->young_gen_spec()->max_size(), false, false); + _young_gen = gen_policy()->young_gen_spec()->init(young_rs, 0, rem_set()); + heap_rs = heap_rs.last_part(gen_policy()->young_gen_spec()->max_size()); + + ReservedSpace old_rs = heap_rs.first_part(gen_policy()->old_gen_spec()->max_size(), false, false); + _old_gen = gen_policy()->old_gen_spec()->init(old_rs, 1, rem_set()); + heap_rs = heap_rs.last_part(gen_policy()->old_gen_spec()->max_size()); + clear_incremental_collection_failed(); #if INCLUDE_ALL_GCS @@ -159,24 +150,22 @@ "the maximum representable size"; // Now figure out the total size. - size_t total_reserved = 0; - int n_covered_regions = 0; - const size_t pageSize = UseLargePages ? - os::large_page_size() : os::vm_page_size(); - + const size_t pageSize = UseLargePages ? os::large_page_size() : os::vm_page_size(); assert(alignment % pageSize == 0, "Must be"); - for (int i = 0; i < _n_gens; i++) { - total_reserved += _gen_specs[i]->max_size(); - if (total_reserved < _gen_specs[i]->max_size()) { - vm_exit_during_initialization(overflow_msg); - } - n_covered_regions += _gen_specs[i]->n_covered_regions(); + size_t total_reserved = gen_policy()->young_gen_spec()->max_size() + + gen_policy()->old_gen_spec()->max_size(); + if (total_reserved < gen_policy()->young_gen_spec()->max_size() || + total_reserved < gen_policy()->old_gen_spec()->max_size()) { + vm_exit_during_initialization(overflow_msg); } assert(total_reserved % alignment == 0, err_msg("Gen size; total_reserved=" SIZE_FORMAT ", alignment=" SIZE_FORMAT, total_reserved, alignment)); + int n_covered_regions = gen_policy()->young_gen_spec()->n_covered_regions() + + gen_policy()->old_gen_spec()->n_covered_regions(); + // Needed until the cardtable is fixed to have the right number // of covered regions. n_covered_regions += 2; --- old/src/share/vm/memory/genCollectedHeap.hpp 2014-10-17 15:34:53.000000000 +0200 +++ new/src/share/vm/memory/genCollectedHeap.hpp 2014-10-17 15:34:52.000000000 +0200 @@ -67,8 +67,6 @@ Generation* _young_gen; Generation* _old_gen; - GenerationSpec** _gen_specs; - // The generational collector policy. GenCollectorPolicy* _gen_policy; @@ -142,8 +140,8 @@ return CollectedHeap::GenCollectedHeap; } - Generation* young_gen() { return _young_gen; } - Generation* old_gen() { return _old_gen; } + Generation* young_gen() const { return _young_gen; } + Generation* old_gen() const { return _old_gen; } // The generational collector policy. GenCollectorPolicy* gen_policy() const { return _gen_policy; } --- old/src/share/vm/memory/generation.cpp 2014-10-17 15:34:53.000000000 +0200 +++ new/src/share/vm/memory/generation.cpp 2014-10-17 15:34:53.000000000 +0200 @@ -65,7 +65,7 @@ GenerationSpec* Generation::spec() { GenCollectedHeap* gch = GenCollectedHeap::heap(); assert(0 <= level() && level() < gch->_n_gens, "Bad gen level"); - return gch->_gen_specs[level()]; + return level() == 0 ? gch->gen_policy()->young_gen_spec() : gch->gen_policy()->old_gen_spec(); } size_t Generation::max_capacity() const { --- old/src/share/vm/memory/generationSpec.hpp 2014-10-17 15:34:54.000000000 +0200 +++ new/src/share/vm/memory/generationSpec.hpp 2014-10-17 15:34:54.000000000 +0200 @@ -39,10 +39,10 @@ size_t _max_size; public: - GenerationSpec(Generation::Name name, size_t init_size, size_t max_size) { + GenerationSpec(Generation::Name name, size_t init_size, size_t max_size, size_t alignment) { _name = name; - _init_size = init_size; - _max_size = max_size; + _init_size = align_size_up(init_size, alignment); + _max_size = align_size_up(max_size, alignment); } Generation* init(ReservedSpace rs, int level, GenRemSet* remset); @@ -54,12 +54,6 @@ size_t max_size() const { return _max_size; } void set_max_size(size_t size) { _max_size = size; } - // Alignment - void align(size_t alignment) { - set_init_size(align_size_up(init_size(), alignment)); - set_max_size(align_size_up(max_size(), alignment)); - } - // Return the number of regions contained in the generation which // might need to be independently covered by a remembered set. virtual int n_covered_regions() const { return 1; } --- old/src/share/vm/runtime/vmStructs.cpp 2014-10-17 15:34:55.000000000 +0200 +++ new/src/share/vm/runtime/vmStructs.cpp 2014-10-17 15:34:54.000000000 +0200 @@ -515,11 +515,11 @@ nonstatic_field(CollectedHeap, _defer_initial_card_mark, bool) \ nonstatic_field(CollectedHeap, _is_gc_active, bool) \ nonstatic_field(CollectedHeap, _total_collections, unsigned int) \ + \ nonstatic_field(CompactibleSpace, _compaction_top, HeapWord*) \ nonstatic_field(CompactibleSpace, _first_dead, HeapWord*) \ nonstatic_field(CompactibleSpace, _end_of_live, HeapWord*) \ \ - \ nonstatic_field(ContiguousSpace, _top, HeapWord*) \ nonstatic_field(ContiguousSpace, _concurrent_iteration_safe_limit, HeapWord*) \ nonstatic_field(ContiguousSpace, _saved_mark_word, HeapWord*) \ @@ -546,7 +546,9 @@ \ static_field(GenCollectedHeap, _gch, GenCollectedHeap*) \ nonstatic_field(GenCollectedHeap, _n_gens, int) \ - nonstatic_field(GenCollectedHeap, _gen_specs, GenerationSpec**) \ + \ + nonstatic_field(GenCollectorPolicy, _young_gen_spec, GenerationSpec*) \ + nonstatic_field(GenCollectorPolicy, _old_gen_spec, GenerationSpec*) \ \ nonstatic_field(HeapWord, i, char*) \ \ @@ -1484,6 +1486,7 @@ declare_type(CardGeneration, Generation) \ declare_type(OneContigSpaceCardGeneration, CardGeneration) \ declare_type(TenuredGeneration, OneContigSpaceCardGeneration) \ + declare_toplevel_type(GenCollectorPolicy) \ declare_toplevel_type(Space) \ declare_toplevel_type(BitMap) \ declare_type(CompactibleSpace, Space) \ --- old/src/share/vm/services/memoryService.cpp 2014-10-17 15:34:55.000000000 +0200 +++ new/src/share/vm/services/memoryService.cpp 2014-10-17 15:34:55.000000000 +0200 @@ -130,8 +130,7 @@ GenCollectorPolicy* gen_policy = policy->as_generation_policy(); if (gen_policy != NULL) { - GenerationSpec** specs = gen_policy->generations(); - Generation::Name kind = specs[0]->name(); + Generation::Name kind = gen_policy->young_gen_spec()->name(); switch (kind) { case Generation::DefNew: _minor_gc_manager = MemoryManager::get_copy_memory_manager();