1 /*
2 * Copyright (c) 2012, 2013, 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_VM_GC_IMPLEMENTATION_SHARED_GCTIMER_HPP
26 #define SHARE_VM_GC_IMPLEMENTATION_SHARED_GCTIMER_HPP
27
28 #include "memory/allocation.hpp"
29 #include "prims/jni_md.h"
30 #include "utilities/macros.hpp"
31
32 class ConcurrentPhase;
33 class GCPhase;
34 class PausePhase;
35
36 template <class E> class GrowableArray;
37
38 class PhaseVisitor {
39 public:
40 virtual void visit(GCPhase* phase) = 0;
41 virtual void visit(PausePhase* phase) { visit((GCPhase*)phase); }
42 virtual void visit(ConcurrentPhase* phase) { visit((GCPhase*)phase); }
43 };
44
45 class GCPhase {
46 const char* _name;
47 int _level;
48 jlong _start;
49 jlong _end;
50
51 public:
52 void set_name(const char* name) { _name = name; }
53 const char* name() { return _name; }
54
55 int level() { return _level; }
56 void set_level(int level) { _level = level; }
57
58 jlong start() { return _start; }
59 void set_start(jlong time) { _start = time; }
60
61 jlong end() { return _end; }
62 void set_end(jlong time) { _end = time; }
63
64 virtual void accept(PhaseVisitor* visitor) = 0;
65 };
66
67 class PausePhase : public GCPhase {
68 public:
69 void accept(PhaseVisitor* visitor) {
70 visitor->visit(this);
71 }
72 };
73
74 class ConcurrentPhase : public GCPhase {
75 void accept(PhaseVisitor* visitor) {
76 visitor->visit(this);
77 }
78 };
79
80 class PhasesStack {
81 public:
82 // FIXME: Temporary set to 5 (used to be 4), since Reference processing needs it.
83 static const int PHASE_LEVELS = 5;
84
85 private:
86 int _phase_indices[PHASE_LEVELS];
87 int _next_phase_level;
88
89 public:
90 PhasesStack() { clear(); }
91 void clear();
92
93 void push(int phase_index);
94 int pop();
95 int count() const;
96 };
97
98 class TimePartitions {
99 static const int INITIAL_CAPACITY = 10;
100
101 // Currently we only support pause phases.
102 GrowableArray<PausePhase>* _phases;
103 PhasesStack _active_phases;
104
105 jlong _sum_of_pauses;
106 jlong _longest_pause;
107
108 public:
109 TimePartitions();
110 ~TimePartitions();
111 void clear();
112
113 void report_gc_phase_start(const char* name, jlong time);
114 void report_gc_phase_end(jlong time);
115
116 int num_phases() const;
117 GCPhase* phase_at(int index) const;
118
119 jlong sum_of_pauses();
120 jlong longest_pause();
121
122 bool has_active_phases();
123 private:
124 void update_statistics(GCPhase* phase);
125 };
126
127 class PhasesIterator {
128 public:
129 virtual bool has_next() = 0;
130 virtual GCPhase* next() = 0;
131 };
132
133 class GCTimer : public ResourceObj {
134 NOT_PRODUCT(friend class GCTimerTest;)
135 protected:
136 jlong _gc_start;
137 jlong _gc_end;
138 TimePartitions _time_partitions;
139
140 public:
141 virtual void register_gc_start(jlong time);
142 virtual void register_gc_end(jlong time);
143
144 void register_gc_phase_start(const char* name, jlong time);
145 void register_gc_phase_end(jlong time);
146
147 jlong gc_start() { return _gc_start; }
148 jlong gc_end() { return _gc_end; }
149
150 TimePartitions* time_partitions() { return &_time_partitions; }
151
152 long longest_pause();
153 long sum_of_pauses();
154
155 protected:
156 void register_gc_pause_start(const char* name, jlong time);
157 void register_gc_pause_end(jlong time);
158 };
159
160 class STWGCTimer : public GCTimer {
161 public:
162 virtual void register_gc_start(jlong time);
163 virtual void register_gc_end(jlong time);
164 };
165
166 class ConcurrentGCTimer : public GCTimer {
167 public:
168 void register_gc_pause_start(const char* name, jlong time);
169 void register_gc_pause_end(jlong time);
170 };
171
172 class TimePartitionPhasesIterator {
173 TimePartitions* _time_partitions;
174 int _next;
175
176 public:
177 TimePartitionPhasesIterator(TimePartitions* time_partitions) : _time_partitions(time_partitions), _next(0) { }
178
179 virtual bool has_next();
180 virtual GCPhase* next();
181 };
182
183
184 /////////////// Unit tests ///////////////
185
186 #ifndef PRODUCT
187
188 class GCTimerAllTest {
189 public:
190 static void all();
191 };
192
193 #endif
194
195 #endif // SHARE_VM_GC_IMPLEMENTATION_SHARED_GCTIMER_HPP