vm/sampling_profiler.cpp

   1 #include "master.hpp"
   2
   3 namespace factor {
   4
   5 // This is like the growable_array class, except the whole of it
   6 // exists on the Factor heap. growarr = growable array.
   7 static cell growarr_capacity(array *growarr) {
   8   return untag_fixnum(growarr->data()[0]);
   9 }
  10
  11 static cell growarr_nth(array *growarr, cell slot) {
  12   return array_nth(untag<array>(growarr->data()[1]), slot);
  13 }
  14
  15 // Allocates memory
  16 array* factor_vm::allot_growarr() {
  17   data_root<array> contents(allot_array(10, false_object), this);
  18   array *growarr = allot_uninitialized_array<array>(2);
  19   set_array_nth(growarr, 0, tag_fixnum(0));
  20   set_array_nth(growarr, 1, contents.value());
  21   return growarr;
  22 }
  23
  24 // Allocates memory
  25 void factor_vm::growarr_add(array *growarr_, cell elt_) {
  26   data_root<array> growarr(growarr_, this);
  27   data_root<object> elt(elt_, this);
  28   data_root<array> contents(growarr.untagged()->data()[1], this);
  29
  30   cell count = growarr_capacity(growarr.untagged());
  31   if (count == array_capacity(contents.untagged())) {
  32     contents.set_untagged(reallot_array(contents.untagged(), 2 * count));
  33     set_array_nth(growarr.untagged(), 1, contents.value());
  34   }
  35   set_array_nth(contents.untagged(), count, elt.value());
  36   set_array_nth(growarr.untagged(), 0, tag_fixnum(count + 1));
  37 }
  38
  39 profiling_sample profiling_sample::record_counts() volatile {
  40   atomic::fence();
  41   profiling_sample returned(sample_count, gc_sample_count,
  42                             jit_sample_count, foreign_sample_count,
  43                             foreign_thread_sample_count);
  44   atomic::fetch_subtract(&sample_count, returned.sample_count);
  45   atomic::fetch_subtract(&gc_sample_count, returned.gc_sample_count);
  46   atomic::fetch_subtract(&jit_sample_count, returned.jit_sample_count);
  47   atomic::fetch_subtract(&foreign_sample_count, returned.foreign_sample_count);
  48   atomic::fetch_subtract(&foreign_thread_sample_count,
  49                          returned.foreign_thread_sample_count);
  50   return returned;
  51 }
  52
  53 void profiling_sample::clear_counts() volatile {
  54   sample_count = 0;
  55   gc_sample_count = 0;
  56   jit_sample_count = 0;
  57   foreign_sample_count = 0;
  58   foreign_thread_sample_count = 0;
  59   atomic::fence();
  60 }
  61
  62 // Allocates memory (sample_callstacks2->add)
  63 void factor_vm::record_sample(bool prolog_p) {
  64   profiling_sample result = current_sample.record_counts();
  65   if (result.empty()) {
  66     return;
  67   }
  68   // Appends the callstack, which is just a sequence of quotation or
  69   // word references, to sample_callstacks.
  70   cell callstacks_cell = special_objects[OBJ_SAMPLE_CALLSTACKS];
  71   data_root<array> callstacks = data_root<array>(callstacks_cell, this);
  72   cell begin = growarr_capacity(callstacks.untagged());
  73
  74   bool skip_p = prolog_p;
  75   auto recorder = [&](cell frame_top, cell size, code_block* owner, cell addr) {
  76     if (skip_p)
  77       skip_p = false;
  78     else {
  79       growarr_add(callstacks.untagged(), owner->owner);
  80     }
  81   };
  82   iterate_callstack(ctx, recorder);
  83   cell end = growarr_capacity(callstacks.untagged());
  84
  85   // Add the sample.
  86   result.thread = special_objects[OBJ_CURRENT_THREAD];
  87   result.callstack_begin = begin;
  88   result.callstack_end = end;
  89   samples.push_back(result);
  90 }
  91
  92 void factor_vm::set_sampling_profiler(fixnum rate) {
  93   bool running_p = (atomic::load(&sampling_profiler_p) != 0);
  94   if (rate > 0 && !running_p)
  95     start_sampling_profiler(rate);
  96   else if (rate == 0 && running_p)
  97     end_sampling_profiler();
  98 }
  99
 100 void factor_vm::start_sampling_profiler(fixnum rate) {
 101   special_objects[OBJ_SAMPLE_CALLSTACKS] = tag<array>(allot_growarr());
 102   samples_per_second = rate;
 103   current_sample.clear_counts();
 104   // Release the memory consumed by collecting samples.
 105   samples.clear();
 106   samples.shrink_to_fit();
 107   samples.reserve(10 * rate);
 108   atomic::store(&sampling_profiler_p, true);
 109   start_sampling_profiler_timer();
 110 }
 111
 112 void factor_vm::end_sampling_profiler() {
 113   atomic::store(&sampling_profiler_p, false);
 114   end_sampling_profiler_timer();
 115   record_sample(false);
 116 }
 117
 118 void factor_vm::primitive_sampling_profiler() {
 119   set_sampling_profiler(to_fixnum(ctx->pop()));
 120 }
 121
 122 // Allocates memory
 123 void factor_vm::primitive_get_samples() {
 124   if (atomic::load(&sampling_profiler_p) || samples.empty()) {
 125     ctx->push(false_object);
 126     return;
 127   }
 128   data_root<array> samples_array(allot_array(samples.size(), false_object),
 129                                  this);
 130   std::vector<profiling_sample>::const_iterator from_iter = samples.begin();
 131   cell to_i = 0;
 132
 133   cell callstacks_cell = special_objects[OBJ_SAMPLE_CALLSTACKS];
 134   data_root<array> callstacks = data_root<array>(callstacks_cell, this);
 135
 136   for (; from_iter != samples.end(); ++from_iter, ++to_i) {
 137     data_root<array> sample(allot_array(7, false_object), this);
 138
 139     set_array_nth(sample.untagged(), 0,
 140                   tag_fixnum(from_iter->sample_count));
 141     set_array_nth(sample.untagged(), 1,
 142                   tag_fixnum(from_iter->gc_sample_count));
 143     set_array_nth(sample.untagged(), 2,
 144                   tag_fixnum(from_iter->jit_sample_count));
 145     set_array_nth(sample.untagged(), 3,
 146                   tag_fixnum(from_iter->foreign_sample_count));
 147     set_array_nth(sample.untagged(), 4,
 148                   tag_fixnum(from_iter->foreign_thread_sample_count));
 149
 150     set_array_nth(sample.untagged(), 5, from_iter->thread);
 151
 152     cell callstack_size =
 153         from_iter->callstack_end - from_iter->callstack_begin;
 154     data_root<array> callstack(allot_array(callstack_size, false_object),
 155                                this);
 156
 157     for (cell i = 0; i < callstack_size; i++) {
 158       cell block_owner = growarr_nth(callstacks.untagged(),
 159                                      from_iter->callstack_begin + i);
 160       set_array_nth(callstack.untagged(), i, block_owner);
 161     }
 162     set_array_nth(sample.untagged(), 6, callstack.value());
 163     set_array_nth(samples_array.untagged(), to_i, sample.value());
 164   }
 165   ctx->push(samples_array.value());
 166 }
 167
 168 }