vm/sampling_profiler.cpp

   1 #include "master.hpp"
   2
   3 namespace factor
   4 {
   5
   6 profiling_sample_count profiling_sample_count::record_counts() volatile
   7 {
   8         atomic::fence();
   9         profiling_sample_count returned(
  10                 sample_count,
  11                 gc_sample_count,
  12                 jit_sample_count,
  13                 foreign_sample_count,
  14                 foreign_thread_sample_count);
  15         atomic::fetch_subtract(&sample_count, returned.sample_count);
  16         atomic::fetch_subtract(&gc_sample_count, returned.gc_sample_count);
  17         atomic::fetch_subtract(&jit_sample_count, returned.jit_sample_count);
  18         atomic::fetch_subtract(&foreign_sample_count, returned.foreign_sample_count);
  19         atomic::fetch_subtract(&foreign_thread_sample_count, returned.foreign_thread_sample_count);
  20         return returned;
  21 }
  22
  23 void profiling_sample_count::clear() volatile
  24 {
  25         sample_count = 0;
  26         gc_sample_count = 0;
  27         jit_sample_count = 0;
  28         foreign_sample_count = 0;
  29         foreign_thread_sample_count = 0;
  30         atomic::fence();
  31 }
  32
  33 profiling_sample::profiling_sample(factor_vm *vm,
  34         bool prolog_p,
  35         profiling_sample_count const &counts,
  36         cell thread)
  37         :
  38         counts(counts),
  39         thread(thread)
  40 {
  41         vm->record_callstack_sample(&callstack_begin, &callstack_end, prolog_p);
  42 }
  43
  44 void factor_vm::record_sample(bool prolog_p)
  45 {
  46         profiling_sample_count counts = safepoint.sample_counts.record_counts();
  47         if (!counts.empty())
  48                 samples.push_back(profiling_sample(this, prolog_p,
  49                         counts, special_objects[OBJ_CURRENT_THREAD]));
  50 }
  51
  52 struct record_callstack_sample_iterator {
  53         std::vector<cell> *sample_callstacks;
  54         bool skip_p;
  55
  56         record_callstack_sample_iterator(std::vector<cell> *sample_callstacks, bool prolog_p)
  57                 : sample_callstacks(sample_callstacks), skip_p(prolog_p) {}
  58
  59         void operator()(void *frame_top, cell frame_size, code_block *owner, void *addr)
  60         {
  61                 if (skip_p)
  62                         skip_p = false;
  63                 else
  64                         sample_callstacks->push_back(owner->owner);
  65         }
  66 };
  67
  68 void factor_vm::record_callstack_sample(cell *begin, cell *end, bool prolog_p)
  69 {
  70         *begin = sample_callstacks.size();
  71
  72         record_callstack_sample_iterator recorder(&sample_callstacks, prolog_p);
  73         iterate_callstack(ctx, recorder);
  74
  75         *end = sample_callstacks.size();
  76
  77         std::reverse(sample_callstacks.begin() + *begin, sample_callstacks.end());
  78 }
  79
  80 void factor_vm::set_sampling_profiler(fixnum rate)
  81 {
  82         bool sampling_p = !!rate;
  83         if (sampling_p == !!atomic::load(&sampling_profiler_p))
  84                 return;
  85
  86         if (sampling_p)
  87                 start_sampling_profiler(rate);
  88         else
  89                 end_sampling_profiler();
  90 }
  91
  92 void factor_vm::clear_samples()
  93 {
  94         // Swapping into temporaries releases the vector's allocated storage,
  95         // whereas clear() would leave the allocation as-is
  96         std::vector<profiling_sample> sample_graveyard;
  97         std::vector<cell> sample_callstack_graveyard;
  98         samples.swap(sample_graveyard);
  99         sample_callstacks.swap(sample_callstack_graveyard);
 100 }
 101
 102 void factor_vm::start_sampling_profiler(fixnum rate)
 103 {
 104         samples_per_second = rate;
 105         safepoint.sample_counts.clear();
 106         clear_samples();
 107         samples.reserve(10*rate);
 108         sample_callstacks.reserve(100*rate);
 109         atomic::store(&sampling_profiler_p, true);
 110         start_sampling_profiler_timer();
 111 }
 112
 113 void factor_vm::end_sampling_profiler()
 114 {
 115         atomic::store(&sampling_profiler_p, false);
 116         end_sampling_profiler_timer();
 117         record_sample(false);
 118 }
 119
 120 void factor_vm::primitive_sampling_profiler()
 121 {
 122         set_sampling_profiler(to_fixnum(ctx->pop()));
 123 }
 124
 125 void factor_vm::primitive_get_samples()
 126 {
 127         if (atomic::load(&sampling_profiler_p) || samples.empty()) {
 128                 ctx->push(false_object);
 129         } else {
 130                 data_root<array> samples_array(allot_array(samples.size(), false_object),this);
 131                 std::vector<profiling_sample>::const_iterator from_iter = samples.begin();
 132                 cell to_i = 0;
 133
 134                 for (; from_iter != samples.end(); ++from_iter, ++to_i)
 135                 {
 136                         data_root<array> sample(allot_array(7, false_object),this);
 137
 138                         set_array_nth(sample.untagged(),0,tag_fixnum(from_iter->counts.sample_count));
 139                         set_array_nth(sample.untagged(),1,tag_fixnum(from_iter->counts.gc_sample_count));
 140                         set_array_nth(sample.untagged(),2,tag_fixnum(from_iter->counts.jit_sample_count));
 141                         set_array_nth(sample.untagged(),3,tag_fixnum(from_iter->counts.foreign_sample_count));
 142                         set_array_nth(sample.untagged(),4,tag_fixnum(from_iter->counts.foreign_thread_sample_count));
 143
 144                         set_array_nth(sample.untagged(),5,from_iter->thread);
 145
 146                         cell callstack_size = from_iter->callstack_end - from_iter->callstack_begin;
 147                         data_root<array> callstack(allot_array(callstack_size,false_object),this);
 148
 149                         std::vector<cell>::const_iterator
 150                                 callstacks_begin = sample_callstacks.begin(),
 151                                 c_from_iter = callstacks_begin + from_iter->callstack_begin,
 152                                 c_from_iter_end = callstacks_begin + from_iter->callstack_end;
 153                         cell c_to_i = 0;
 154
 155                         for (; c_from_iter != c_from_iter_end; ++c_from_iter, ++c_to_i)
 156                                 set_array_nth(callstack.untagged(),c_to_i,*c_from_iter);
 157
 158                         set_array_nth(sample.untagged(),6,callstack.value());
 159
 160                         set_array_nth(samples_array.untagged(),to_i,sample.value());
 161                 }
 162                 ctx->push(samples_array.value());
 163         }
 164 }
 165
 166 void factor_vm::primitive_clear_samples()
 167 {
 168         clear_samples();
 169 }
 170
 171 }