21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_VMGCOPERATIONS_HPP
26 #define SHARE_VM_GC_IMPLEMENTATION_SHARED_VMGCOPERATIONS_HPP
27
28 #include "memory/heapInspection.hpp"
29 #include "runtime/handles.hpp"
30 #include "runtime/jniHandles.hpp"
31 #include "runtime/synchronizer.hpp"
32 #include "runtime/vm_operations.hpp"
33 #include "prims/jvmtiExport.hpp"
34
35 // The following class hierarchy represents
36 // a set of operations (VM_Operation) related to GC.
37 //
38 // VM_Operation
39 // VM_GC_Operation
40 // VM_GC_HeapInspection
41 // VM_GenCollectForAllocation
42 // VM_GenCollectFull
43 // VM_GenCollectFullConcurrent
44 // VM_ParallelGCFailedAllocation
45 // VM_ParallelGCSystemGC
46 // VM_GC_Operation
47 // - implements methods common to all classes in the hierarchy:
48 // prevents multiple gc requests and manages lock on heap;
49 //
50 // VM_GC_HeapInspection
51 // - prints class histogram on SIGBREAK if PrintClassHistogram
52 // is specified; and also the attach "inspectheap" operation
53 //
54 // VM_GenCollectForAllocation
55 // VM_ParallelGCFailedAllocation
56 // - this operation is invoked when allocation is failed;
57 // operation performs garbage collection and tries to
58 // allocate afterwards;
59 //
60 // VM_GenCollectFull
61 // VM_GenCollectFullConcurrent
62 // VM_ParallelGCSystemGC
63 // - these operations preform full collection of heaps of
64 // different kind
65 //
66
67 class VM_GC_Operation: public VM_Operation {
68 protected:
69 BasicLock _pending_list_basic_lock; // for refs pending list notification (PLL)
70 uint _gc_count_before; // gc count before acquiring PLL
71 uint _full_gc_count_before; // full gc count before acquiring PLL
72 bool _full; // whether a "full" collection
73 bool _prologue_succeeded; // whether doit_prologue succeeded
143 _full_gc = request_full_gc;
144 _csv_format = false;
145 _print_help = false;
146 _print_class_stats = false;
147 _columns = NULL;
148 }
149
150 ~VM_GC_HeapInspection() {}
151 virtual VMOp_Type type() const { return VMOp_GC_HeapInspection; }
152 virtual bool skip_operation() const;
153 virtual bool doit_prologue();
154 virtual void doit();
155 void set_csv_format(bool value) {_csv_format = value;}
156 void set_print_help(bool value) {_print_help = value;}
157 void set_print_class_stats(bool value) {_print_class_stats = value;}
158 void set_columns(const char* value) {_columns = value;}
159 protected:
160 bool collect();
161 };
162
163
164 class VM_GenCollectForAllocation: public VM_GC_Operation {
165 private:
166 HeapWord* _res;
167 size_t _size; // size of object to be allocated.
168 bool _tlab; // alloc is of a tlab.
169 public:
170 VM_GenCollectForAllocation(size_t size,
171 bool tlab,
172 uint gc_count_before)
173 : VM_GC_Operation(gc_count_before, GCCause::_allocation_failure),
174 _size(size),
175 _tlab(tlab) {
176 _res = NULL;
177 }
178 ~VM_GenCollectForAllocation() {}
179 virtual VMOp_Type type() const { return VMOp_GenCollectForAllocation; }
180 virtual void doit();
181 HeapWord* result() const { return _res; }
182 };
183
184 // VM operation to invoke a collection of the heap as a
185 // GenCollectedHeap heap.
186 class VM_GenCollectFull: public VM_GC_Operation {
187 private:
188 int _max_level;
189 public:
190 VM_GenCollectFull(uint gc_count_before,
191 uint full_gc_count_before,
192 GCCause::Cause gc_cause,
193 int max_level)
194 : VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true /* full */),
195 _max_level(max_level) { }
196 ~VM_GenCollectFull() {}
197 virtual VMOp_Type type() const { return VMOp_GenCollectFull; }
198 virtual void doit();
199 };
200
201 class VM_CollectForMetadataAllocation: public VM_GC_Operation {
|
21 * questions.
22 *
23 */
24
25 #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_VMGCOPERATIONS_HPP
26 #define SHARE_VM_GC_IMPLEMENTATION_SHARED_VMGCOPERATIONS_HPP
27
28 #include "memory/heapInspection.hpp"
29 #include "runtime/handles.hpp"
30 #include "runtime/jniHandles.hpp"
31 #include "runtime/synchronizer.hpp"
32 #include "runtime/vm_operations.hpp"
33 #include "prims/jvmtiExport.hpp"
34
35 // The following class hierarchy represents
36 // a set of operations (VM_Operation) related to GC.
37 //
38 // VM_Operation
39 // VM_GC_Operation
40 // VM_GC_HeapInspection
41 // VM_GenCollectFull
42 // VM_GenCollectFullConcurrent
43 // VM_ParallelGCSystemGC
44 // VM_CollectForAllocation
45 // VM_GenCollectForAllocation
46 // VM_ParallelGCFailedAllocation
47 // VM_GC_Operation
48 // - implements methods common to all classes in the hierarchy:
49 // prevents multiple gc requests and manages lock on heap;
50 //
51 // VM_GC_HeapInspection
52 // - prints class histogram on SIGBREAK if PrintClassHistogram
53 // is specified; and also the attach "inspectheap" operation
54 //
55 // VM_CollectForAllocation
56 // VM_GenCollectForAllocation
57 // VM_ParallelGCFailedAllocation
58 // - this operation is invoked when allocation is failed;
59 // operation performs garbage collection and tries to
60 // allocate afterwards;
61 //
62 // VM_GenCollectFull
63 // VM_GenCollectFullConcurrent
64 // VM_ParallelGCSystemGC
65 // - these operations preform full collection of heaps of
66 // different kind
67 //
68
69 class VM_GC_Operation: public VM_Operation {
70 protected:
71 BasicLock _pending_list_basic_lock; // for refs pending list notification (PLL)
72 uint _gc_count_before; // gc count before acquiring PLL
73 uint _full_gc_count_before; // full gc count before acquiring PLL
74 bool _full; // whether a "full" collection
75 bool _prologue_succeeded; // whether doit_prologue succeeded
145 _full_gc = request_full_gc;
146 _csv_format = false;
147 _print_help = false;
148 _print_class_stats = false;
149 _columns = NULL;
150 }
151
152 ~VM_GC_HeapInspection() {}
153 virtual VMOp_Type type() const { return VMOp_GC_HeapInspection; }
154 virtual bool skip_operation() const;
155 virtual bool doit_prologue();
156 virtual void doit();
157 void set_csv_format(bool value) {_csv_format = value;}
158 void set_print_help(bool value) {_print_help = value;}
159 void set_print_class_stats(bool value) {_print_class_stats = value;}
160 void set_columns(const char* value) {_columns = value;}
161 protected:
162 bool collect();
163 };
164
165 class VM_CollectForAllocation : public VM_GC_Operation {
166 protected:
167 size_t _word_size; // Size of object to be allocated (in number of words)
168 HeapWord* _result; // Allocation result (NULL if allocation failed)
169
170 public:
171 VM_CollectForAllocation(size_t word_size, uint gc_count_before, GCCause::Cause cause)
172 : VM_GC_Operation(gc_count_before, cause), _result(NULL), _word_size(word_size) {}
173
174 HeapWord* result() const {
175 return _result;
176 }
177 };
178
179 class VM_GenCollectForAllocation : public VM_CollectForAllocation {
180 private:
181 bool _tlab; // alloc is of a tlab.
182 public:
183 VM_GenCollectForAllocation(size_t word_size,
184 bool tlab,
185 uint gc_count_before)
186 : VM_CollectForAllocation(word_size, gc_count_before, GCCause::_allocation_failure),
187 _tlab(tlab) {
188 assert(word_size != 0, "An allocation should always be requested with this operation.");
189 }
190 ~VM_GenCollectForAllocation() {}
191 virtual VMOp_Type type() const { return VMOp_GenCollectForAllocation; }
192 virtual void doit();
193 };
194
195 // VM operation to invoke a collection of the heap as a
196 // GenCollectedHeap heap.
197 class VM_GenCollectFull: public VM_GC_Operation {
198 private:
199 int _max_level;
200 public:
201 VM_GenCollectFull(uint gc_count_before,
202 uint full_gc_count_before,
203 GCCause::Cause gc_cause,
204 int max_level)
205 : VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true /* full */),
206 _max_level(max_level) { }
207 ~VM_GenCollectFull() {}
208 virtual VMOp_Type type() const { return VMOp_GenCollectFull; }
209 virtual void doit();
210 };
211
212 class VM_CollectForMetadataAllocation: public VM_GC_Operation {
|