Thu, 20 Nov 2008 16:56:09 -0800
6684579: SoftReference processing can be made more efficient
Summary: For current soft-ref clearing policies, we can decide at marking time if a soft-reference will definitely not be cleared, postponing the decision of whether it will definitely be cleared to the final reference processing phase. This can be especially beneficial in the case of concurrent collectors where the marking is usually concurrent but reference processing is usually not.
Reviewed-by: jmasa
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 */
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 //
41 // Forward decl.
42 class CMSCollector;
44 class VM_CMS_Operation: public VM_Operation {
45 protected:
46 CMSCollector* _collector; // associated collector
47 bool _prologue_succeeded; // whether doit_prologue succeeded
49 bool lost_race() const;
51 // java.lang.ref.Reference support
52 void acquire_pending_list_lock();
53 void release_and_notify_pending_list_lock();
55 public:
56 VM_CMS_Operation(CMSCollector* collector):
57 _collector(collector),
58 _prologue_succeeded(false) {}
59 ~VM_CMS_Operation() {}
61 // The legal collector state for executing this CMS op.
62 virtual const CMSCollector::CollectorState legal_state() const = 0;
64 // Whether the pending list lock needs to be held
65 virtual const bool needs_pll() const = 0;
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();
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; }
79 void verify_before_gc();
80 void verify_after_gc();
81 };
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) {}
90 virtual VMOp_Type type() const { return VMOp_CMS_Initial_Mark; }
91 virtual void doit();
93 virtual const CMSCollector::CollectorState legal_state() const {
94 return CMSCollector::InitialMarking;
95 }
97 virtual const bool needs_pll() const {
98 return false;
99 }
100 };
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();
110 virtual const CMSCollector::CollectorState legal_state() const {
111 return CMSCollector::FinalMarking;
112 }
114 virtual const bool needs_pll() const {
115 return true;
116 }
117 };
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 };