vm/safepoints.cpp

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