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