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_VM_GC_SHARED_VMGCOPERATIONS_HPP
26 #define SHARE_VM_GC_SHARED_VMGCOPERATIONS_HPP
27
28 #include "gc/shared/collectedHeap.hpp"
29 #include "gc/shared/genCollectedHeap.hpp"
30 #include "memory/heapInspection.hpp"
31 #include "prims/jvmtiExport.hpp"
32 #include "runtime/handles.hpp"
33 #include "runtime/jniHandles.hpp"
34 #include "runtime/synchronizer.hpp"
35 #include "runtime/vm_operations.hpp"
36
37 // The following class hierarchy represents
38 // a set of operations (VM_Operation) related to GC.
39 //
40 // VM_Operation
41 // VM_GC_Operation
42 // VM_GC_HeapInspection
43 // VM_GenCollectFull
44 // VM_GenCollectFullConcurrent
45 // VM_ParallelGCSystemGC
46 // VM_CollectForAllocation
47 // VM_GenCollectForAllocation
48 // VM_ParallelGCFailedAllocation
149 }
150
151 ~VM_GC_HeapInspection() {}
152 virtual VMOp_Type type() const { return VMOp_GC_HeapInspection; }
153 virtual bool skip_operation() const;
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 class VM_CollectForAllocation : public VM_GC_Operation {
164 protected:
165 size_t _word_size; // Size of object to be allocated (in number of words)
166 HeapWord* _result; // Allocation result (NULL if allocation failed)
167
168 public:
169 VM_CollectForAllocation(size_t word_size, uint gc_count_before, GCCause::Cause cause)
170 : VM_GC_Operation(gc_count_before, cause), _result(NULL), _word_size(word_size) {}
171
172 HeapWord* result() const {
173 return _result;
174 }
175 };
176
177 class VM_GenCollectForAllocation : public VM_CollectForAllocation {
178 private:
179 bool _tlab; // alloc is of a tlab.
180 public:
181 VM_GenCollectForAllocation(size_t word_size,
182 bool tlab,
183 uint gc_count_before)
184 : VM_CollectForAllocation(word_size, gc_count_before, GCCause::_allocation_failure),
185 _tlab(tlab) {
186 assert(word_size != 0, "An allocation should always be requested with this operation.");
187 }
188 ~VM_GenCollectForAllocation() {}
189 virtual VMOp_Type type() const { return VMOp_GenCollectForAllocation; }
190 virtual void doit();
201 GCCause::Cause gc_cause,
202 GenCollectedHeap::GenerationType max_generation)
203 : VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true /* full */),
204 _max_generation(max_generation) { }
205 ~VM_GenCollectFull() {}
206 virtual VMOp_Type type() const { return VMOp_GenCollectFull; }
207 virtual void doit();
208 };
209
210 class VM_CollectForMetadataAllocation: public VM_GC_Operation {
211 private:
212 MetaWord* _result;
213 size_t _size; // size of object to be allocated
214 Metaspace::MetadataType _mdtype;
215 ClassLoaderData* _loader_data;
216 public:
217 VM_CollectForMetadataAllocation(ClassLoaderData* loader_data,
218 size_t size, Metaspace::MetadataType mdtype,
219 uint gc_count_before,
220 uint full_gc_count_before,
221 GCCause::Cause gc_cause)
222 : VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true),
223 _loader_data(loader_data), _size(size), _mdtype(mdtype), _result(NULL) {
224 }
225 virtual VMOp_Type type() const { return VMOp_CollectForMetadataAllocation; }
226 virtual void doit();
227 MetaWord* result() const { return _result; }
228
229 bool initiate_concurrent_GC();
230 };
231
232 class SvcGCMarker : public StackObj {
233 private:
234 JvmtiGCMarker _jgcm;
235 public:
236 typedef enum { MINOR, FULL, OTHER } reason_type;
237
238 SvcGCMarker(reason_type reason ) {
239 VM_GC_Operation::notify_gc_begin(reason == FULL);
240 }
241
242 ~SvcGCMarker() {
243 VM_GC_Operation::notify_gc_end();
244 }
|
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_VM_GC_SHARED_VMGCOPERATIONS_HPP
26 #define SHARE_VM_GC_SHARED_VMGCOPERATIONS_HPP
27
28 #include "gc/shared/collectedHeap.hpp"
29 #include "gc/shared/gcId.hpp"
30 #include "gc/shared/genCollectedHeap.hpp"
31 #include "memory/heapInspection.hpp"
32 #include "prims/jvmtiExport.hpp"
33 #include "runtime/handles.hpp"
34 #include "runtime/jniHandles.hpp"
35 #include "runtime/synchronizer.hpp"
36 #include "runtime/vm_operations.hpp"
37
38 // The following class hierarchy represents
39 // a set of operations (VM_Operation) related to GC.
40 //
41 // VM_Operation
42 // VM_GC_Operation
43 // VM_GC_HeapInspection
44 // VM_GenCollectFull
45 // VM_GenCollectFullConcurrent
46 // VM_ParallelGCSystemGC
47 // VM_CollectForAllocation
48 // VM_GenCollectForAllocation
49 // VM_ParallelGCFailedAllocation
150 }
151
152 ~VM_GC_HeapInspection() {}
153 virtual VMOp_Type type() const { return VMOp_GC_HeapInspection; }
154 virtual bool skip_operation() const;
155 virtual void doit();
156 void set_csv_format(bool value) {_csv_format = value;}
157 void set_print_help(bool value) {_print_help = value;}
158 void set_print_class_stats(bool value) {_print_class_stats = value;}
159 void set_columns(const char* value) {_columns = value;}
160 protected:
161 bool collect();
162 };
163
164 class VM_CollectForAllocation : public VM_GC_Operation {
165 protected:
166 size_t _word_size; // Size of object to be allocated (in number of words)
167 HeapWord* _result; // Allocation result (NULL if allocation failed)
168
169 public:
170 VM_CollectForAllocation(size_t word_size, uint gc_count_before, GCCause::Cause cause);
171
172 HeapWord* result() const {
173 return _result;
174 }
175 };
176
177 class VM_GenCollectForAllocation : public VM_CollectForAllocation {
178 private:
179 bool _tlab; // alloc is of a tlab.
180 public:
181 VM_GenCollectForAllocation(size_t word_size,
182 bool tlab,
183 uint gc_count_before)
184 : VM_CollectForAllocation(word_size, gc_count_before, GCCause::_allocation_failure),
185 _tlab(tlab) {
186 assert(word_size != 0, "An allocation should always be requested with this operation.");
187 }
188 ~VM_GenCollectForAllocation() {}
189 virtual VMOp_Type type() const { return VMOp_GenCollectForAllocation; }
190 virtual void doit();
201 GCCause::Cause gc_cause,
202 GenCollectedHeap::GenerationType max_generation)
203 : VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true /* full */),
204 _max_generation(max_generation) { }
205 ~VM_GenCollectFull() {}
206 virtual VMOp_Type type() const { return VMOp_GenCollectFull; }
207 virtual void doit();
208 };
209
210 class VM_CollectForMetadataAllocation: public VM_GC_Operation {
211 private:
212 MetaWord* _result;
213 size_t _size; // size of object to be allocated
214 Metaspace::MetadataType _mdtype;
215 ClassLoaderData* _loader_data;
216 public:
217 VM_CollectForMetadataAllocation(ClassLoaderData* loader_data,
218 size_t size, Metaspace::MetadataType mdtype,
219 uint gc_count_before,
220 uint full_gc_count_before,
221 GCCause::Cause gc_cause);
222 virtual VMOp_Type type() const { return VMOp_CollectForMetadataAllocation; }
223 virtual void doit();
224 MetaWord* result() const { return _result; }
225
226 bool initiate_concurrent_GC();
227 };
228
229 class SvcGCMarker : public StackObj {
230 private:
231 JvmtiGCMarker _jgcm;
232 public:
233 typedef enum { MINOR, FULL, OTHER } reason_type;
234
235 SvcGCMarker(reason_type reason ) {
236 VM_GC_Operation::notify_gc_begin(reason == FULL);
237 }
238
239 ~SvcGCMarker() {
240 VM_GC_Operation::notify_gc_end();
241 }
|