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
  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     (void)frame_top;
  77     (void)size;
  78     (void)addr;
  79     if (skip_p)
  80       skip_p = false;
  81     else {
  82       growarr_add(callstacks.untagged(), owner->owner);
  83     }
  84   };
  85   iterate_callstack(ctx, recorder);
  86   cell end = growarr_capacity(callstacks.untagged());
  87
  88   // Add the sample.
  89   result.thread = special_objects[OBJ_CURRENT_THREAD];
  90   result.callstack_begin = begin;
  91   result.callstack_end = end;
  92   samples.push_back(result);
  93 }
  94
  95 // Allocates memory
  96 void factor_vm::set_profiling(fixnum rate) {
  97   bool running_p = atomic::load(&sampling_profiler_p);
  98   if (rate > 0 && !running_p)
  99     start_sampling_profiler(rate);
 100   else if (rate == 0 && running_p)
 101     end_sampling_profiler();
 102 }
 103
 104 // Allocates memory
 105 void factor_vm::start_sampling_profiler(fixnum rate) {
 106   special_objects[OBJ_SAMPLE_CALLSTACKS] = tag<array>(allot_growarr());
 107   samples_per_second = rate;
 108   current_sample.clear_counts();
 109   // Release the memory consumed by collecting samples.
 110   samples.clear();
 111   samples.shrink_to_fit();
 112   samples.reserve(10 * rate);
 113   atomic::store(&sampling_profiler_p, true);
 114   start_sampling_profiler_timer();
 115 }
 116
 117 void factor_vm::end_sampling_profiler() {
 118   atomic::store(&sampling_profiler_p, false);
 119   end_sampling_profiler_timer();
 120   record_sample(false);
 121 }
 122
 123 // Allocates memory
 124 void factor_vm::primitive_set_profiling() {
 125   set_profiling(to_fixnum(ctx->pop()));
 126 }
 127
 128 // Allocates memory
 129 void factor_vm::primitive_get_samples() {
 130   if (atomic::load(&sampling_profiler_p) || samples.empty()) {
 131     ctx->push(false_object);
 132     return;
 133   }
 134   data_root<array> samples_array(allot_array(samples.size(), false_object),
 135                                  this);
 136   std::vector<profiling_sample>::const_iterator from_iter = samples.begin();
 137   cell to_i = 0;
 138
 139   cell callstacks_cell = special_objects[OBJ_SAMPLE_CALLSTACKS];
 140   data_root<array> callstacks = data_root<array>(callstacks_cell, this);
 141
 142   for (; from_iter != samples.end(); ++from_iter, ++to_i) {
 143     data_root<array> sample(allot_array(7, false_object), this);
 144
 145     set_array_nth(sample.untagged(), 0,
 146                   tag_fixnum(from_iter->sample_count));
 147     set_array_nth(sample.untagged(), 1,
 148                   tag_fixnum(from_iter->gc_sample_count));
 149     set_array_nth(sample.untagged(), 2,
 150                   tag_fixnum(from_iter->jit_sample_count));
 151     set_array_nth(sample.untagged(), 3,
 152                   tag_fixnum(from_iter->foreign_sample_count));
 153     set_array_nth(sample.untagged(), 4,
 154                   tag_fixnum(from_iter->foreign_thread_sample_count));
 155
 156     set_array_nth(sample.untagged(), 5, from_iter->thread);
 157
 158     cell callstack_size =
 159         from_iter->callstack_end - from_iter->callstack_begin;
 160     data_root<array> callstack(allot_array(callstack_size, false_object),
 161                                this);
 162
 163     for (cell i = 0; i < callstack_size; i++) {
 164       cell block_owner = growarr_nth(callstacks.untagged(),
 165                                      from_iter->callstack_begin + i);
 166       set_array_nth(callstack.untagged(), i, block_owner);
 167     }
 168     set_array_nth(sample.untagged(), 6, callstack.value());
 169     set_array_nth(samples_array.untagged(), to_i, sample.value());
 170   }
 171   ctx->push(samples_array.value());
 172 }
 173
 174 }