Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit b823b26

Browse files
brixenbrixen
committedJun 23, 2015
Merge remote-tracking branch 'origin' into 1.8.7
Conflicts: kernel/common/gc.rb kernel/common/range_mirror.rb vm/builtin/data.cpp vm/shared_state.cpp
·
v1.4.11v1.4.10
2 parents 854648a + d1c4443 commit b823b26

16 files changed

+135
-219
lines changed
 

‎vm/builtin/data.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,7 @@ namespace rubinius {
4242
state->memory()->needs_finalization(data, (FinalizerFunction)&Data::finalize);
4343
}
4444

45-
state->vm()->metrics().m.ruby_metrics.memory_data_objects_total++;
45+
state->vm()->metrics().m.ruby_metrics.memory_data_objects++;
4646

4747
return data;
4848
}

‎vm/builtin/thread.cpp

+1-2
Original file line numberDiff line numberDiff line change
@@ -93,8 +93,7 @@ namespace rubinius {
9393
state->memory()->needs_finalization(thr, (FinalizerFunction)&Thread::finalize,
9494
FinalizeObject::eUnmanaged);
9595

96-
state->vm()->metrics().system_metrics.vm_threads++;
97-
state->vm()->metrics().system_metrics.vm_threads_total++;
96+
state->vm()->metrics().system_metrics.vm_threads_created++;
9897

9998
return thr;
10099
}

‎vm/gc/immix.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,7 @@ namespace rubinius {
1919
#endif
2020

2121
if(object_memory_) {
22-
object_memory_->state()->metrics().m.ruby_metrics.memory_immix_chunks_total++;
22+
object_memory_->state()->metrics().m.ruby_metrics.memory_immix_chunks++;
2323

2424
if(gc_->dec_chunks_left() <= 0) {
2525
gc_->reset_chunks_left();

‎vm/gc/immix_marker.cpp

+2-6
Original file line numberDiff line numberDiff line change
@@ -81,9 +81,7 @@ namespace rubinius {
8181
if(data_) {
8282
{
8383
timer::StopWatch<timer::milliseconds> timer(
84-
state->vm()->metrics().m.ruby_metrics.gc_immix_conc_last_ms,
85-
state->vm()->metrics().m.ruby_metrics.gc_immix_conc_total_ms
86-
);
84+
state->vm()->metrics().m.ruby_metrics.gc_immix_concurrent_ms);
8785

8886
// Allow for a young stop the world GC to occur
8987
// every bunch of marks. 100 is a fairly arbitrary
@@ -100,9 +98,7 @@ namespace rubinius {
10098

10199
{
102100
timer::StopWatch<timer::milliseconds> timer(
103-
state->vm()->metrics().m.ruby_metrics.gc_immix_stop_last_ms,
104-
state->vm()->metrics().m.ruby_metrics.gc_immix_stop_total_ms
105-
);
101+
state->vm()->metrics().m.ruby_metrics.gc_immix_stop_ms);
106102

107103
// Finish and pause
108104
while(!state->stop_the_world()) {

‎vm/gc/mark_sweep.cpp

+1-5
Original file line numberDiff line numberDiff line change
@@ -56,9 +56,6 @@ namespace rubinius {
5656
object_memory_->state()->metrics().m.ruby_metrics.memory_large_objects++;
5757
object_memory_->state()->metrics().m.ruby_metrics.memory_large_bytes += bytes;
5858

59-
object_memory_->state()->metrics().m.ruby_metrics.memory_large_objects_total++;
60-
object_memory_->state()->metrics().m.ruby_metrics.memory_large_bytes_total += bytes;
61-
6259
next_collection_bytes -= bytes;
6360
if(next_collection_bytes < 0) {
6461
*collect_now = true;
@@ -126,8 +123,7 @@ namespace rubinius {
126123
metrics::MetricsData& metrics = object_memory_->state()->metrics();
127124

128125
timer::StopWatch<timer::milliseconds> timer(
129-
metrics.m.ruby_metrics.gc_large_sweep_last_ms,
130-
metrics.m.ruby_metrics.gc_large_sweep_total_ms);
126+
metrics.m.ruby_metrics.gc_large_sweep_ms);
131127

132128
last_freed = 0;
133129

‎vm/instruments/timing.hpp

+3-6
Original file line numberDiff line numberDiff line change
@@ -64,22 +64,19 @@ namespace timer {
6464

6565
template <int factor=milliseconds>
6666
class StopWatch {
67-
uint64_t& lap_;
6867
uint64_t& total_;
6968
uint64_t start_;
7069

7170
public:
72-
StopWatch(uint64_t& lap, uint64_t& total)
73-
: lap_(lap)
74-
, total_(total)
71+
StopWatch(uint64_t& total)
72+
: total_(total)
7573
{
7674
start_ = get_current_time();
7775
}
7876

7977
~StopWatch() {
8078
uint64_t now = get_current_time();
81-
lap_ = (now - start_) / ((uint64_t)factor);
82-
total_ += lap_;
79+
total_ += (now - start_) / ((uint64_t)factor);
8380
}
8481
};
8582

‎vm/internal_threads.cpp

+8-8
Original file line numberDiff line numberDiff line change
@@ -130,7 +130,7 @@ namespace rubinius {
130130
if(exec_in_progress_) return;
131131
exec_in_progress_ = true;
132132

133-
for(std::list<InternalThread*>::reverse_iterator i = threads_.rbegin();
133+
for(InternalThreadList::reverse_iterator i = threads_.rbegin();
134134
i != threads_.rend();
135135
++i) {
136136
(*i)->before_exec(state);
@@ -142,7 +142,7 @@ namespace rubinius {
142142
// after execvp() call.
143143
state->shared().env()->after_exec(state);
144144

145-
for(std::list<InternalThread*>::iterator i = threads_.begin();
145+
for(InternalThreadList::iterator i = threads_.begin();
146146
i != threads_.end();
147147
++i) {
148148
(*i)->after_exec(state);
@@ -157,7 +157,7 @@ namespace rubinius {
157157
if(fork_exec_in_progress_) return;
158158
fork_exec_in_progress_ = true;
159159

160-
for(std::list<InternalThread*>::reverse_iterator i = threads_.rbegin();
160+
for(InternalThreadList::reverse_iterator i = threads_.rbegin();
161161
i != threads_.rend();
162162
++i) {
163163
(*i)->before_fork_exec(state);
@@ -167,7 +167,7 @@ namespace rubinius {
167167
void InternalThreads::after_fork_exec_parent(STATE) {
168168
// We don't guard here on the assumption that only one thread is running
169169
// after fork() call.
170-
for(std::list<InternalThread*>::iterator i = threads_.begin();
170+
for(InternalThreadList::iterator i = threads_.begin();
171171
i != threads_.end();
172172
++i) {
173173
(*i)->after_fork_exec_parent(state);
@@ -179,7 +179,7 @@ namespace rubinius {
179179
void InternalThreads::after_fork_exec_child(STATE) {
180180
// We don't guard here on the assumption that only one thread is running
181181
// after execvp() call.
182-
for(std::list<InternalThread*>::iterator i = threads_.begin();
182+
for(InternalThreadList::iterator i = threads_.begin();
183183
i != threads_.end();
184184
++i) {
185185
(*i)->after_fork_exec_child(state);
@@ -195,7 +195,7 @@ namespace rubinius {
195195
if(fork_in_progress_) return;
196196
fork_in_progress_ = true;
197197

198-
for(std::list<InternalThread*>::reverse_iterator i = threads_.rbegin();
198+
for(InternalThreadList::reverse_iterator i = threads_.rbegin();
199199
i != threads_.rend();
200200
++i) {
201201
(*i)->before_fork(state);
@@ -205,7 +205,7 @@ namespace rubinius {
205205
void InternalThreads::after_fork_parent(STATE) {
206206
// We don't guard here on the assumption that only one thread is running
207207
// after fork() call.
208-
for(std::list<InternalThread*>::iterator i = threads_.begin();
208+
for(InternalThreadList::iterator i = threads_.begin();
209209
i != threads_.end();
210210
++i) {
211211
(*i)->after_fork_parent(state);
@@ -219,7 +219,7 @@ namespace rubinius {
219219
// after fork() call.
220220
state->shared().env()->after_fork_child(state);
221221

222-
for(std::list<InternalThread*>::iterator i = threads_.begin();
222+
for(InternalThreadList::iterator i = threads_.begin();
223223
i != threads_.end();
224224
++i) {
225225
(*i)->after_fork_child(state);

‎vm/internal_threads.hpp

+4-1
Original file line numberDiff line numberDiff line change
@@ -7,12 +7,15 @@
77
#include <list>
88

99
namespace rubinius {
10+
class InternalThread;
1011
class VM;
1112

1213
namespace metrics {
1314
struct MetricsData;
1415
}
1516

17+
typedef std::list<InternalThread*> InternalThreadList;
18+
1619
class InternalThread {
1720
VM* vm_;
1821
bool thread_running_;
@@ -73,7 +76,7 @@ namespace rubinius {
7376
bool fork_exec_in_progress_;
7477
bool shutdown_in_progress_;
7578
utilities::thread::Mutex mutex_;
76-
std::list<InternalThread*> threads_;
79+
InternalThreadList threads_;
7780

7881
public:
7982
InternalThreads()

‎vm/llvm/state.cpp

+1-2
Original file line numberDiff line numberDiff line change
@@ -292,8 +292,7 @@ namespace rubinius {
292292

293293
{
294294
timer::StopWatch<timer::microseconds> timer(
295-
metrics().m.jit_metrics.time_last_us,
296-
metrics().m.jit_metrics.time_total_us);
295+
metrics().m.jit_metrics.time_us);
297296

298297
jit.compile(compile_request);
299298

‎vm/metrics.cpp

+34-71
Original file line numberDiff line numberDiff line change
@@ -227,56 +227,36 @@ namespace rubinius {
227227
metrics_map_.push_back(new MetricsItem(
228228
"jit.methods.failed", metrics_collection_.jit_metrics.methods_failed));
229229
metrics_map_.push_back(new MetricsItem(
230-
"jit.time.last.us", metrics_collection_.jit_metrics.time_last_us));
231-
metrics_map_.push_back(new MetricsItem(
232-
"jit.time.total.us", metrics_collection_.jit_metrics.time_total_us));
230+
"jit.time.us", metrics_collection_.jit_metrics.time_us));
233231

234232
// Object memory metrics
235233
metrics_map_.push_back(new MetricsItem(
236-
"memory.young.bytes.current",
234+
"memory.young.bytes",
237235
metrics_collection_.ruby_metrics.memory_young_bytes));
238236
metrics_map_.push_back(new MetricsItem(
239-
"memory.young.bytes.total",
240-
metrics_collection_.ruby_metrics.memory_young_bytes_total));
241-
metrics_map_.push_back(new MetricsItem(
242-
"memory.young.objects.current",
237+
"memory.young.objects",
243238
metrics_collection_.ruby_metrics.memory_young_objects));
244239
metrics_map_.push_back(new MetricsItem(
245-
"memory.young.objects.total",
246-
metrics_collection_.ruby_metrics.memory_young_objects_total));
240+
"memory.young.occupancy",
241+
metrics_collection_.ruby_metrics.memory_young_occupancy));
247242
metrics_map_.push_back(new MetricsItem(
248-
"memory.young.percent_used",
249-
metrics_collection_.ruby_metrics.memory_young_percent_used));
250-
metrics_map_.push_back(new MetricsItem(
251-
"memory.immix.bytes.current",
243+
"memory.immix.bytes",
252244
metrics_collection_.ruby_metrics.memory_immix_bytes));
253245
metrics_map_.push_back(new MetricsItem(
254-
"memory.immix.bytes.total",
255-
metrics_collection_.ruby_metrics.memory_immix_bytes_total));
256-
metrics_map_.push_back(new MetricsItem(
257-
"memory.immix.objects.current",
246+
"memory.immix.objects",
258247
metrics_collection_.ruby_metrics.memory_immix_objects));
259248
metrics_map_.push_back(new MetricsItem(
260-
"memory.immix.objects.total",
261-
metrics_collection_.ruby_metrics.memory_immix_objects_total));
262-
metrics_map_.push_back(new MetricsItem(
263-
"memory.immix.chunks.current",
249+
"memory.immix.chunks",
264250
metrics_collection_.ruby_metrics.memory_immix_chunks));
265251
metrics_map_.push_back(new MetricsItem(
266-
"memory.immix.chunks.total",
267-
metrics_collection_.ruby_metrics.memory_immix_chunks_total));
268-
metrics_map_.push_back(new MetricsItem(
269-
"memory.large.bytes.current",
252+
"memory.large.bytes",
270253
metrics_collection_.ruby_metrics.memory_large_bytes));
271254
metrics_map_.push_back(new MetricsItem(
272-
"memory.large.bytes.total",
273-
metrics_collection_.ruby_metrics.memory_large_bytes_total));
274-
metrics_map_.push_back(new MetricsItem(
275-
"memory.large.objects.current",
255+
"memory.large.objects",
276256
metrics_collection_.ruby_metrics.memory_large_objects));
277257
metrics_map_.push_back(new MetricsItem(
278-
"memory.large.objects.total",
279-
metrics_collection_.ruby_metrics.memory_large_objects_total));
258+
"memory.symbols",
259+
metrics_collection_.ruby_metrics.memory_symbols));
280260
metrics_map_.push_back(new MetricsItem(
281261
"memory.symbols.bytes",
282262
metrics_collection_.ruby_metrics.memory_symbols_bytes));
@@ -285,25 +265,22 @@ namespace rubinius {
285265
metrics_map_.push_back(new MetricsItem(
286266
"memory.jit.bytes", metrics_collection_.ruby_metrics.memory_jit_bytes));
287267
metrics_map_.push_back(new MetricsItem(
288-
"memory.promoted.bytes.total",
289-
metrics_collection_.ruby_metrics.memory_promoted_bytes_total));
268+
"memory.promoted.bytes",
269+
metrics_collection_.ruby_metrics.memory_promoted_bytes));
290270
metrics_map_.push_back(new MetricsItem(
291-
"memory.promoted.objects.total",
292-
metrics_collection_.ruby_metrics.memory_promoted_objects_total));
271+
"memory.promoted.objects",
272+
metrics_collection_.ruby_metrics.memory_promoted_objects));
293273
metrics_map_.push_back(new MetricsItem(
294-
"memory.slab.refills.total",
295-
metrics_collection_.ruby_metrics.memory_slab_refills_total));
274+
"memory.slab.refills",
275+
metrics_collection_.ruby_metrics.memory_slab_refills));
296276
metrics_map_.push_back(new MetricsItem(
297277
"memory.slab.refills.fails",
298278
metrics_collection_.ruby_metrics.memory_slab_refills_fails));
299279
metrics_map_.push_back(new MetricsItem(
300-
"memory.data_objects.total",
301-
metrics_collection_.ruby_metrics.memory_data_objects_total));
280+
"memory.data_objects",
281+
metrics_collection_.ruby_metrics.memory_data_objects));
302282
metrics_map_.push_back(new MetricsItem(
303-
"memory.capi_handles.total",
304-
metrics_collection_.ruby_metrics.memory_capi_handles_total));
305-
metrics_map_.push_back(new MetricsItem(
306-
"memory.capi_handles.current",
283+
"memory.capi_handles",
307284
metrics_collection_.ruby_metrics.memory_capi_handles));
308285
metrics_map_.push_back(new MetricsItem(
309286
"memory.inflated_headers",
@@ -313,33 +290,22 @@ namespace rubinius {
313290
metrics_map_.push_back(new MetricsItem(
314291
"gc.young.count", metrics_collection_.ruby_metrics.gc_young_count));
315292
metrics_map_.push_back(new MetricsItem(
316-
"gc.young.last.ms", metrics_collection_.ruby_metrics.gc_young_last_ms));
317-
metrics_map_.push_back(new MetricsItem(
318-
"gc.young.total.ms", metrics_collection_.ruby_metrics.gc_young_total_ms));
293+
"gc.young.ms", metrics_collection_.ruby_metrics.gc_young_ms));
319294
metrics_map_.push_back(new MetricsItem(
320295
"gc.young.lifetime", metrics_collection_.ruby_metrics.gc_young_lifetime));
321296
metrics_map_.push_back(new MetricsItem(
322297
"gc.immix.count", metrics_collection_.ruby_metrics.gc_immix_count));
323298
metrics_map_.push_back(new MetricsItem(
324-
"gc.immix.stop.last.ms",
325-
metrics_collection_.ruby_metrics.gc_immix_stop_last_ms));
326-
metrics_map_.push_back(new MetricsItem(
327-
"gc.immix.stop.total.ms",
328-
metrics_collection_.ruby_metrics.gc_immix_stop_total_ms));
299+
"gc.immix.stop.ms",
300+
metrics_collection_.ruby_metrics.gc_immix_stop_ms));
329301
metrics_map_.push_back(new MetricsItem(
330-
"gc.immix.concurrent.last.ms",
331-
metrics_collection_.ruby_metrics.gc_immix_conc_last_ms));
332-
metrics_map_.push_back(new MetricsItem(
333-
"gc.immix.concurrent.total.ms",
334-
metrics_collection_.ruby_metrics.gc_immix_conc_total_ms));
302+
"gc.immix.concurrent.ms",
303+
metrics_collection_.ruby_metrics.gc_immix_concurrent_ms));
335304
metrics_map_.push_back(new MetricsItem(
336305
"gc.large.count", metrics_collection_.ruby_metrics.gc_large_count));
337306
metrics_map_.push_back(new MetricsItem(
338-
"gc.large.sweep.last.ms",
339-
metrics_collection_.ruby_metrics.gc_large_sweep_last_ms));
340-
metrics_map_.push_back(new MetricsItem(
341-
"gc.large.sweep.total.ms",
342-
metrics_collection_.ruby_metrics.gc_large_sweep_total_ms));
307+
"gc.large.sweep.ms",
308+
metrics_collection_.ruby_metrics.gc_large_sweep_ms));
343309

344310
// I/O metrics
345311
metrics_map_.push_back(new MetricsItem(
@@ -360,19 +326,16 @@ namespace rubinius {
360326
"vm.inline_cache.resets",
361327
metrics_collection_.system_metrics.vm_inline_cache_resets));
362328
metrics_map_.push_back(new MetricsItem(
363-
"vm.threads.current",
364-
metrics_collection_.system_metrics.vm_threads));
329+
"vm.threads.created",
330+
metrics_collection_.system_metrics.vm_threads_created));
365331
metrics_map_.push_back(new MetricsItem(
366-
"vm.threads.total",
367-
metrics_collection_.system_metrics.vm_threads_total));
332+
"vm.threads.destroyed",
333+
metrics_collection_.system_metrics.vm_threads_destroyed));
368334

369335
// Lock metrics
370336
metrics_map_.push_back(new MetricsItem(
371-
"locks.stop_the_world.last.ns",
372-
metrics_collection_.system_metrics.locks_stop_the_world_last_ns));
373-
metrics_map_.push_back(new MetricsItem(
374-
"locks.stop_the_world.total.ns",
375-
metrics_collection_.system_metrics.locks_stop_the_world_total_ns));
337+
"locks.stop_the_world.ns",
338+
metrics_collection_.system_metrics.locks_stop_the_world_ns));
376339
}
377340

378341
void Metrics::init_ruby_metrics(STATE) {

‎vm/metrics.hpp

+43-81
Original file line numberDiff line numberDiff line change
@@ -34,126 +34,94 @@ namespace rubinius {
3434
struct RubyMetrics {
3535
// Object memory metrics
3636
metric memory_young_bytes;
37-
metric memory_young_bytes_total;
3837
metric memory_young_objects;
39-
metric memory_young_objects_total;
40-
metric memory_young_percent_used;
38+
metric memory_young_occupancy;
4139
metric memory_immix_bytes;
42-
metric memory_immix_bytes_total;
4340
metric memory_immix_objects;
44-
metric memory_immix_objects_total;
4541
metric memory_immix_chunks;
46-
metric memory_immix_chunks_total;
4742
metric memory_large_bytes;
48-
metric memory_large_bytes_total;
4943
metric memory_large_objects;
50-
metric memory_large_objects_total;
44+
metric memory_symbols;
5145
metric memory_symbols_bytes;
5246
metric memory_code_bytes;
5347
metric memory_jit_bytes;
54-
metric memory_promoted_bytes_total;
55-
metric memory_promoted_objects_total;
56-
metric memory_slab_refills_total;
48+
metric memory_promoted_bytes;
49+
metric memory_promoted_objects;
50+
metric memory_slab_refills;
5751
metric memory_slab_refills_fails;
58-
metric memory_data_objects_total;
52+
metric memory_data_objects;
5953
metric memory_capi_handles;
60-
metric memory_capi_handles_total;
6154
metric memory_inflated_headers;
6255

6356
// Garbage collector metrics
6457
metric gc_young_count;
65-
metric gc_young_last_ms;
66-
metric gc_young_total_ms;
58+
metric gc_young_ms;
6759
metric gc_young_lifetime;
6860
metric gc_immix_count;
69-
metric gc_immix_stop_last_ms;
70-
metric gc_immix_stop_total_ms;
71-
metric gc_immix_conc_last_ms;
72-
metric gc_immix_conc_total_ms;
61+
metric gc_immix_stop_ms;
62+
metric gc_immix_concurrent_ms;
7363
metric gc_large_count;
74-
metric gc_large_sweep_last_ms;
75-
metric gc_large_sweep_total_ms;
64+
metric gc_large_sweep_ms;
7665

7766
void init() {
7867
memory_young_bytes = 0;
79-
memory_young_bytes_total = 0;
8068
memory_young_objects = 0;
81-
memory_young_objects_total = 0;
82-
memory_young_percent_used = 0;
69+
memory_young_occupancy = 0;
8370
memory_immix_bytes = 0;
84-
memory_immix_bytes_total = 0;
8571
memory_immix_objects = 0;
86-
memory_immix_objects_total = 0;
8772
memory_immix_chunks = 0;
88-
memory_immix_chunks_total = 0;
8973
memory_large_bytes = 0;
90-
memory_large_bytes_total = 0;
9174
memory_large_objects = 0;
92-
memory_large_objects_total = 0;
75+
memory_symbols = 0;
9376
memory_symbols_bytes = 0;
9477
memory_code_bytes = 0;
9578
memory_jit_bytes = 0;
96-
memory_promoted_bytes_total = 0;
97-
memory_promoted_objects_total = 0;
98-
memory_slab_refills_total = 0;
79+
memory_promoted_bytes = 0;
80+
memory_promoted_objects = 0;
81+
memory_slab_refills = 0;
9982
memory_slab_refills_fails = 0;
100-
memory_data_objects_total = 0;
83+
memory_data_objects = 0;
10184
memory_capi_handles = 0;
102-
memory_capi_handles_total = 0;
10385
memory_inflated_headers = 0;
10486
gc_young_count = 0;
105-
gc_young_last_ms = 0;
106-
gc_young_total_ms = 0;
87+
gc_young_ms = 0;
10788
gc_young_lifetime = 0;
10889
gc_immix_count = 0;
109-
gc_immix_stop_last_ms = 0;
110-
gc_immix_stop_total_ms = 0;
111-
gc_immix_conc_last_ms = 0;
112-
gc_immix_conc_total_ms = 0;
90+
gc_immix_stop_ms = 0;
91+
gc_immix_concurrent_ms = 0;
11392
gc_large_count = 0;
114-
gc_large_sweep_last_ms = 0;
115-
gc_large_sweep_total_ms = 0;
93+
gc_large_sweep_ms = 0;
11694
}
11795

11896
void add(RubyMetrics& data) {
11997
memory_young_bytes += data.memory_young_bytes;
120-
memory_young_bytes_total += data.memory_young_bytes_total;
12198
memory_young_objects += data.memory_young_objects;
122-
memory_young_objects_total += data.memory_young_objects_total;
123-
memory_young_percent_used += data.memory_young_percent_used;
99+
memory_young_occupancy += data.memory_young_occupancy;
124100
memory_immix_bytes += data.memory_immix_bytes;
125-
memory_immix_bytes_total += data.memory_immix_bytes_total;
126101
memory_immix_objects += data.memory_immix_objects;
127-
memory_immix_objects_total += data.memory_immix_objects_total;
128102
memory_immix_chunks += data.memory_immix_chunks;
129-
memory_immix_chunks_total += data.memory_immix_chunks_total;
130103
memory_large_bytes += data.memory_large_bytes;
131-
memory_large_bytes_total += data.memory_large_bytes_total;
132104
memory_large_objects += data.memory_large_objects;
133-
memory_large_objects_total += data.memory_large_objects_total;
105+
memory_symbols += data.memory_symbols;
134106
memory_symbols_bytes += data.memory_symbols_bytes;
135107
memory_code_bytes += data.memory_code_bytes;
136108
memory_jit_bytes += data.memory_jit_bytes;
137-
memory_promoted_bytes_total += data.memory_promoted_bytes_total;
138-
memory_promoted_objects_total += data.memory_promoted_objects_total;
139-
memory_slab_refills_total += data.memory_slab_refills_total;
109+
memory_promoted_bytes += data.memory_promoted_bytes;
110+
memory_promoted_objects += data.memory_promoted_objects;
111+
memory_slab_refills += data.memory_slab_refills;
140112
memory_slab_refills_fails += data.memory_slab_refills_fails;
141-
memory_data_objects_total += data.memory_data_objects_total;
113+
memory_data_objects += data.memory_data_objects;
114+
memory_capi_handles += data.memory_capi_handles;
142115
memory_capi_handles += data.memory_capi_handles;
143-
memory_capi_handles_total += data.memory_capi_handles_total;
144116
memory_inflated_headers += data.memory_inflated_headers;
145117
gc_young_count += data.gc_young_count;
146-
gc_young_last_ms += data.gc_young_last_ms;
147-
gc_young_total_ms += data.gc_young_total_ms;
118+
gc_young_ms += data.gc_young_ms;
148119
gc_young_lifetime += data.gc_young_lifetime;
149120
gc_immix_count += data.gc_immix_count;
150-
gc_immix_stop_last_ms += data.gc_immix_stop_last_ms;
151-
gc_immix_stop_total_ms += data.gc_immix_stop_total_ms;
152-
gc_immix_conc_last_ms += data.gc_immix_conc_last_ms;
153-
gc_immix_conc_total_ms += data.gc_immix_conc_total_ms;
121+
gc_immix_stop_ms += data.gc_immix_stop_ms;
122+
gc_immix_concurrent_ms += data.gc_immix_concurrent_ms;
154123
gc_large_count += data.gc_large_count;
155-
gc_large_sweep_last_ms += data.gc_large_sweep_last_ms;
156-
gc_large_sweep_total_ms += data.gc_large_sweep_total_ms;
124+
gc_large_sweep_ms += data.gc_large_sweep_ms;
157125
}
158126

159127
void add(MetricsData& data);
@@ -180,23 +148,20 @@ namespace rubinius {
180148
metric methods_queued;
181149
metric methods_compiled;
182150
metric methods_failed;
183-
metric time_last_us;
184-
metric time_total_us;
151+
metric time_us;
185152

186153
void init() {
187154
methods_queued = 0;
188155
methods_compiled = 0;
189156
methods_failed = 0;
190-
time_last_us = 0;
191-
time_total_us = 0;
157+
time_us = 0;
192158
}
193159

194160
void add(JITMetrics& data) {
195161
methods_queued += data.methods_queued;
196162
methods_compiled += data.methods_compiled;
197163
methods_failed += data.methods_failed;
198-
time_last_us += data.time_last_us;
199-
time_total_us += data.time_total_us;
164+
time_us += data.time_us;
200165
}
201166

202167
void add(MetricsData& data);
@@ -230,23 +195,21 @@ namespace rubinius {
230195

231196
// VM metrics
232197
metric vm_inline_cache_resets;
233-
metric vm_threads;
234-
metric vm_threads_total;
198+
metric vm_threads_created;
199+
metric vm_threads_destroyed;
235200

236201
// Lock metrics
237-
metric locks_stop_the_world_last_ns;
238-
metric locks_stop_the_world_total_ns;
202+
metric locks_stop_the_world_ns;
239203

240204
void init() {
241205
io_read_bytes = 0;
242206
io_write_bytes = 0;
243207
os_signals_received = 0;
244208
os_signals_processed = 0;
245209
vm_inline_cache_resets = 0;
246-
vm_threads = 0;
247-
vm_threads_total = 0;
248-
locks_stop_the_world_last_ns = 0;
249-
locks_stop_the_world_total_ns = 0;
210+
vm_threads_created = 0;
211+
vm_threads_destroyed = 0;
212+
locks_stop_the_world_ns = 0;
250213
}
251214

252215
void add(SystemMetrics& data) {
@@ -255,10 +218,9 @@ namespace rubinius {
255218
os_signals_received += data.os_signals_received;
256219
os_signals_processed += data.os_signals_processed;
257220
vm_inline_cache_resets += data.vm_inline_cache_resets;
258-
vm_threads += data.vm_threads;
259-
vm_threads_total += data.vm_threads_total;
260-
locks_stop_the_world_last_ns += data.locks_stop_the_world_last_ns;
261-
locks_stop_the_world_total_ns += data.locks_stop_the_world_total_ns;
221+
vm_threads_created += data.vm_threads_created;
222+
vm_threads_destroyed += data.vm_threads_destroyed;
223+
locks_stop_the_world_ns += data.locks_stop_the_world_ns;
262224
}
263225

264226
void add(MetricsData& data);

‎vm/object_memory.cpp

+29-31
Original file line numberDiff line numberDiff line change
@@ -437,12 +437,12 @@ namespace rubinius {
437437
Address addr = young_->allocate_for_slab(slab_size_);
438438

439439
metrics::MetricsData& metrics = state->vm()->metrics();
440-
metrics.m.ruby_metrics.memory_young_objects_total += slab.allocations();
441-
metrics.m.ruby_metrics.memory_young_bytes_total += slab.bytes_used();
440+
metrics.m.ruby_metrics.memory_young_objects += slab.allocations();
441+
metrics.m.ruby_metrics.memory_young_bytes += slab.bytes_used();
442442

443443
if(addr) {
444444
slab.refill(addr, slab_size_);
445-
metrics.m.ruby_metrics.memory_slab_refills_total++;
445+
metrics.m.ruby_metrics.memory_slab_refills++;
446446
return true;
447447
} else {
448448
slab.refill(0, 0);
@@ -483,8 +483,8 @@ namespace rubinius {
483483

484484
Object* copy = immix_->move_object(obj, sz);
485485

486-
state()->metrics().m.ruby_metrics.memory_promoted_objects_total++;
487-
state()->metrics().m.ruby_metrics.memory_promoted_bytes_total += sz;
486+
state()->metrics().m.ruby_metrics.memory_promoted_objects++;
487+
state()->metrics().m.ruby_metrics.memory_promoted_bytes += sz;
488488

489489
if(unlikely(!copy)) {
490490
copy = mark_sweep_->move_object(obj, sz, &collect_mature_now);
@@ -544,10 +544,10 @@ namespace rubinius {
544544
RUBINIUS_GC_END(0);
545545

546546
metrics::MetricsData& metrics = state->vm()->metrics();
547-
metrics.m.ruby_metrics.memory_young_bytes =
547+
metrics.m.ruby_metrics.memory_young_bytes +=
548548
state->memory()->young_bytes_allocated();
549-
metrics.m.ruby_metrics.memory_young_percent_used = stats.percentage_used;
550-
metrics.m.ruby_metrics.gc_young_lifetime = stats.lifetime;
549+
metrics.m.ruby_metrics.memory_young_occupancy += stats.percentage_used;
550+
metrics.m.ruby_metrics.gc_young_lifetime += stats.lifetime;
551551
}
552552

553553
if(collect_mature_now) {
@@ -578,9 +578,7 @@ namespace rubinius {
578578
#endif
579579

580580
timer::StopWatch<timer::milliseconds> timerx(
581-
state->vm()->metrics().m.ruby_metrics.gc_young_last_ms,
582-
state->vm()->metrics().m.ruby_metrics.gc_young_total_ms
583-
);
581+
state->vm()->metrics().m.ruby_metrics.gc_young_ms);
584582

585583
young_gc_while_marking_++;
586584
young_->reset_stats();
@@ -621,8 +619,7 @@ namespace rubinius {
621619

622620
void ObjectMemory::collect_mature(STATE, GCData* data) {
623621
timer::StopWatch<timer::milliseconds> timerx(
624-
state->vm()->metrics().m.ruby_metrics.gc_immix_conc_last_ms,
625-
state->vm()->metrics().m.ruby_metrics.gc_immix_conc_total_ms);
622+
state->vm()->metrics().m.ruby_metrics.gc_immix_concurrent_ms);
626623

627624
#ifndef RBX_GC_STRESS_MATURE
628625
collect_mature_now = false;
@@ -671,11 +668,12 @@ namespace rubinius {
671668
metrics::MetricsData& metrics = state->vm()->metrics();
672669
metrics.m.ruby_metrics.gc_immix_count++;
673670
metrics.m.ruby_metrics.gc_large_count++;
674-
metrics.m.ruby_metrics.memory_immix_bytes = immix_->bytes_allocated();
675-
metrics.m.ruby_metrics.memory_large_bytes = mark_sweep_->allocated_bytes;
676-
metrics.m.ruby_metrics.memory_symbols_bytes = shared_.symbols.bytes_used();
677-
metrics.m.ruby_metrics.memory_code_bytes = code_manager_.size();
678-
metrics.m.ruby_metrics.memory_jit_bytes = data->jit_bytes_allocated();
671+
metrics.m.ruby_metrics.memory_immix_bytes += immix_->bytes_allocated();
672+
metrics.m.ruby_metrics.memory_large_bytes += mark_sweep_->allocated_bytes;
673+
metrics.m.ruby_metrics.memory_symbols += shared_.symbols.size();
674+
metrics.m.ruby_metrics.memory_symbols_bytes += shared_.symbols.bytes_used();
675+
metrics.m.ruby_metrics.memory_code_bytes += code_manager_.size();
676+
metrics.m.ruby_metrics.memory_jit_bytes += data->jit_bytes_allocated();
679677

680678
if(FinalizerThread* hdl = state->shared().finalizer_handler()) {
681679
hdl->finish_collection(state);
@@ -833,8 +831,8 @@ namespace rubinius {
833831
obj = mark_sweep_->allocate(bytes, &collect_mature_now);
834832
if(unlikely(!obj)) return NULL;
835833

836-
state()->metrics().m.ruby_metrics.memory_immix_objects_total++;
837-
state()->metrics().m.ruby_metrics.memory_immix_bytes_total += bytes;
834+
state()->metrics().m.ruby_metrics.memory_immix_objects++;
835+
state()->metrics().m.ruby_metrics.memory_immix_bytes += bytes;
838836

839837
if(collect_mature_now) shared_.gc_soon();
840838

@@ -850,13 +848,13 @@ namespace rubinius {
850848
obj = mark_sweep_->allocate(bytes, &collect_mature_now);
851849
}
852850

853-
state()->metrics().m.ruby_metrics.memory_immix_objects_total++;
854-
state()->metrics().m.ruby_metrics.memory_immix_bytes_total += bytes;
851+
state()->metrics().m.ruby_metrics.memory_immix_objects++;
852+
state()->metrics().m.ruby_metrics.memory_immix_bytes += bytes;
855853

856854
if(collect_mature_now) shared_.gc_soon();
857855
} else {
858-
state()->metrics().m.ruby_metrics.memory_young_objects_total++;
859-
state()->metrics().m.ruby_metrics.memory_young_bytes_total += bytes;
856+
state()->metrics().m.ruby_metrics.memory_young_objects++;
857+
state()->metrics().m.ruby_metrics.memory_young_bytes += bytes;
860858
}
861859
}
862860

@@ -883,8 +881,8 @@ namespace rubinius {
883881
obj = mark_sweep_->allocate(bytes, &collect_mature_now);
884882
}
885883

886-
state()->metrics().m.ruby_metrics.memory_immix_objects_total++;
887-
state()->metrics().m.ruby_metrics.memory_immix_bytes_total += bytes;
884+
state()->metrics().m.ruby_metrics.memory_immix_objects++;
885+
state()->metrics().m.ruby_metrics.memory_immix_bytes += bytes;
888886
}
889887

890888
if(collect_mature_now) shared_.gc_soon();
@@ -950,8 +948,8 @@ namespace rubinius {
950948
Object* obj = mark_sweep_->allocate(bytes, &collect_mature_now);
951949
if(unlikely(!obj)) return NULL;
952950

953-
state()->metrics().m.ruby_metrics.memory_immix_objects_total++;
954-
state()->metrics().m.ruby_metrics.memory_immix_bytes_total += bytes;
951+
state()->metrics().m.ruby_metrics.memory_immix_objects++;
952+
state()->metrics().m.ruby_metrics.memory_immix_bytes += bytes;
955953

956954
obj->clear_fields(bytes);
957955
return obj;
@@ -963,8 +961,8 @@ namespace rubinius {
963961
Object* obj = mark_sweep_->allocate(bytes, &collect_mature_now);
964962
if(unlikely(!obj)) return NULL;
965963

966-
state->vm()->metrics().m.ruby_metrics.memory_immix_objects_total++;
967-
state->vm()->metrics().m.ruby_metrics.memory_immix_bytes_total += bytes;
964+
state->vm()->metrics().m.ruby_metrics.memory_immix_objects++;
965+
state->vm()->metrics().m.ruby_metrics.memory_immix_bytes += bytes;
968966

969967
if(collect_mature_now) shared_.gc_soon();
970968

@@ -1027,7 +1025,7 @@ namespace rubinius {
10271025
if(!obj->reference_p()) {
10281026
rubinius::bug("Trying to add a handle for a non reference");
10291027
}
1030-
state->vm()->metrics().m.ruby_metrics.memory_capi_handles_total++;
1028+
state->vm()->metrics().m.ruby_metrics.memory_capi_handles++;
10311029
uintptr_t handle_index = capi_handles_->allocate_index(state, obj);
10321030
obj->set_handle_index(state, handle_index);
10331031
return obj->handle(state);

‎vm/shared_state.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -200,7 +200,7 @@ namespace rubinius {
200200
if(VM* vm = (*i)->as_vm()) {
201201
if(vm == current) {
202202
vm->metrics().init(metrics::eRubyMetrics);
203-
state->vm()->metrics().system_metrics.vm_threads++;
203+
state->vm()->metrics().system_metrics.vm_threads_created++;
204204
continue;
205205
}
206206

‎vm/symbol_table.hpp

+4
Original file line numberDiff line numberDiff line change
@@ -73,6 +73,10 @@ namespace rubinius {
7373
return bytes_used_;
7474
}
7575

76+
size_t size() {
77+
return symbols.size();
78+
};
79+
7680
Symbol* lookup(SharedState* shared, const std::string& str);
7781
Symbol* lookup(STATE, const std::string& str);
7882
Symbol* lookup(STATE, const char* str, size_t length);

‎vm/vm.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -109,7 +109,7 @@ namespace rubinius {
109109
vm->saved_call_frame_ = 0;
110110
vm->shared.remove_vm(vm);
111111

112-
state->vm()->metrics().system_metrics.vm_threads--;
112+
state->vm()->metrics().system_metrics.vm_threads_destroyed++;
113113

114114
delete vm;
115115
}

‎vm/world_state.hpp

+1-2
Original file line numberDiff line numberDiff line change
@@ -140,8 +140,7 @@ namespace rubinius {
140140
atomic::fetch_and_sub(&pending_threads_, 1);
141141

142142
timer::StopWatch<timer::nanoseconds> timer(
143-
state->metrics().system_metrics.locks_stop_the_world_last_ns,
144-
state->metrics().system_metrics.locks_stop_the_world_total_ns);
143+
state->metrics().system_metrics.locks_stop_the_world_ns);
145144

146145
// We need a write barrier so we're sure we're seeing an up to
147146
// date version of pending_threads_ in each loop.

0 commit comments

Comments
 (0)
Please sign in to comment.