1 /*

     2  * Copyright 2005-2006 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 // The VM_CMS_Operation is slightly different from

    26 // a VM_GC_Operation -- and would not have subclassed easily

    27 // to VM_GC_Operation without several changes to VM_GC_Operation.

    28 // To minimize the changes, we have replicated some of the VM_GC_Operation

    29 // functionality here. We will consolidate that back by doing subclassing

    30 // as appropriate in Dolphin.

    31 //

    32 //  VM_Operation

    33 //    VM_CMS_Operation

    34 //    - implements the common portion of work done in support

    35 //      of CMS' stop-world phases (initial mark and remark).

    36 //

    37 //      VM_CMS_Initial_Mark

    38 //      VM_CMS_Final_Mark

    39 //

    40 

    41 // Forward decl.

    42 class CMSCollector;

    43 

    44 class VM_CMS_Operation: public VM_Operation {

    45  protected:

    46   CMSCollector*  _collector;                 // associated collector

    47   bool           _prologue_succeeded;     // whether doit_prologue succeeded

    48 

    49   bool lost_race() const;

    50 

    51   // java.lang.ref.Reference support

    52   void acquire_pending_list_lock();

    53   void release_and_notify_pending_list_lock();

    54 

    55  public:

    56   VM_CMS_Operation(CMSCollector* collector):

    57     _collector(collector),

    58     _prologue_succeeded(false) {}

    59   ~VM_CMS_Operation() {}

    60 

    61   // The legal collector state for executing this CMS op.

    62   virtual const CMSCollector::CollectorState legal_state() const = 0;

    63 

    64   // Whether the pending list lock needs to be held

    65   virtual const bool needs_pll() const = 0;

    66 

    67   // Execute operations in the context of the caller,

    68   // prior to execution of the vm operation itself.

    69   virtual bool doit_prologue();

    70   // Execute operations in the context of the caller,

    71   // following completion of the vm operation.

    72   virtual void doit_epilogue();

    73 

    74   virtual bool evaluate_at_safepoint() const { return true; }

    75   virtual bool is_cheap_allocated() const { return false; }

    76   virtual bool allow_nested_vm_operations() const  { return false; }

    77   bool prologue_succeeded() const { return _prologue_succeeded; }

    78 

    79   void verify_before_gc();

    80   void verify_after_gc();

    81 };

    82 

    83 

    84 // VM_CMS_Operation for the initial marking phase of CMS.

    85 class VM_CMS_Initial_Mark: public VM_CMS_Operation {

    86  public:

    87   VM_CMS_Initial_Mark(CMSCollector* _collector) :

    88     VM_CMS_Operation(_collector) {}

    89 

    90   virtual VMOp_Type type() const { return VMOp_CMS_Initial_Mark; }

    91   virtual void doit();

    92 

    93   virtual const CMSCollector::CollectorState legal_state() const {

    94     return CMSCollector::InitialMarking;

    95   }

    96 

    97   virtual const bool needs_pll() const {

    98     return false;

    99   }

   100 };

   101 

   102 // VM_CMS_Operation for the final remark phase of CMS.

   103 class VM_CMS_Final_Remark: public VM_CMS_Operation {

   104  public:

   105   VM_CMS_Final_Remark(CMSCollector* _collector) :

   106     VM_CMS_Operation(_collector) {}

   107   virtual VMOp_Type type() const { return VMOp_CMS_Final_Remark; }

   108   virtual void doit();

   109 

   110   virtual const CMSCollector::CollectorState legal_state() const {

   111     return CMSCollector::FinalMarking;

   112   }

   113 

   114   virtual const bool needs_pll() const {

   115     return true;

   116   }

   117 };

   118 

   119 

   120 // VM operation to invoke a concurrent collection of the heap as a

   121 // GenCollectedHeap heap.

   122 class VM_GenCollectFullConcurrent: public VM_GC_Operation {

   123  public:

   124   VM_GenCollectFullConcurrent(unsigned int gc_count_before,

   125                               unsigned int full_gc_count_before,

   126                               GCCause::Cause gc_cause)

   127     : VM_GC_Operation(gc_count_before, full_gc_count_before, true /* full */) {

   128     _gc_cause = gc_cause;

   129     assert(FullGCCount_lock != NULL && UseConcMarkSweepGC &&

   130            ExplicitGCInvokesConcurrent, "Otherwise shouldn't be here");

   131     assert(UseAsyncConcMarkSweepGC, "Else will hang caller");

   132   }

   133   ~VM_GenCollectFullConcurrent() {}

   134   virtual VMOp_Type type() const { return VMOp_GenCollectFullConcurrent; }

   135   virtual void doit();

   136   virtual void doit_epilogue();

   137   virtual bool is_cheap_allocated() const { return false; }

   138   virtual bool evaluate_at_safepoint() const;

   139 };