Skip to content

Commit d1c4443

Browse files
brixenbrixen
committedJun 23, 2015
Converted Metrics to only counters.
Counters preserve their characteristics under sampling (ie they lose resolution but not accuracy) and counters can be used in pairs to simulate a gauge.
·
v5.0vℇ
1 parent 5e55964 commit d1c4443

15 files changed

+136
-223
lines changed
 

‎kernel/common/gc.rb

+12-12
Original file line numberDiff line numberDiff line change
@@ -6,9 +6,9 @@ def self.count
66

77
def self.time
88
data = stat
9-
data[:"gc.young.total.ms"] +
10-
data[:"gc.immix.stop.total.ms"] +
11-
data[:"gc.large.sweep.total.ms"]
9+
data[:"gc.young.ms"] +
10+
data[:"gc.immix.stop.ms"] +
11+
data[:"gc.large.sweep.ms"]
1212
end
1313

1414
def self.stat
@@ -54,22 +54,22 @@ def self.result
5454
===================================
5555
5656
Collections
57-
Count Total time / concurrent (ms) Last time / concurrent (ms)
58-
Young #{sprintf("% 22d", stats[:'gc.young.count'])} #{sprintf("% 16d ", stats[:'gc.young.total.ms'])} #{sprintf("% 16d ", stats[:'gc.young.last.ms'])}
59-
Full #{sprintf("% 22d", stats[:'gc.immix.count'])} #{sprintf("% 16d / % 10d", stats[:'gc.immix.stop.total.ms'], stats[:'gc.immix.concurrent.total.ms'])} #{sprintf("% 16d / % 10d", stats[:'gc.immix.stop.last.ms'], stats[:'gc.immix.concurrent.last.ms'])}
57+
Count Total time / concurrent (ms)
58+
Young #{sprintf("% 22d", stats[:'gc.young.count'])} #{sprintf("% 16d ", stats[:'gc.young.ms'])}
59+
Full #{sprintf("% 22d", stats[:'gc.immix.count'])} #{sprintf("% 16d / % 10d", stats[:'gc.immix.stop.ms'], stats[:'gc.immix.concurrent.ms'])}
6060
6161
Allocation
6262
Objects allocated Bytes allocated
63-
Young #{sprintf("% 22d", stats[:'memory.young.objects.total'])} #{sprintf("% 22d", stats[:'memory.young.bytes.total'])}
64-
Promoted#{sprintf("% 22d", stats[:'memory.promoted.objects.total'])} #{sprintf("% 22d", stats[:'memory.promoted.bytes.total'])}
65-
Mature #{sprintf("% 22d", stats[:'memory.immix.objects.total'])} #{sprintf("% 22d", stats[:'memory.immix.bytes.total'])}
63+
Young #{sprintf("% 22d", stats[:'memory.young.objects'])} #{sprintf("% 22d", stats[:'memory.young.bytes'])}
64+
Promoted#{sprintf("% 22d", stats[:'memory.promoted.objects'])} #{sprintf("% 22d", stats[:'memory.promoted.bytes'])}
65+
Mature #{sprintf("% 22d", stats[:'memory.immix.objects'])} #{sprintf("% 22d", stats[:'memory.immix.bytes'])}
6666
6767
6868
Usage
6969
Bytes used
70-
Young #{sprintf("% 22d", stats[:'memory.young.bytes.current'])}
71-
Mature #{sprintf("% 22d", stats[:'memory.immix.bytes.current'])}
72-
Large #{sprintf("% 22d", stats[:'memory.large.bytes.current'])}
70+
Young #{sprintf("% 22d", stats[:'memory.young.bytes'])}
71+
Mature #{sprintf("% 22d", stats[:'memory.immix.bytes'])}
72+
Large #{sprintf("% 22d", stats[:'memory.large.bytes'])}
7373
Code #{sprintf("% 22d", stats[:'memory.code.bytes'])}
7474
Symbols #{sprintf("% 22d", stats[:'memory.symbols.bytes'])}
7575
OUT

‎vm/builtin/data.cpp

+2-2
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
}
@@ -76,7 +76,7 @@ namespace rubinius {
7676
state->memory()->needs_finalization(data, (FinalizerFunction)&Data::finalize);
7777
}
7878

79-
state->vm()->metrics().m.ruby_metrics.memory_data_objects_total++;
79+
state->vm()->metrics().m.ruby_metrics.memory_data_objects++;
8080

8181
return data;
8282
}

‎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/llvm/state.cpp

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

294294
{
295295
timer::StopWatch<timer::microseconds> timer(
296-
metrics().m.jit_metrics.time_last_us,
297-
metrics().m.jit_metrics.time_total_us);
296+
metrics().m.jit_metrics.time_us);
298297

299298
jit.compile(compile_request);
300299

‎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
@@ -195,7 +195,7 @@ namespace rubinius {
195195
if(VM* vm = (*i)->as_vm()) {
196196
if(vm == current) {
197197
vm->metrics().init(metrics::eRubyMetrics);
198-
state->vm()->metrics().system_metrics.vm_threads++;
198+
state->vm()->metrics().system_metrics.vm_threads_created++;
199199
continue;
200200
}
201201

‎vm/symbol_table.hpp

+4
Original file line numberDiff line numberDiff line change
@@ -75,6 +75,10 @@ namespace rubinius {
7575
return bytes_used_;
7676
}
7777

78+
size_t size() {
79+
return symbols.size();
80+
};
81+
7882
Symbol* lookup(SharedState* shared, const std::string& str);
7983
Symbol* lookup(STATE, const std::string& str);
8084
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.