vm/safepoints.cpp

   1 #include "master.hpp"
   2
   3 namespace factor {
   4
   5 void safepoint_state::enqueue_fep(factor_vm* parent) volatile {
   6   if (parent->fep_p)
   7     fatal_error("Low-level debugger interrupted", 0);
   8   atomic::store(&fep_p, true);
   9   parent->code->set_safepoint_guard(true);
  10 }
  11
  12 void safepoint_state::enqueue_samples(factor_vm* parent,
  13                                       cell samples,
  14                                       cell pc,
  15                                       bool foreign_thread_p) volatile {
  16
  17   if (!atomic::load(&parent->sampling_profiler_p))
  18     return;
  19   atomic::fetch_add(&sample_counts.sample_count, samples);
  20
  21   if (foreign_thread_p)
  22     atomic::fetch_add(&sample_counts.foreign_thread_sample_count, samples);
  23   else {
  24     if (atomic::load(&parent->current_gc_p))
  25       atomic::fetch_add(&sample_counts.gc_sample_count, samples);
  26     if (atomic::load(&parent->current_jit_count) > 0)
  27       atomic::fetch_add(&sample_counts.jit_sample_count, samples);
  28     if (!parent->code->seg->in_segment_p(pc))
  29       atomic::fetch_add(&sample_counts.foreign_sample_count, samples);
  30   }
  31   parent->code->set_safepoint_guard(true);
  32 }
  33
  34 void safepoint_state::handle_safepoint(factor_vm* parent, cell pc) volatile {
  35   parent->code->set_safepoint_guard(false);
  36   parent->faulting_p = false;
  37
  38   if (atomic::load(&fep_p)) {
  39     if (atomic::load(&parent->sampling_profiler_p))
  40       parent->end_sampling_profiler();
  41     std::cout << "Interrupted\n";
  42     parent->factorbug();
  43     atomic::store(&fep_p, false);
  44   } else if (atomic::load(&parent->sampling_profiler_p)) {
  45     FACTOR_ASSERT(parent->code->seg->in_segment_p(pc));
  46     code_block* block = parent->code->code_block_for_address(pc);
  47     bool prolog_p = block->entry_point() == pc;
  48
  49     parent->record_sample(prolog_p);
  50   }
  51 }
  52
  53 }