1 /*

     2  * Copyright (c) 2017, 2019, 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 #ifndef SHARE_GC_CMS_CMSHEAP_HPP

    26 #define SHARE_GC_CMS_CMSHEAP_HPP

    27 

    28 #include "gc/cms/concurrentMarkSweepGeneration.hpp"

    29 #include "gc/cms/parNewGeneration.hpp"

    30 #include "gc/shared/collectedHeap.hpp"

    31 #include "gc/shared/gcCause.hpp"

    32 #include "gc/shared/genCollectedHeap.hpp"

    33 #include "gc/shared/oopStorageParState.hpp"

    34 #include "utilities/growableArray.hpp"

    35 

    36 class CLDClosure;

    37 class GCMemoryManager;

    38 class MemoryPool;

    39 class OopsInGenClosure;

    40 class outputStream;

    41 class StrongRootsScope;

    42 class ThreadClosure;

    43 class WorkGang;

    44 

    45 class CMSHeap : public GenCollectedHeap {

    46 public:

    47   CMSHeap();

    48 

    49   // Returns JNI_OK on success

    50   virtual jint initialize();

    51   virtual CardTableRS* create_rem_set(const MemRegion& reserved_region);

    52 

    53   // Convenience function to be used in situations where the heap type can be

    54   // asserted to be this type.

    55   static CMSHeap* heap();

    56 

    57   virtual Name kind() const {

    58     return CollectedHeap::CMS;

    59   }

    60 

    61   virtual const char* name() const {

    62     return "Concurrent Mark Sweep";

    63   }

    64 

    65   WorkGang* workers() const { return _workers; }

    66 

    67   virtual void print_gc_threads_on(outputStream* st) const;

    68   virtual void gc_threads_do(ThreadClosure* tc) const;

    69   virtual void print_on_error(outputStream* st) const;

    70 

    71   // Perform a full collection of the heap; intended for use in implementing

    72   // "System.gc". This implies as full a collection as the CollectedHeap

    73   // supports. Caller does not hold the Heap_lock on entry.

    74   void collect(GCCause::Cause cause);

    75 

    76   void stop();

    77   void safepoint_synchronize_begin();

    78   void safepoint_synchronize_end();

    79 

    80   virtual GrowableArray<GCMemoryManager*> memory_managers();

    81   virtual GrowableArray<MemoryPool*> memory_pools();

    82 

    83   // If "young_gen_as_roots" is false, younger generations are

    84   // not scanned as roots; in this case, the caller must be arranging to

    85   // scan the younger generations itself.  (For example, a generation might

    86   // explicitly mark reachable objects in younger generations, to avoid

    87   // excess storage retention.)

    88   void cms_process_roots(StrongRootsScope* scope,

    89                          bool young_gen_as_roots,

    90                          ScanningOption so,

    91                          bool only_strong_roots,

    92                          OopsInGenClosure* root_closure,

    93                          CLDClosure* cld_closure);

    94 

    95   GCMemoryManager* old_manager() const { return _old_manager; }

    96 

    97   ParNewGeneration* young_gen() const {

    98     assert(_young_gen->kind() == Generation::ParNew, "Wrong generation type");

    99     return static_cast<ParNewGeneration*>(_young_gen);

   100   }

   101 

   102   ConcurrentMarkSweepGeneration* old_gen() const {

   103     assert(_old_gen->kind() == Generation::ConcurrentMarkSweep, "Wrong generation kind");

   104     return static_cast<ConcurrentMarkSweepGeneration*>(_old_gen);

   105   }

   106 

   107   // Apply "cur->do_oop" or "older->do_oop" to all the oops in objects

   108   // allocated since the last call to save_marks in the young generation.

   109   // The "cur" closure is applied to references in the younger generation

   110   // at "level", and the "older" closure to older generations.

   111   template <typename OopClosureType1, typename OopClosureType2>

   112   void oop_since_save_marks_iterate(OopClosureType1* cur,

   113                                     OopClosureType2* older);

   114 

   115 private:

   116   WorkGang* _workers;

   117   MemoryPool* _eden_pool;

   118   MemoryPool* _survivor_pool;

   119   MemoryPool* _old_pool;

   120 

   121   virtual void gc_prologue(bool full);

   122   virtual void gc_epilogue(bool full);

   123 

   124   virtual void initialize_serviceability();

   125 

   126   // Accessor for memory state verification support

   127   NOT_PRODUCT(

   128     virtual size_t skip_header_HeapWords() { return CMSCollector::skip_header_HeapWords(); }

   129   )

   130 

   131   // Returns success or failure.

   132   bool create_cms_collector();

   133 

   134   // In support of ExplicitGCInvokesConcurrent functionality

   135   bool should_do_concurrent_full_gc(GCCause::Cause cause);

   136 

   137   void collect_mostly_concurrent(GCCause::Cause cause);

   138 };

   139 

   140 #endif // SHARE_GC_CMS_CMSHEAP_HPP