src/share/vm/services/memoryService.cpp

Print this page
rev 4273 : imported patch JDK-8009156


 223   return (MemoryPool*) pool;
 224 }
 225 
 226 #if INCLUDE_ALL_GCS
 227 MemoryPool* MemoryService::add_cms_space(CompactibleFreeListSpace* space,
 228                                          const char* name,
 229                                          bool is_heap,
 230                                          size_t max_size,
 231                                          bool support_usage_threshold) {
 232   MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);
 233   CompactibleFreeListSpacePool* pool = new CompactibleFreeListSpacePool(space, name, type, max_size, support_usage_threshold);
 234   _pools_list->append(pool);
 235   return (MemoryPool*) pool;
 236 }
 237 #endif // INCLUDE_ALL_GCS
 238 
 239 // Add memory pool(s) for one generation
 240 void MemoryService::add_generation_memory_pool(Generation* gen,
 241                                                MemoryManager* major_mgr,
 242                                                MemoryManager* minor_mgr) {

 243   Generation::Name kind = gen->kind();
 244   int index = _pools_list->length();
 245 
 246   switch (kind) {
 247     case Generation::DefNew: {
 248       assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers");
 249       DefNewGeneration* young_gen = (DefNewGeneration*) gen;
 250       // Add a memory pool for each space and young gen doesn't
 251       // support low memory detection as it is expected to get filled up.
 252       MemoryPool* eden = add_space(young_gen->eden(),
 253                                    "Eden Space",
 254                                    true, /* is_heap */
 255                                    young_gen->max_eden_size(),
 256                                    false /* support_usage_threshold */);
 257       MemoryPool* survivor = add_survivor_spaces(young_gen,
 258                                                  "Survivor Space",
 259                                                  true, /* is_heap */
 260                                                  young_gen->max_survivor_size(),
 261                                                  false /* support_usage_threshold */);
 262       break;




 223   return (MemoryPool*) pool;
 224 }
 225 
 226 #if INCLUDE_ALL_GCS
 227 MemoryPool* MemoryService::add_cms_space(CompactibleFreeListSpace* space,
 228                                          const char* name,
 229                                          bool is_heap,
 230                                          size_t max_size,
 231                                          bool support_usage_threshold) {
 232   MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap);
 233   CompactibleFreeListSpacePool* pool = new CompactibleFreeListSpacePool(space, name, type, max_size, support_usage_threshold);
 234   _pools_list->append(pool);
 235   return (MemoryPool*) pool;
 236 }
 237 #endif // INCLUDE_ALL_GCS
 238 
 239 // Add memory pool(s) for one generation
 240 void MemoryService::add_generation_memory_pool(Generation* gen,
 241                                                MemoryManager* major_mgr,
 242                                                MemoryManager* minor_mgr) {
 243   guarantee(gen != NULL, "No generation for memory pool");
 244   Generation::Name kind = gen->kind();
 245   int index = _pools_list->length();
 246 
 247   switch (kind) {
 248     case Generation::DefNew: {
 249       assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers");
 250       DefNewGeneration* young_gen = (DefNewGeneration*) gen;
 251       // Add a memory pool for each space and young gen doesn't
 252       // support low memory detection as it is expected to get filled up.
 253       MemoryPool* eden = add_space(young_gen->eden(),
 254                                    "Eden Space",
 255                                    true, /* is_heap */
 256                                    young_gen->max_eden_size(),
 257                                    false /* support_usage_threshold */);
 258       MemoryPool* survivor = add_survivor_spaces(young_gen,
 259                                                  "Survivor Space",
 260                                                  true, /* is_heap */
 261                                                  young_gen->max_survivor_size(),
 262                                                  false /* support_usage_threshold */);
 263       break;