1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   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/cms/compactibleFreeListSpace.hpp"
  27 #include "gc/cms/concurrentMarkSweepGeneration.hpp"
  28 #include "gc/cms/concurrentMarkSweepThread.hpp"
  29 #include "gc/cms/cmsHeap.hpp"
  30 #include "gc/cms/parNewGeneration.hpp"
  31 #include "gc/cms/vmCMSOperations.hpp"
  32 #include "gc/shared/genMemoryPools.hpp"
  33 #include "gc/shared/genOopClosures.inline.hpp"
  34 #include "gc/shared/strongRootsScope.hpp"
  35 #include "gc/shared/workgroup.hpp"
  36 #include "oops/oop.inline.hpp"
  37 #include "runtime/vmThread.hpp"
  38 #include "services/memoryManager.hpp"
  39 #include "utilities/stack.inline.hpp"
  40 
  41 class CompactibleFreeListSpacePool : public CollectedMemoryPool {
  42 private:
  43   CompactibleFreeListSpace* _space;
  44 public:
  45   CompactibleFreeListSpacePool(CompactibleFreeListSpace* space,
  46                                const char* name,
  47                                size_t max_size,
  48                                bool support_usage_threshold) :
  49     CollectedMemoryPool(name, space->capacity(), max_size, support_usage_threshold),
  50     _space(space) {
  51   }
  52 
  53   MemoryUsage get_memory_usage() {
  54     size_t max_heap_size   = (available_for_allocation() ? max_size() : 0);
  55     size_t used      = used_in_bytes();
  56     size_t committed = _space->capacity();
  57 
  58     return MemoryUsage(initial_size(), used, committed, max_heap_size);
  59   }
  60 
  61   size_t used_in_bytes() {
  62     return _space->used();
  63   }
  64 };
  65 
  66 CMSHeap::CMSHeap(GenCollectorPolicy *policy) :
  67   GenCollectedHeap(policy), _eden_pool(NULL), _survivor_pool(NULL), _old_pool(NULL) {
  68   _young_manager = new GCMemoryManager("ParNew", "end of minor GC");
  69   _old_manager = new GCMemoryManager("ConcurrentMarkSweep", "end of major GC");
  70 
  71   _workers = new WorkGang("GC Thread", ParallelGCThreads,
  72                           /* are_GC_task_threads */true,
  73                           /* are_ConcurrentGC_threads */false);
  74   _workers->initialize_workers();
  75 }
  76 
  77 jint CMSHeap::initialize() {
  78   jint status = GenCollectedHeap::initialize();
  79   if (status != JNI_OK) return status;
  80 
  81   // If we are running CMS, create the collector responsible
  82   // for collecting the CMS generations.
  83   assert(collector_policy()->is_concurrent_mark_sweep_policy(), "must be CMS policy");
  84   if (!create_cms_collector()) {
  85     return JNI_ENOMEM;
  86   }
  87 
  88   ParNewGeneration* young = (ParNewGeneration*) young_gen();
  89   _eden_pool = new ContiguousSpacePool(young->eden(),
  90                                        "Par Eden Space",
  91                                        young->max_eden_size(),
  92                                        false);
  93 
  94   _survivor_pool = new SurvivorContiguousSpacePool(young,
  95                                                    "Par Survivor Space",
  96                                                    young->max_survivor_size(),
  97                                                    false);
  98 
  99   ConcurrentMarkSweepGeneration* old = (ConcurrentMarkSweepGeneration*) old_gen();
 100   _old_pool = new CompactibleFreeListSpacePool(old->cmsSpace(),
 101                                                "CMS Old Gen",
 102                                                old->reserved().byte_size(),
 103                                                true);
 104 
 105   _young_manager->add_pool(_eden_pool);
 106   _young_manager->add_pool(_survivor_pool);
 107   young->set_gc_manager(_young_manager);
 108 
 109   _old_manager->add_pool(_eden_pool);
 110   _old_manager->add_pool(_survivor_pool);
 111   _old_manager->add_pool(_old_pool);
 112   old ->set_gc_manager(_old_manager);
 113 
 114   return JNI_OK;
 115 }
 116 
 117 void CMSHeap::check_gen_kinds() {
 118   assert(young_gen()->kind() == Generation::ParNew,
 119          "Wrong youngest generation type");
 120   assert(old_gen()->kind() == Generation::ConcurrentMarkSweep,
 121          "Wrong generation kind");
 122 }
 123 
 124 CMSHeap* CMSHeap::heap() {
 125   CollectedHeap* heap = Universe::heap();
 126   assert(heap != NULL, "Uninitialized access to CMSHeap::heap()");
 127   assert(heap->kind() == CollectedHeap::CMSHeap, "Not a CMSHeap");
 128   return (CMSHeap*) heap;
 129 }
 130 
 131 void CMSHeap::gc_threads_do(ThreadClosure* tc) const {
 132   assert(workers() != NULL, "should have workers here");
 133   workers()->threads_do(tc);
 134   ConcurrentMarkSweepThread::threads_do(tc);
 135 }
 136 
 137 void CMSHeap::print_gc_threads_on(outputStream* st) const {
 138   assert(workers() != NULL, "should have workers here");
 139   workers()->print_worker_threads_on(st);
 140   ConcurrentMarkSweepThread::print_all_on(st);
 141 }
 142 
 143 void CMSHeap::print_on_error(outputStream* st) const {
 144   GenCollectedHeap::print_on_error(st);
 145   st->cr();
 146   CMSCollector::print_on_error(st);
 147 }
 148 
 149 bool CMSHeap::create_cms_collector() {
 150   assert(old_gen()->kind() == Generation::ConcurrentMarkSweep,
 151          "Unexpected generation kinds");
 152   assert(gen_policy()->is_concurrent_mark_sweep_policy(), "Unexpected policy type");
 153   CMSCollector* collector =
 154     new CMSCollector((ConcurrentMarkSweepGeneration*) old_gen(),
 155                      rem_set(),
 156                      gen_policy()->as_concurrent_mark_sweep_policy());
 157 
 158   if (collector == NULL || !collector->completed_initialization()) {
 159     if (collector) {
 160       delete collector; // Be nice in embedded situation
 161     }
 162     vm_shutdown_during_initialization("Could not create CMS collector");
 163     return false;
 164   }
 165   return true; // success
 166 }
 167 
 168 void CMSHeap::collect(GCCause::Cause cause) {
 169   if (should_do_concurrent_full_gc(cause)) {
 170     // Mostly concurrent full collection.
 171     collect_mostly_concurrent(cause);
 172   } else {
 173     GenCollectedHeap::collect(cause);
 174   }
 175 }
 176 
 177 bool CMSHeap::should_do_concurrent_full_gc(GCCause::Cause cause) {
 178   switch (cause) {
 179     case GCCause::_gc_locker:           return GCLockerInvokesConcurrent;
 180     case GCCause::_java_lang_system_gc:
 181     case GCCause::_dcmd_gc_run:         return ExplicitGCInvokesConcurrent;
 182     default:                            return false;
 183   }
 184 }
 185 
 186 void CMSHeap::collect_mostly_concurrent(GCCause::Cause cause) {
 187   assert(!Heap_lock->owned_by_self(), "Should not own Heap_lock");
 188 
 189   MutexLocker ml(Heap_lock);
 190   // Read the GC counts while holding the Heap_lock
 191   unsigned int full_gc_count_before = total_full_collections();
 192   unsigned int gc_count_before      = total_collections();
 193   {
 194     MutexUnlocker mu(Heap_lock);
 195     VM_GenCollectFullConcurrent op(gc_count_before, full_gc_count_before, cause);
 196     VMThread::execute(&op);
 197   }
 198 }
 199 
 200 void CMSHeap::stop() {
 201   ConcurrentMarkSweepThread::cmst()->stop();
 202 }
 203 
 204 void CMSHeap::safepoint_synchronize_begin() {
 205   ConcurrentMarkSweepThread::synchronize(false);
 206 }
 207 
 208 void CMSHeap::safepoint_synchronize_end() {
 209   ConcurrentMarkSweepThread::desynchronize(false);
 210 }
 211 
 212 void CMSHeap::cms_process_roots(StrongRootsScope* scope,
 213                                 bool young_gen_as_roots,
 214                                 ScanningOption so,
 215                                 bool only_strong_roots,
 216                                 OopsInGenClosure* root_closure,
 217                                 CLDClosure* cld_closure) {
 218   MarkingCodeBlobClosure mark_code_closure(root_closure, !CodeBlobToOopClosure::FixRelocations);
 219   OopsInGenClosure* weak_roots = only_strong_roots ? NULL : root_closure;
 220   CLDClosure* weak_cld_closure = only_strong_roots ? NULL : cld_closure;
 221 
 222   process_roots(scope, so, root_closure, weak_roots, cld_closure, weak_cld_closure, &mark_code_closure);
 223   if (!only_strong_roots) {
 224     process_string_table_roots(scope, root_closure);
 225   }
 226 
 227   if (young_gen_as_roots &&
 228       !_process_strong_tasks->is_task_claimed(GCH_PS_younger_gens)) {
 229     root_closure->set_generation(young_gen());
 230     young_gen()->oop_iterate(root_closure);
 231     root_closure->reset_generation();
 232   }
 233 
 234   _process_strong_tasks->all_tasks_completed(scope->n_threads());
 235 }
 236 
 237 void CMSHeap::gc_prologue(bool full) {
 238   always_do_update_barrier = false;
 239   GenCollectedHeap::gc_prologue(full);
 240 };
 241 
 242 void CMSHeap::gc_epilogue(bool full) {
 243   GenCollectedHeap::gc_epilogue(full);
 244   always_do_update_barrier = true;
 245 };
 246 
 247 GrowableArray<GCMemoryManager*> CMSHeap::memory_managers() {
 248   GrowableArray<GCMemoryManager*> memory_managers(2);
 249   memory_managers.append(_young_manager);
 250   memory_managers.append(_old_manager);
 251   return memory_managers;
 252 }
 253 
 254 GrowableArray<MemoryPool*> CMSHeap::memory_pools() {
 255   GrowableArray<MemoryPool*> memory_pools(3);
 256   memory_pools.append(_eden_pool);
 257   memory_pools.append(_survivor_pool);
 258   memory_pools.append(_old_pool);
 259   return memory_pools;
 260 }