From b2929acff61f4a06410a40fc9030dae884692ee6 Mon Sep 17 00:00:00 2001 From: Erik Charlebois Date: Sat, 11 May 2013 22:28:05 -0400 Subject: [PATCH] VM: Refactor sampling_profiler.cpp/hpp to Factor style --- vm/sampling_profiler.cpp | 270 +++++++++++++++++++-------------------- vm/sampling_profiler.hpp | 108 +++++++--------- 2 files changed, 180 insertions(+), 198 deletions(-) diff --git a/vm/sampling_profiler.cpp b/vm/sampling_profiler.cpp index caf349f1a0..5c527a8f99 100644 --- a/vm/sampling_profiler.cpp +++ b/vm/sampling_profiler.cpp @@ -1,172 +1,164 @@ #include "master.hpp" -namespace factor -{ - -profiling_sample_count profiling_sample_count::record_counts() volatile -{ - atomic::fence(); - profiling_sample_count returned( - sample_count, - gc_sample_count, - jit_sample_count, - foreign_sample_count, - foreign_thread_sample_count); - atomic::fetch_subtract(&sample_count, returned.sample_count); - atomic::fetch_subtract(&gc_sample_count, returned.gc_sample_count); - atomic::fetch_subtract(&jit_sample_count, returned.jit_sample_count); - atomic::fetch_subtract(&foreign_sample_count, returned.foreign_sample_count); - atomic::fetch_subtract(&foreign_thread_sample_count, returned.foreign_thread_sample_count); - return returned; +namespace factor { + +profiling_sample_count profiling_sample_count::record_counts() volatile { + atomic::fence(); + profiling_sample_count returned(sample_count, gc_sample_count, + jit_sample_count, foreign_sample_count, + foreign_thread_sample_count); + atomic::fetch_subtract(&sample_count, returned.sample_count); + atomic::fetch_subtract(&gc_sample_count, returned.gc_sample_count); + atomic::fetch_subtract(&jit_sample_count, returned.jit_sample_count); + atomic::fetch_subtract(&foreign_sample_count, returned.foreign_sample_count); + atomic::fetch_subtract(&foreign_thread_sample_count, + returned.foreign_thread_sample_count); + return returned; } -void profiling_sample_count::clear() volatile -{ - sample_count = 0; - gc_sample_count = 0; - jit_sample_count = 0; - foreign_sample_count = 0; - foreign_thread_sample_count = 0; - atomic::fence(); +void profiling_sample_count::clear() volatile { + sample_count = 0; + gc_sample_count = 0; + jit_sample_count = 0; + foreign_sample_count = 0; + foreign_thread_sample_count = 0; + atomic::fence(); } -profiling_sample::profiling_sample(factor_vm *vm, - bool prolog_p, - profiling_sample_count const &counts, - cell thread) - : - counts(counts), - thread(thread) -{ - vm->record_callstack_sample(&callstack_begin, &callstack_end, prolog_p); +profiling_sample::profiling_sample(factor_vm* vm, bool prolog_p, + profiling_sample_count const& counts, + cell thread) + : counts(counts), thread(thread) { + vm->record_callstack_sample(&callstack_begin, &callstack_end, prolog_p); } -void factor_vm::record_sample(bool prolog_p) -{ - profiling_sample_count counts = safepoint.sample_counts.record_counts(); - if (!counts.empty()) - samples.push_back(profiling_sample(this, prolog_p, - counts, special_objects[OBJ_CURRENT_THREAD])); +void factor_vm::record_sample(bool prolog_p) { + profiling_sample_count counts = safepoint.sample_counts.record_counts(); + if (!counts.empty()) + samples.push_back(profiling_sample(this, prolog_p, counts, + special_objects[OBJ_CURRENT_THREAD])); } struct record_callstack_sample_iterator { - std::vector *sample_callstacks; - bool skip_p; - - record_callstack_sample_iterator(std::vector *sample_callstacks, bool prolog_p) - : sample_callstacks(sample_callstacks), skip_p(prolog_p) {} - - void operator()(void *frame_top, cell frame_size, code_block *owner, void *addr) - { - if (skip_p) - skip_p = false; - else - sample_callstacks->push_back(owner->owner); - } + std::vector* sample_callstacks; + bool skip_p; + + record_callstack_sample_iterator(std::vector* sample_callstacks, + bool prolog_p) + : sample_callstacks(sample_callstacks), skip_p(prolog_p) {} + + void operator()(void* frame_top, cell frame_size, code_block* owner, + void* addr) { + if (skip_p) + skip_p = false; + else + sample_callstacks->push_back(owner->owner); + } }; -void factor_vm::record_callstack_sample(cell *begin, cell *end, bool prolog_p) -{ - *begin = sample_callstacks.size(); +void factor_vm::record_callstack_sample(cell* begin, cell* end, bool prolog_p) { + *begin = sample_callstacks.size(); - record_callstack_sample_iterator recorder(&sample_callstacks, prolog_p); - iterate_callstack(ctx, recorder); + record_callstack_sample_iterator recorder(&sample_callstacks, prolog_p); + iterate_callstack(ctx, recorder); - *end = sample_callstacks.size(); + *end = sample_callstacks.size(); - std::reverse(sample_callstacks.begin() + *begin, sample_callstacks.end()); + std::reverse(sample_callstacks.begin() + *begin, sample_callstacks.end()); } -void factor_vm::set_sampling_profiler(fixnum rate) -{ - bool sampling_p = !!rate; - if (sampling_p == !!atomic::load(&sampling_profiler_p)) - return; - - if (sampling_p) - start_sampling_profiler(rate); - else - end_sampling_profiler(); +void factor_vm::set_sampling_profiler(fixnum rate) { + bool sampling_p = !!rate; + if (sampling_p == !!atomic::load(&sampling_profiler_p)) + return; + + if (sampling_p) + start_sampling_profiler(rate); + else + end_sampling_profiler(); } -void factor_vm::clear_samples() -{ - // Swapping into temporaries releases the vector's allocated storage, - // whereas clear() would leave the allocation as-is - std::vector sample_graveyard; - std::vector sample_callstack_graveyard; - samples.swap(sample_graveyard); - sample_callstacks.swap(sample_callstack_graveyard); +void factor_vm::clear_samples() { + // Swapping into temporaries releases the vector's allocated storage, + // whereas clear() would leave the allocation as-is + std::vector sample_graveyard; + std::vector sample_callstack_graveyard; + samples.swap(sample_graveyard); + sample_callstacks.swap(sample_callstack_graveyard); } -void factor_vm::start_sampling_profiler(fixnum rate) -{ - samples_per_second = rate; - safepoint.sample_counts.clear(); - clear_samples(); - samples.reserve(10*rate); - sample_callstacks.reserve(100*rate); - atomic::store(&sampling_profiler_p, true); - start_sampling_profiler_timer(); +void factor_vm::start_sampling_profiler(fixnum rate) { + samples_per_second = rate; + safepoint.sample_counts.clear(); + clear_samples(); + samples.reserve(10 * rate); + sample_callstacks.reserve(100 * rate); + atomic::store(&sampling_profiler_p, true); + start_sampling_profiler_timer(); } -void factor_vm::end_sampling_profiler() -{ - atomic::store(&sampling_profiler_p, false); - end_sampling_profiler_timer(); - record_sample(false); +void factor_vm::end_sampling_profiler() { + atomic::store(&sampling_profiler_p, false); + end_sampling_profiler_timer(); + record_sample(false); } -void factor_vm::primitive_sampling_profiler() -{ - set_sampling_profiler(to_fixnum(ctx->pop())); +void factor_vm::primitive_sampling_profiler() { + set_sampling_profiler(to_fixnum(ctx->pop())); } /* Allocates memory */ -void factor_vm::primitive_get_samples() -{ - if (atomic::load(&sampling_profiler_p) || samples.empty()) { - ctx->push(false_object); - } else { - data_root samples_array(allot_array(samples.size(), false_object),this); - std::vector::const_iterator from_iter = samples.begin(); - cell to_i = 0; - - for (; from_iter != samples.end(); ++from_iter, ++to_i) - { - data_root sample(allot_array(7, false_object),this); - - set_array_nth(sample.untagged(),0,tag_fixnum(from_iter->counts.sample_count)); - set_array_nth(sample.untagged(),1,tag_fixnum(from_iter->counts.gc_sample_count)); - set_array_nth(sample.untagged(),2,tag_fixnum(from_iter->counts.jit_sample_count)); - set_array_nth(sample.untagged(),3,tag_fixnum(from_iter->counts.foreign_sample_count)); - set_array_nth(sample.untagged(),4,tag_fixnum(from_iter->counts.foreign_thread_sample_count)); - - set_array_nth(sample.untagged(),5,from_iter->thread); - - cell callstack_size = from_iter->callstack_end - from_iter->callstack_begin; - data_root callstack(allot_array(callstack_size,false_object),this); - - std::vector::const_iterator - callstacks_begin = sample_callstacks.begin(), - c_from_iter = callstacks_begin + from_iter->callstack_begin, - c_from_iter_end = callstacks_begin + from_iter->callstack_end; - cell c_to_i = 0; - - for (; c_from_iter != c_from_iter_end; ++c_from_iter, ++c_to_i) - set_array_nth(callstack.untagged(),c_to_i,*c_from_iter); - - set_array_nth(sample.untagged(),6,callstack.value()); - - set_array_nth(samples_array.untagged(),to_i,sample.value()); - } - ctx->push(samples_array.value()); - } +void factor_vm::primitive_get_samples() { + if (atomic::load(&sampling_profiler_p) || samples.empty()) { + ctx->push(false_object); + } else { + data_root samples_array(allot_array(samples.size(), false_object), + this); + std::vector::const_iterator from_iter = samples.begin(); + cell to_i = 0; + + for (; from_iter != samples.end(); ++from_iter, ++to_i) { + data_root sample(allot_array(7, false_object), this); + + set_array_nth(sample.untagged(), 0, + tag_fixnum(from_iter->counts.sample_count)); + set_array_nth(sample.untagged(), 1, + tag_fixnum(from_iter->counts.gc_sample_count)); + set_array_nth(sample.untagged(), 2, + tag_fixnum(from_iter->counts.jit_sample_count)); + set_array_nth(sample.untagged(), 3, + tag_fixnum(from_iter->counts.foreign_sample_count)); + set_array_nth(sample.untagged(), 4, + tag_fixnum(from_iter->counts.foreign_thread_sample_count)); + + set_array_nth(sample.untagged(), 5, from_iter->thread); + + cell callstack_size = + from_iter->callstack_end - from_iter->callstack_begin; + data_root callstack(allot_array(callstack_size, false_object), + this); + + std::vector::const_iterator callstacks_begin = + sample_callstacks.begin(), + c_from_iter = + callstacks_begin + + from_iter->callstack_begin, + c_from_iter_end = + callstacks_begin + + from_iter->callstack_end; + cell c_to_i = 0; + + for (; c_from_iter != c_from_iter_end; ++c_from_iter, ++c_to_i) + set_array_nth(callstack.untagged(), c_to_i, *c_from_iter); + + set_array_nth(sample.untagged(), 6, callstack.value()); + + set_array_nth(samples_array.untagged(), to_i, sample.value()); + } + ctx->push(samples_array.value()); + } } -void factor_vm::primitive_clear_samples() -{ - clear_samples(); -} +void factor_vm::primitive_clear_samples() { clear_samples(); } } diff --git a/vm/sampling_profiler.hpp b/vm/sampling_profiler.hpp index 5f0558fe04..8711f28d63 100644 --- a/vm/sampling_profiler.hpp +++ b/vm/sampling_profiler.hpp @@ -1,64 +1,54 @@ -namespace factor -{ - -struct profiling_sample_count -{ - // Number of samples taken before the safepoint that recorded the sample - fixnum sample_count; - // Number of samples taken during GC - fixnum gc_sample_count; - // Number of samples taken during unoptimized compiler - fixnum jit_sample_count; - // Number of samples taken during foreign code execution - fixnum foreign_sample_count; - // Number of samples taken during code execution in non-Factor threads - fixnum foreign_thread_sample_count; - - profiling_sample_count() : - sample_count(0), - gc_sample_count(0), - jit_sample_count(0), - foreign_sample_count(0), - foreign_thread_sample_count(0) {} - - profiling_sample_count(fixnum sample_count, - fixnum gc_sample_count, - fixnum jit_sample_count, - fixnum foreign_sample_count, - fixnum foreign_thread_sample_count) : - sample_count(sample_count), - gc_sample_count(gc_sample_count), - jit_sample_count(jit_sample_count), - foreign_sample_count(foreign_sample_count), - foreign_thread_sample_count(foreign_thread_sample_count) {} - - bool empty() const - { - return sample_count - + gc_sample_count - + jit_sample_count - + foreign_sample_count - + foreign_thread_sample_count == 0; - } - - profiling_sample_count record_counts() volatile; - void clear() volatile; +namespace factor { + +struct profiling_sample_count { + // Number of samples taken before the safepoint that recorded the sample + fixnum sample_count; + // Number of samples taken during GC + fixnum gc_sample_count; + // Number of samples taken during unoptimized compiler + fixnum jit_sample_count; + // Number of samples taken during foreign code execution + fixnum foreign_sample_count; + // Number of samples taken during code execution in non-Factor threads + fixnum foreign_thread_sample_count; + + profiling_sample_count() + : sample_count(0), + gc_sample_count(0), + jit_sample_count(0), + foreign_sample_count(0), + foreign_thread_sample_count(0) {} + + profiling_sample_count(fixnum sample_count, fixnum gc_sample_count, + fixnum jit_sample_count, fixnum foreign_sample_count, + fixnum foreign_thread_sample_count) + : sample_count(sample_count), + gc_sample_count(gc_sample_count), + jit_sample_count(jit_sample_count), + foreign_sample_count(foreign_sample_count), + foreign_thread_sample_count(foreign_thread_sample_count) {} + + bool empty() const { + return sample_count + gc_sample_count + jit_sample_count + + foreign_sample_count + foreign_thread_sample_count == + 0; + } + + profiling_sample_count record_counts() volatile; + void clear() volatile; }; -struct profiling_sample -{ - // Sample counts - profiling_sample_count counts; - // Active thread during sample - cell thread; - /* The callstack at safepoint time. Indexes to the beginning and ending - code_block entries in the vm sample_callstacks array. */ - cell callstack_begin, callstack_end; - - profiling_sample(factor_vm *vm, - bool prolog_p, - profiling_sample_count const &counts, - cell thread); +struct profiling_sample { + // Sample counts + profiling_sample_count counts; + // Active thread during sample + cell thread; + /* The callstack at safepoint time. Indexes to the beginning and ending + code_block entries in the vm sample_callstacks array. */ + cell callstack_begin, callstack_end; + + profiling_sample(factor_vm* vm, bool prolog_p, + profiling_sample_count const& counts, cell thread); }; } -- 2.34.1