Skip to content

Commit

Permalink
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Merge remote-tracking branch 'origin' into 1.8.7
Browse files Browse the repository at this point in the history
Conflicts:
	kernel/common/gc.rb
	kernel/common/range_mirror.rb
	vm/builtin/data.cpp
	vm/shared_state.cpp
brixen committed Jun 23, 2015
2 parents 854648a + d1c4443 commit b823b26
Showing 16 changed files with 135 additions and 219 deletions.
2 changes: 1 addition & 1 deletion vm/builtin/data.cpp
Original file line number Diff line number Diff line change
@@ -42,7 +42,7 @@ namespace rubinius {
state->memory()->needs_finalization(data, (FinalizerFunction)&Data::finalize);
}

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

return data;
}
3 changes: 1 addition & 2 deletions vm/builtin/thread.cpp
Original file line number Diff line number Diff line change
@@ -93,8 +93,7 @@ namespace rubinius {
state->memory()->needs_finalization(thr, (FinalizerFunction)&Thread::finalize,
FinalizeObject::eUnmanaged);

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

return thr;
}
2 changes: 1 addition & 1 deletion vm/gc/immix.cpp
Original file line number Diff line number Diff line change
@@ -19,7 +19,7 @@ namespace rubinius {
#endif

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

if(gc_->dec_chunks_left() <= 0) {
gc_->reset_chunks_left();
8 changes: 2 additions & 6 deletions vm/gc/immix_marker.cpp
Original file line number Diff line number Diff line change
@@ -81,9 +81,7 @@ namespace rubinius {
if(data_) {
{
timer::StopWatch<timer::milliseconds> timer(
state->vm()->metrics().m.ruby_metrics.gc_immix_conc_last_ms,
state->vm()->metrics().m.ruby_metrics.gc_immix_conc_total_ms
);
state->vm()->metrics().m.ruby_metrics.gc_immix_concurrent_ms);

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

{
timer::StopWatch<timer::milliseconds> timer(
state->vm()->metrics().m.ruby_metrics.gc_immix_stop_last_ms,
state->vm()->metrics().m.ruby_metrics.gc_immix_stop_total_ms
);
state->vm()->metrics().m.ruby_metrics.gc_immix_stop_ms);

// Finish and pause
while(!state->stop_the_world()) {
6 changes: 1 addition & 5 deletions vm/gc/mark_sweep.cpp
Original file line number Diff line number Diff line change
@@ -56,9 +56,6 @@ namespace rubinius {
object_memory_->state()->metrics().m.ruby_metrics.memory_large_objects++;
object_memory_->state()->metrics().m.ruby_metrics.memory_large_bytes += bytes;

object_memory_->state()->metrics().m.ruby_metrics.memory_large_objects_total++;
object_memory_->state()->metrics().m.ruby_metrics.memory_large_bytes_total += bytes;

next_collection_bytes -= bytes;
if(next_collection_bytes < 0) {
*collect_now = true;
@@ -126,8 +123,7 @@ namespace rubinius {
metrics::MetricsData& metrics = object_memory_->state()->metrics();

timer::StopWatch<timer::milliseconds> timer(
metrics.m.ruby_metrics.gc_large_sweep_last_ms,
metrics.m.ruby_metrics.gc_large_sweep_total_ms);
metrics.m.ruby_metrics.gc_large_sweep_ms);

last_freed = 0;

9 changes: 3 additions & 6 deletions vm/instruments/timing.hpp
Original file line number Diff line number Diff line change
@@ -64,22 +64,19 @@ namespace timer {

template <int factor=milliseconds>
class StopWatch {
uint64_t& lap_;
uint64_t& total_;
uint64_t start_;

public:
StopWatch(uint64_t& lap, uint64_t& total)
: lap_(lap)
, total_(total)
StopWatch(uint64_t& total)
: total_(total)
{
start_ = get_current_time();
}

~StopWatch() {
uint64_t now = get_current_time();
lap_ = (now - start_) / ((uint64_t)factor);
total_ += lap_;
total_ += (now - start_) / ((uint64_t)factor);
}
};

16 changes: 8 additions & 8 deletions vm/internal_threads.cpp
Original file line number Diff line number Diff line change
@@ -130,7 +130,7 @@ namespace rubinius {
if(exec_in_progress_) return;
exec_in_progress_ = true;

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

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

for(std::list<InternalThread*>::reverse_iterator i = threads_.rbegin();
for(InternalThreadList::reverse_iterator i = threads_.rbegin();
i != threads_.rend();
++i) {
(*i)->before_fork_exec(state);
@@ -167,7 +167,7 @@ namespace rubinius {
void InternalThreads::after_fork_exec_parent(STATE) {
// We don't guard here on the assumption that only one thread is running
// after fork() call.
for(std::list<InternalThread*>::iterator i = threads_.begin();
for(InternalThreadList::iterator i = threads_.begin();
i != threads_.end();
++i) {
(*i)->after_fork_exec_parent(state);
@@ -179,7 +179,7 @@ namespace rubinius {
void InternalThreads::after_fork_exec_child(STATE) {
// We don't guard here on the assumption that only one thread is running
// after execvp() call.
for(std::list<InternalThread*>::iterator i = threads_.begin();
for(InternalThreadList::iterator i = threads_.begin();
i != threads_.end();
++i) {
(*i)->after_fork_exec_child(state);
@@ -195,7 +195,7 @@ namespace rubinius {
if(fork_in_progress_) return;
fork_in_progress_ = true;

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

for(std::list<InternalThread*>::iterator i = threads_.begin();
for(InternalThreadList::iterator i = threads_.begin();
i != threads_.end();
++i) {
(*i)->after_fork_child(state);
5 changes: 4 additions & 1 deletion vm/internal_threads.hpp
Original file line number Diff line number Diff line change
@@ -7,12 +7,15 @@
#include <list>

namespace rubinius {
class InternalThread;
class VM;

namespace metrics {
struct MetricsData;
}

typedef std::list<InternalThread*> InternalThreadList;

class InternalThread {
VM* vm_;
bool thread_running_;
@@ -73,7 +76,7 @@ namespace rubinius {
bool fork_exec_in_progress_;
bool shutdown_in_progress_;
utilities::thread::Mutex mutex_;
std::list<InternalThread*> threads_;
InternalThreadList threads_;

public:
InternalThreads()
3 changes: 1 addition & 2 deletions vm/llvm/state.cpp
Original file line number Diff line number Diff line change
@@ -292,8 +292,7 @@ namespace rubinius {

{
timer::StopWatch<timer::microseconds> timer(
metrics().m.jit_metrics.time_last_us,
metrics().m.jit_metrics.time_total_us);
metrics().m.jit_metrics.time_us);

jit.compile(compile_request);

105 changes: 34 additions & 71 deletions vm/metrics.cpp
Original file line number Diff line number Diff line change
@@ -227,56 +227,36 @@ namespace rubinius {
metrics_map_.push_back(new MetricsItem(
"jit.methods.failed", metrics_collection_.jit_metrics.methods_failed));
metrics_map_.push_back(new MetricsItem(
"jit.time.last.us", metrics_collection_.jit_metrics.time_last_us));
metrics_map_.push_back(new MetricsItem(
"jit.time.total.us", metrics_collection_.jit_metrics.time_total_us));
"jit.time.us", metrics_collection_.jit_metrics.time_us));

// Object memory metrics
metrics_map_.push_back(new MetricsItem(
"memory.young.bytes.current",
"memory.young.bytes",
metrics_collection_.ruby_metrics.memory_young_bytes));
metrics_map_.push_back(new MetricsItem(
"memory.young.bytes.total",
metrics_collection_.ruby_metrics.memory_young_bytes_total));
metrics_map_.push_back(new MetricsItem(
"memory.young.objects.current",
"memory.young.objects",
metrics_collection_.ruby_metrics.memory_young_objects));
metrics_map_.push_back(new MetricsItem(
"memory.young.objects.total",
metrics_collection_.ruby_metrics.memory_young_objects_total));
"memory.young.occupancy",
metrics_collection_.ruby_metrics.memory_young_occupancy));
metrics_map_.push_back(new MetricsItem(
"memory.young.percent_used",
metrics_collection_.ruby_metrics.memory_young_percent_used));
metrics_map_.push_back(new MetricsItem(
"memory.immix.bytes.current",
"memory.immix.bytes",
metrics_collection_.ruby_metrics.memory_immix_bytes));
metrics_map_.push_back(new MetricsItem(
"memory.immix.bytes.total",
metrics_collection_.ruby_metrics.memory_immix_bytes_total));
metrics_map_.push_back(new MetricsItem(
"memory.immix.objects.current",
"memory.immix.objects",
metrics_collection_.ruby_metrics.memory_immix_objects));
metrics_map_.push_back(new MetricsItem(
"memory.immix.objects.total",
metrics_collection_.ruby_metrics.memory_immix_objects_total));
metrics_map_.push_back(new MetricsItem(
"memory.immix.chunks.current",
"memory.immix.chunks",
metrics_collection_.ruby_metrics.memory_immix_chunks));
metrics_map_.push_back(new MetricsItem(
"memory.immix.chunks.total",
metrics_collection_.ruby_metrics.memory_immix_chunks_total));
metrics_map_.push_back(new MetricsItem(
"memory.large.bytes.current",
"memory.large.bytes",
metrics_collection_.ruby_metrics.memory_large_bytes));
metrics_map_.push_back(new MetricsItem(
"memory.large.bytes.total",
metrics_collection_.ruby_metrics.memory_large_bytes_total));
metrics_map_.push_back(new MetricsItem(
"memory.large.objects.current",
"memory.large.objects",
metrics_collection_.ruby_metrics.memory_large_objects));
metrics_map_.push_back(new MetricsItem(
"memory.large.objects.total",
metrics_collection_.ruby_metrics.memory_large_objects_total));
"memory.symbols",
metrics_collection_.ruby_metrics.memory_symbols));
metrics_map_.push_back(new MetricsItem(
"memory.symbols.bytes",
metrics_collection_.ruby_metrics.memory_symbols_bytes));
@@ -285,25 +265,22 @@ namespace rubinius {
metrics_map_.push_back(new MetricsItem(
"memory.jit.bytes", metrics_collection_.ruby_metrics.memory_jit_bytes));
metrics_map_.push_back(new MetricsItem(
"memory.promoted.bytes.total",
metrics_collection_.ruby_metrics.memory_promoted_bytes_total));
"memory.promoted.bytes",
metrics_collection_.ruby_metrics.memory_promoted_bytes));
metrics_map_.push_back(new MetricsItem(
"memory.promoted.objects.total",
metrics_collection_.ruby_metrics.memory_promoted_objects_total));
"memory.promoted.objects",
metrics_collection_.ruby_metrics.memory_promoted_objects));
metrics_map_.push_back(new MetricsItem(
"memory.slab.refills.total",
metrics_collection_.ruby_metrics.memory_slab_refills_total));
"memory.slab.refills",
metrics_collection_.ruby_metrics.memory_slab_refills));
metrics_map_.push_back(new MetricsItem(
"memory.slab.refills.fails",
metrics_collection_.ruby_metrics.memory_slab_refills_fails));
metrics_map_.push_back(new MetricsItem(
"memory.data_objects.total",
metrics_collection_.ruby_metrics.memory_data_objects_total));
"memory.data_objects",
metrics_collection_.ruby_metrics.memory_data_objects));
metrics_map_.push_back(new MetricsItem(
"memory.capi_handles.total",
metrics_collection_.ruby_metrics.memory_capi_handles_total));
metrics_map_.push_back(new MetricsItem(
"memory.capi_handles.current",
"memory.capi_handles",
metrics_collection_.ruby_metrics.memory_capi_handles));
metrics_map_.push_back(new MetricsItem(
"memory.inflated_headers",
@@ -313,33 +290,22 @@ namespace rubinius {
metrics_map_.push_back(new MetricsItem(
"gc.young.count", metrics_collection_.ruby_metrics.gc_young_count));
metrics_map_.push_back(new MetricsItem(
"gc.young.last.ms", metrics_collection_.ruby_metrics.gc_young_last_ms));
metrics_map_.push_back(new MetricsItem(
"gc.young.total.ms", metrics_collection_.ruby_metrics.gc_young_total_ms));
"gc.young.ms", metrics_collection_.ruby_metrics.gc_young_ms));
metrics_map_.push_back(new MetricsItem(
"gc.young.lifetime", metrics_collection_.ruby_metrics.gc_young_lifetime));
metrics_map_.push_back(new MetricsItem(
"gc.immix.count", metrics_collection_.ruby_metrics.gc_immix_count));
metrics_map_.push_back(new MetricsItem(
"gc.immix.stop.last.ms",
metrics_collection_.ruby_metrics.gc_immix_stop_last_ms));
metrics_map_.push_back(new MetricsItem(
"gc.immix.stop.total.ms",
metrics_collection_.ruby_metrics.gc_immix_stop_total_ms));
"gc.immix.stop.ms",
metrics_collection_.ruby_metrics.gc_immix_stop_ms));
metrics_map_.push_back(new MetricsItem(
"gc.immix.concurrent.last.ms",
metrics_collection_.ruby_metrics.gc_immix_conc_last_ms));
metrics_map_.push_back(new MetricsItem(
"gc.immix.concurrent.total.ms",
metrics_collection_.ruby_metrics.gc_immix_conc_total_ms));
"gc.immix.concurrent.ms",
metrics_collection_.ruby_metrics.gc_immix_concurrent_ms));
metrics_map_.push_back(new MetricsItem(
"gc.large.count", metrics_collection_.ruby_metrics.gc_large_count));
metrics_map_.push_back(new MetricsItem(
"gc.large.sweep.last.ms",
metrics_collection_.ruby_metrics.gc_large_sweep_last_ms));
metrics_map_.push_back(new MetricsItem(
"gc.large.sweep.total.ms",
metrics_collection_.ruby_metrics.gc_large_sweep_total_ms));
"gc.large.sweep.ms",
metrics_collection_.ruby_metrics.gc_large_sweep_ms));

// I/O metrics
metrics_map_.push_back(new MetricsItem(
@@ -360,19 +326,16 @@ namespace rubinius {
"vm.inline_cache.resets",
metrics_collection_.system_metrics.vm_inline_cache_resets));
metrics_map_.push_back(new MetricsItem(
"vm.threads.current",
metrics_collection_.system_metrics.vm_threads));
"vm.threads.created",
metrics_collection_.system_metrics.vm_threads_created));
metrics_map_.push_back(new MetricsItem(
"vm.threads.total",
metrics_collection_.system_metrics.vm_threads_total));
"vm.threads.destroyed",
metrics_collection_.system_metrics.vm_threads_destroyed));

// Lock metrics
metrics_map_.push_back(new MetricsItem(
"locks.stop_the_world.last.ns",
metrics_collection_.system_metrics.locks_stop_the_world_last_ns));
metrics_map_.push_back(new MetricsItem(
"locks.stop_the_world.total.ns",
metrics_collection_.system_metrics.locks_stop_the_world_total_ns));
"locks.stop_the_world.ns",
metrics_collection_.system_metrics.locks_stop_the_world_ns));
}

void Metrics::init_ruby_metrics(STATE) {
124 changes: 43 additions & 81 deletions vm/metrics.hpp
Original file line number Diff line number Diff line change
@@ -34,126 +34,94 @@ namespace rubinius {
struct RubyMetrics {
// Object memory metrics
metric memory_young_bytes;
metric memory_young_bytes_total;
metric memory_young_objects;
metric memory_young_objects_total;
metric memory_young_percent_used;
metric memory_young_occupancy;
metric memory_immix_bytes;
metric memory_immix_bytes_total;
metric memory_immix_objects;
metric memory_immix_objects_total;
metric memory_immix_chunks;
metric memory_immix_chunks_total;
metric memory_large_bytes;
metric memory_large_bytes_total;
metric memory_large_objects;
metric memory_large_objects_total;
metric memory_symbols;
metric memory_symbols_bytes;
metric memory_code_bytes;
metric memory_jit_bytes;
metric memory_promoted_bytes_total;
metric memory_promoted_objects_total;
metric memory_slab_refills_total;
metric memory_promoted_bytes;
metric memory_promoted_objects;
metric memory_slab_refills;
metric memory_slab_refills_fails;
metric memory_data_objects_total;
metric memory_data_objects;
metric memory_capi_handles;
metric memory_capi_handles_total;
metric memory_inflated_headers;

// Garbage collector metrics
metric gc_young_count;
metric gc_young_last_ms;
metric gc_young_total_ms;
metric gc_young_ms;
metric gc_young_lifetime;
metric gc_immix_count;
metric gc_immix_stop_last_ms;
metric gc_immix_stop_total_ms;
metric gc_immix_conc_last_ms;
metric gc_immix_conc_total_ms;
metric gc_immix_stop_ms;
metric gc_immix_concurrent_ms;
metric gc_large_count;
metric gc_large_sweep_last_ms;
metric gc_large_sweep_total_ms;
metric gc_large_sweep_ms;

void init() {
memory_young_bytes = 0;
memory_young_bytes_total = 0;
memory_young_objects = 0;
memory_young_objects_total = 0;
memory_young_percent_used = 0;
memory_young_occupancy = 0;
memory_immix_bytes = 0;
memory_immix_bytes_total = 0;
memory_immix_objects = 0;
memory_immix_objects_total = 0;
memory_immix_chunks = 0;
memory_immix_chunks_total = 0;
memory_large_bytes = 0;
memory_large_bytes_total = 0;
memory_large_objects = 0;
memory_large_objects_total = 0;
memory_symbols = 0;
memory_symbols_bytes = 0;
memory_code_bytes = 0;
memory_jit_bytes = 0;
memory_promoted_bytes_total = 0;
memory_promoted_objects_total = 0;
memory_slab_refills_total = 0;
memory_promoted_bytes = 0;
memory_promoted_objects = 0;
memory_slab_refills = 0;
memory_slab_refills_fails = 0;
memory_data_objects_total = 0;
memory_data_objects = 0;
memory_capi_handles = 0;
memory_capi_handles_total = 0;
memory_inflated_headers = 0;
gc_young_count = 0;
gc_young_last_ms = 0;
gc_young_total_ms = 0;
gc_young_ms = 0;
gc_young_lifetime = 0;
gc_immix_count = 0;
gc_immix_stop_last_ms = 0;
gc_immix_stop_total_ms = 0;
gc_immix_conc_last_ms = 0;
gc_immix_conc_total_ms = 0;
gc_immix_stop_ms = 0;
gc_immix_concurrent_ms = 0;
gc_large_count = 0;
gc_large_sweep_last_ms = 0;
gc_large_sweep_total_ms = 0;
gc_large_sweep_ms = 0;
}

void add(RubyMetrics& data) {
memory_young_bytes += data.memory_young_bytes;
memory_young_bytes_total += data.memory_young_bytes_total;
memory_young_objects += data.memory_young_objects;
memory_young_objects_total += data.memory_young_objects_total;
memory_young_percent_used += data.memory_young_percent_used;
memory_young_occupancy += data.memory_young_occupancy;
memory_immix_bytes += data.memory_immix_bytes;
memory_immix_bytes_total += data.memory_immix_bytes_total;
memory_immix_objects += data.memory_immix_objects;
memory_immix_objects_total += data.memory_immix_objects_total;
memory_immix_chunks += data.memory_immix_chunks;
memory_immix_chunks_total += data.memory_immix_chunks_total;
memory_large_bytes += data.memory_large_bytes;
memory_large_bytes_total += data.memory_large_bytes_total;
memory_large_objects += data.memory_large_objects;
memory_large_objects_total += data.memory_large_objects_total;
memory_symbols += data.memory_symbols;
memory_symbols_bytes += data.memory_symbols_bytes;
memory_code_bytes += data.memory_code_bytes;
memory_jit_bytes += data.memory_jit_bytes;
memory_promoted_bytes_total += data.memory_promoted_bytes_total;
memory_promoted_objects_total += data.memory_promoted_objects_total;
memory_slab_refills_total += data.memory_slab_refills_total;
memory_promoted_bytes += data.memory_promoted_bytes;
memory_promoted_objects += data.memory_promoted_objects;
memory_slab_refills += data.memory_slab_refills;
memory_slab_refills_fails += data.memory_slab_refills_fails;
memory_data_objects_total += data.memory_data_objects_total;
memory_data_objects += data.memory_data_objects;
memory_capi_handles += data.memory_capi_handles;
memory_capi_handles += data.memory_capi_handles;
memory_capi_handles_total += data.memory_capi_handles_total;
memory_inflated_headers += data.memory_inflated_headers;
gc_young_count += data.gc_young_count;
gc_young_last_ms += data.gc_young_last_ms;
gc_young_total_ms += data.gc_young_total_ms;
gc_young_ms += data.gc_young_ms;
gc_young_lifetime += data.gc_young_lifetime;
gc_immix_count += data.gc_immix_count;
gc_immix_stop_last_ms += data.gc_immix_stop_last_ms;
gc_immix_stop_total_ms += data.gc_immix_stop_total_ms;
gc_immix_conc_last_ms += data.gc_immix_conc_last_ms;
gc_immix_conc_total_ms += data.gc_immix_conc_total_ms;
gc_immix_stop_ms += data.gc_immix_stop_ms;
gc_immix_concurrent_ms += data.gc_immix_concurrent_ms;
gc_large_count += data.gc_large_count;
gc_large_sweep_last_ms += data.gc_large_sweep_last_ms;
gc_large_sweep_total_ms += data.gc_large_sweep_total_ms;
gc_large_sweep_ms += data.gc_large_sweep_ms;
}

void add(MetricsData& data);
@@ -180,23 +148,20 @@ namespace rubinius {
metric methods_queued;
metric methods_compiled;
metric methods_failed;
metric time_last_us;
metric time_total_us;
metric time_us;

void init() {
methods_queued = 0;
methods_compiled = 0;
methods_failed = 0;
time_last_us = 0;
time_total_us = 0;
time_us = 0;
}

void add(JITMetrics& data) {
methods_queued += data.methods_queued;
methods_compiled += data.methods_compiled;
methods_failed += data.methods_failed;
time_last_us += data.time_last_us;
time_total_us += data.time_total_us;
time_us += data.time_us;
}

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

// VM metrics
metric vm_inline_cache_resets;
metric vm_threads;
metric vm_threads_total;
metric vm_threads_created;
metric vm_threads_destroyed;

// Lock metrics
metric locks_stop_the_world_last_ns;
metric locks_stop_the_world_total_ns;
metric locks_stop_the_world_ns;

void init() {
io_read_bytes = 0;
io_write_bytes = 0;
os_signals_received = 0;
os_signals_processed = 0;
vm_inline_cache_resets = 0;
vm_threads = 0;
vm_threads_total = 0;
locks_stop_the_world_last_ns = 0;
locks_stop_the_world_total_ns = 0;
vm_threads_created = 0;
vm_threads_destroyed = 0;
locks_stop_the_world_ns = 0;
}

void add(SystemMetrics& data) {
@@ -255,10 +218,9 @@ namespace rubinius {
os_signals_received += data.os_signals_received;
os_signals_processed += data.os_signals_processed;
vm_inline_cache_resets += data.vm_inline_cache_resets;
vm_threads += data.vm_threads;
vm_threads_total += data.vm_threads_total;
locks_stop_the_world_last_ns += data.locks_stop_the_world_last_ns;
locks_stop_the_world_total_ns += data.locks_stop_the_world_total_ns;
vm_threads_created += data.vm_threads_created;
vm_threads_destroyed += data.vm_threads_destroyed;
locks_stop_the_world_ns += data.locks_stop_the_world_ns;
}

void add(MetricsData& data);
60 changes: 29 additions & 31 deletions vm/object_memory.cpp
Original file line number Diff line number Diff line change
@@ -437,12 +437,12 @@ namespace rubinius {
Address addr = young_->allocate_for_slab(slab_size_);

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

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

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

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

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

metrics::MetricsData& metrics = state->vm()->metrics();
metrics.m.ruby_metrics.memory_young_bytes =
metrics.m.ruby_metrics.memory_young_bytes +=
state->memory()->young_bytes_allocated();
metrics.m.ruby_metrics.memory_young_percent_used = stats.percentage_used;
metrics.m.ruby_metrics.gc_young_lifetime = stats.lifetime;
metrics.m.ruby_metrics.memory_young_occupancy += stats.percentage_used;
metrics.m.ruby_metrics.gc_young_lifetime += stats.lifetime;
}

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

timer::StopWatch<timer::milliseconds> timerx(
state->vm()->metrics().m.ruby_metrics.gc_young_last_ms,
state->vm()->metrics().m.ruby_metrics.gc_young_total_ms
);
state->vm()->metrics().m.ruby_metrics.gc_young_ms);

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

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

#ifndef RBX_GC_STRESS_MATURE
collect_mature_now = false;
@@ -671,11 +668,12 @@ namespace rubinius {
metrics::MetricsData& metrics = state->vm()->metrics();
metrics.m.ruby_metrics.gc_immix_count++;
metrics.m.ruby_metrics.gc_large_count++;
metrics.m.ruby_metrics.memory_immix_bytes = immix_->bytes_allocated();
metrics.m.ruby_metrics.memory_large_bytes = mark_sweep_->allocated_bytes;
metrics.m.ruby_metrics.memory_symbols_bytes = shared_.symbols.bytes_used();
metrics.m.ruby_metrics.memory_code_bytes = code_manager_.size();
metrics.m.ruby_metrics.memory_jit_bytes = data->jit_bytes_allocated();
metrics.m.ruby_metrics.memory_immix_bytes += immix_->bytes_allocated();
metrics.m.ruby_metrics.memory_large_bytes += mark_sweep_->allocated_bytes;
metrics.m.ruby_metrics.memory_symbols += shared_.symbols.size();
metrics.m.ruby_metrics.memory_symbols_bytes += shared_.symbols.bytes_used();
metrics.m.ruby_metrics.memory_code_bytes += code_manager_.size();
metrics.m.ruby_metrics.memory_jit_bytes += data->jit_bytes_allocated();

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

state()->metrics().m.ruby_metrics.memory_immix_objects_total++;
state()->metrics().m.ruby_metrics.memory_immix_bytes_total += bytes;
state()->metrics().m.ruby_metrics.memory_immix_objects++;
state()->metrics().m.ruby_metrics.memory_immix_bytes += bytes;

if(collect_mature_now) shared_.gc_soon();

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

state()->metrics().m.ruby_metrics.memory_immix_objects_total++;
state()->metrics().m.ruby_metrics.memory_immix_bytes_total += bytes;
state()->metrics().m.ruby_metrics.memory_immix_objects++;
state()->metrics().m.ruby_metrics.memory_immix_bytes += bytes;

if(collect_mature_now) shared_.gc_soon();
} else {
state()->metrics().m.ruby_metrics.memory_young_objects_total++;
state()->metrics().m.ruby_metrics.memory_young_bytes_total += bytes;
state()->metrics().m.ruby_metrics.memory_young_objects++;
state()->metrics().m.ruby_metrics.memory_young_bytes += bytes;
}
}

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

state()->metrics().m.ruby_metrics.memory_immix_objects_total++;
state()->metrics().m.ruby_metrics.memory_immix_bytes_total += bytes;
state()->metrics().m.ruby_metrics.memory_immix_objects++;
state()->metrics().m.ruby_metrics.memory_immix_bytes += bytes;
}

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

state()->metrics().m.ruby_metrics.memory_immix_objects_total++;
state()->metrics().m.ruby_metrics.memory_immix_bytes_total += bytes;
state()->metrics().m.ruby_metrics.memory_immix_objects++;
state()->metrics().m.ruby_metrics.memory_immix_bytes += bytes;

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

state->vm()->metrics().m.ruby_metrics.memory_immix_objects_total++;
state->vm()->metrics().m.ruby_metrics.memory_immix_bytes_total += bytes;
state->vm()->metrics().m.ruby_metrics.memory_immix_objects++;
state->vm()->metrics().m.ruby_metrics.memory_immix_bytes += bytes;

if(collect_mature_now) shared_.gc_soon();

@@ -1027,7 +1025,7 @@ namespace rubinius {
if(!obj->reference_p()) {
rubinius::bug("Trying to add a handle for a non reference");
}
state->vm()->metrics().m.ruby_metrics.memory_capi_handles_total++;
state->vm()->metrics().m.ruby_metrics.memory_capi_handles++;
uintptr_t handle_index = capi_handles_->allocate_index(state, obj);
obj->set_handle_index(state, handle_index);
return obj->handle(state);
2 changes: 1 addition & 1 deletion vm/shared_state.cpp
Original file line number Diff line number Diff line change
@@ -200,7 +200,7 @@ namespace rubinius {
if(VM* vm = (*i)->as_vm()) {
if(vm == current) {
vm->metrics().init(metrics::eRubyMetrics);
state->vm()->metrics().system_metrics.vm_threads++;
state->vm()->metrics().system_metrics.vm_threads_created++;
continue;
}

4 changes: 4 additions & 0 deletions vm/symbol_table.hpp
Original file line number Diff line number Diff line change
@@ -73,6 +73,10 @@ namespace rubinius {
return bytes_used_;
}

size_t size() {
return symbols.size();
};

Symbol* lookup(SharedState* shared, const std::string& str);
Symbol* lookup(STATE, const std::string& str);
Symbol* lookup(STATE, const char* str, size_t length);
2 changes: 1 addition & 1 deletion vm/vm.cpp
Original file line number Diff line number Diff line change
@@ -109,7 +109,7 @@ namespace rubinius {
vm->saved_call_frame_ = 0;
vm->shared.remove_vm(vm);

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

delete vm;
}
3 changes: 1 addition & 2 deletions vm/world_state.hpp
Original file line number Diff line number Diff line change
@@ -140,8 +140,7 @@ namespace rubinius {
atomic::fetch_and_sub(&pending_threads_, 1);

timer::StopWatch<timer::nanoseconds> timer(
state->metrics().system_metrics.locks_stop_the_world_last_ns,
state->metrics().system_metrics.locks_stop_the_world_total_ns);
state->metrics().system_metrics.locks_stop_the_world_ns);

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

0 comments on commit b823b26

Please sign in to comment.