vm/safepoints.cpp

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