src/hotspot/share/gc/shared/genCollectedHeap.cpp
changeset 49048 4e8c86b75428
parent 49047 8f004146e407
child 49049 effb50eeea4e
equal deleted inserted replaced
49047:8f004146e407 49048:4e8c86b75428
    28 #include "classfile/stringTable.hpp"
    28 #include "classfile/stringTable.hpp"
    29 #include "classfile/systemDictionary.hpp"
    29 #include "classfile/systemDictionary.hpp"
    30 #include "classfile/vmSymbols.hpp"
    30 #include "classfile/vmSymbols.hpp"
    31 #include "code/codeCache.hpp"
    31 #include "code/codeCache.hpp"
    32 #include "code/icBuffer.hpp"
    32 #include "code/icBuffer.hpp"
       
    33 #include "gc/shared/adaptiveSizePolicy.hpp"
    33 #include "gc/shared/cardTableRS.hpp"
    34 #include "gc/shared/cardTableRS.hpp"
    34 #include "gc/shared/collectedHeap.inline.hpp"
    35 #include "gc/shared/collectedHeap.inline.hpp"
    35 #include "gc/shared/collectorCounters.hpp"
    36 #include "gc/shared/collectorCounters.hpp"
    36 #include "gc/shared/gcId.hpp"
    37 #include "gc/shared/gcId.hpp"
    37 #include "gc/shared/gcLocker.inline.hpp"
    38 #include "gc/shared/gcLocker.inline.hpp"
   109   clear_incremental_collection_failed();
   110   clear_incremental_collection_failed();
   110 
   111 
   111   return JNI_OK;
   112   return JNI_OK;
   112 }
   113 }
   113 
   114 
       
   115 void GenCollectedHeap::initialize_size_policy(size_t init_eden_size,
       
   116                                               size_t init_promo_size,
       
   117                                               size_t init_survivor_size) {
       
   118   const double max_gc_pause_sec = ((double) MaxGCPauseMillis) / 1000.0;
       
   119   _size_policy = new AdaptiveSizePolicy(init_eden_size,
       
   120                                         init_promo_size,
       
   121                                         init_survivor_size,
       
   122                                         max_gc_pause_sec,
       
   123                                         GCTimeRatio);
       
   124 }
       
   125 
   114 char* GenCollectedHeap::allocate(size_t alignment,
   126 char* GenCollectedHeap::allocate(size_t alignment,
   115                                  ReservedSpace* heap_rs){
   127                                  ReservedSpace* heap_rs){
   116   // Now figure out the total size.
   128   // Now figure out the total size.
   117   const size_t pageSize = UseLargePages ? os::large_page_size() : os::vm_page_size();
   129   const size_t pageSize = UseLargePages ? os::large_page_size() : os::vm_page_size();
   118   assert(alignment % pageSize == 0, "Must be");
   130   assert(alignment % pageSize == 0, "Must be");
   146   CollectedHeap::post_initialize();
   158   CollectedHeap::post_initialize();
   147   ref_processing_init();
   159   ref_processing_init();
   148   check_gen_kinds();
   160   check_gen_kinds();
   149   DefNewGeneration* def_new_gen = (DefNewGeneration*)_young_gen;
   161   DefNewGeneration* def_new_gen = (DefNewGeneration*)_young_gen;
   150 
   162 
   151   _gen_policy->initialize_size_policy(def_new_gen->eden()->capacity(),
   163   initialize_size_policy(def_new_gen->eden()->capacity(),
   152                                       _old_gen->capacity(),
   164                          _old_gen->capacity(),
   153                                       def_new_gen->from()->capacity());
   165                          def_new_gen->from()->capacity());
   154 
   166 
   155   _gen_policy->initialize_gc_policy_counters();
   167   _gen_policy->initialize_gc_policy_counters();
   156 }
   168 }
   157 
   169 
   158 void GenCollectedHeap::ref_processing_init() {
   170 void GenCollectedHeap::ref_processing_init() {
   330       // has been done.  If the gc time limit was exceeded the
   342       // has been done.  If the gc time limit was exceeded the
   331       // this time, return NULL so that an out-of-memory
   343       // this time, return NULL so that an out-of-memory
   332       // will be thrown.  Clear gc_overhead_limit_exceeded
   344       // will be thrown.  Clear gc_overhead_limit_exceeded
   333       // so that the overhead exceeded does not persist.
   345       // so that the overhead exceeded does not persist.
   334 
   346 
   335       const bool limit_exceeded = gen_policy()->size_policy()->gc_overhead_limit_exceeded();
   347       const bool limit_exceeded = size_policy()->gc_overhead_limit_exceeded();
   336       const bool softrefs_clear = soft_ref_policy()->all_soft_refs_clear();
   348       const bool softrefs_clear = soft_ref_policy()->all_soft_refs_clear();
   337 
   349 
   338       if (limit_exceeded && softrefs_clear) {
   350       if (limit_exceeded && softrefs_clear) {
   339         *gc_overhead_limit_was_exceeded = true;
   351         *gc_overhead_limit_was_exceeded = true;
   340         gen_policy()->size_policy()->set_gc_overhead_limit_exceeded(false);
   352         size_policy()->set_gc_overhead_limit_exceeded(false);
   341         if (op.result() != NULL) {
   353         if (op.result() != NULL) {
   342           CollectedHeap::fill_with_object(op.result(), size);
   354           CollectedHeap::fill_with_object(op.result(), size);
   343         }
   355         }
   344         return NULL;
   356         return NULL;
   345       }
   357       }