9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "gc/serial/defNewGeneration.hpp" 27 #include "gc/serial/serialHeap.hpp" 28 #include "gc/shared/genMemoryPools.hpp" 29 #include "services/memoryManager.hpp" 30 31 SerialHeap::SerialHeap(GenCollectorPolicy* policy) : 32 GenCollectedHeap(policy), _eden_pool(NULL), _survivor_pool(NULL), _old_pool(NULL) { 33 _young_manager = new GCMemoryManager("Copy", "end of minor GC"); 34 _old_manager = new GCMemoryManager("MarkSweepCompact", "end of major GC"); 35 } 36 37 void SerialHeap::initialize_serviceability() { 38 39 DefNewGeneration* young = (DefNewGeneration*) young_gen(); 40 41 // Add a memory pool for each space and young gen doesn't 42 // support low memory detection as it is expected to get filled up. 43 _eden_pool = new ContiguousSpacePool(young->eden(), 44 "Eden Space", 45 young->max_eden_size(), 46 false /* support_usage_threshold */); 47 _survivor_pool = new SurvivorContiguousSpacePool(young, 48 "Survivor Space", 49 young->max_survivor_size(), 50 false /* support_usage_threshold */); 51 Generation* old = old_gen(); 52 _old_pool = new GenerationPool(old, "Tenured Gen", true); 53 54 _young_manager->add_pool(_eden_pool); 55 _young_manager->add_pool(_survivor_pool); 56 young->set_gc_manager(_young_manager); 57 58 _old_manager->add_pool(_eden_pool); 59 _old_manager->add_pool(_survivor_pool); 60 _old_manager->add_pool(_old_pool); 61 old->set_gc_manager(_old_manager); 62 63 } 64 65 void SerialHeap::check_gen_kinds() { 66 assert(young_gen()->kind() == Generation::DefNew, 67 "Wrong youngest generation type"); 68 assert(old_gen()->kind() == Generation::MarkSweepCompact, 69 "Wrong generation kind"); 70 } 71 72 GrowableArray<GCMemoryManager*> SerialHeap::memory_managers() { 73 GrowableArray<GCMemoryManager*> memory_managers(2); 74 memory_managers.append(_young_manager); 75 memory_managers.append(_old_manager); 76 return memory_managers; 77 } 78 79 GrowableArray<MemoryPool*> SerialHeap::memory_pools() { 80 GrowableArray<MemoryPool*> memory_pools(3); 81 memory_pools.append(_eden_pool); 82 memory_pools.append(_survivor_pool); | 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "gc/serial/defNewGeneration.hpp" 27 #include "gc/serial/serialHeap.hpp" 28 #include "gc/shared/genMemoryPools.hpp" 29 #include "gc/shared/generationSpec.hpp" 30 #include "gc/shared/gcPolicyCounters.hpp" 31 #include "services/memoryManager.hpp" 32 33 SerialHeap::SerialHeap(const SerialSettings& settings) : 34 GenCollectedHeap(settings, 35 Generation::DefNew, 36 Generation::MarkSweepCompact), 37 _settings(settings), 38 _eden_pool(NULL), 39 _survivor_pool(NULL), 40 _old_pool(NULL) { 41 _young_manager = new GCMemoryManager("Copy", "end of minor GC"); 42 _old_manager = new GCMemoryManager("MarkSweepCompact", "end of major GC"); 43 } 44 45 void SerialHeap::initialize_serviceability() { 46 47 DefNewGeneration* young = (DefNewGeneration*) young_gen(); 48 49 // Add a memory pool for each space and young gen doesn't 50 // support low memory detection as it is expected to get filled up. 51 _eden_pool = new ContiguousSpacePool(young->eden(), 52 "Eden Space", 53 young->max_eden_size(), 54 false /* support_usage_threshold */); 55 _survivor_pool = new SurvivorContiguousSpacePool(young, 56 "Survivor Space", 57 young->max_survivor_size(), 58 false /* support_usage_threshold */); 59 Generation* old = old_gen(); 60 _old_pool = new GenerationPool(old, "Tenured Gen", true); 61 62 _young_manager->add_pool(_eden_pool); 63 _young_manager->add_pool(_survivor_pool); 64 young->set_gc_manager(_young_manager); 65 66 _old_manager->add_pool(_eden_pool); 67 _old_manager->add_pool(_survivor_pool); 68 _old_manager->add_pool(_old_pool); 69 old->set_gc_manager(_old_manager); 70 71 } 72 73 void SerialHeap::initialize_gc_policy_counters() { 74 initialize_gc_policy_counters_helper("Copy:MSC"); 75 } 76 77 void SerialHeap::check_gen_kinds() { 78 assert(young_gen()->kind() == Generation::DefNew, 79 "Wrong youngest generation type"); 80 assert(old_gen()->kind() == Generation::MarkSweepCompact, 81 "Wrong generation kind"); 82 } 83 84 GrowableArray<GCMemoryManager*> SerialHeap::memory_managers() { 85 GrowableArray<GCMemoryManager*> memory_managers(2); 86 memory_managers.append(_young_manager); 87 memory_managers.append(_old_manager); 88 return memory_managers; 89 } 90 91 GrowableArray<MemoryPool*> SerialHeap::memory_pools() { 92 GrowableArray<MemoryPool*> memory_pools(3); 93 memory_pools.append(_eden_pool); 94 memory_pools.append(_survivor_pool); |