Module: StackProfx

Defined in:

ext/stackprofx.c

Class Method Summary

• .results(*args) ⇒ Object
• .run(*args) ⇒ Object
• .running? ⇒ Boolean
• .sample ⇒ Object
• .start(*args) ⇒ Object
• .stop ⇒ Object

Class Method Details

.results(*args) ⇒ Object

# File 'ext/stackprofx.c', line 263

static VALUE
stackprofx_results(int argc, VALUE *argv, VALUE self)
{
    VALUE results, frames;

    if (!_stackprofx.frames || _stackprofx.running)
  return Qnil;

    results = rb_hash_new();
    rb_hash_aset(results, sym_version, DBL2NUM(1.1));
    rb_hash_aset(results, sym_mode, _stackprofx.mode);
    rb_hash_aset(results, sym_interval, _stackprofx.interval);
    rb_hash_aset(results, sym_samples, SIZET2NUM(_stackprofx.overall_samples));
    rb_hash_aset(results, sym_gc_samples, SIZET2NUM(_stackprofx.during_gc));
    rb_hash_aset(results, sym_missed_samples, SIZET2NUM(_stackprofx.overall_signals - _stackprofx.overall_samples));

    frames = rb_hash_new();
    rb_hash_aset(results, sym_frames, frames);
    st_foreach(_stackprofx.frames, frame_i, (st_data_t)frames);

    st_free_table(_stackprofx.frames);
    _stackprofx.frames = NULL;

    if (_stackprofx.raw && _stackprofx.raw_samples_len) {
  size_t len, n, o;
  VALUE raw_samples = rb_ary_new_capa(_stackprofx.raw_samples_len);

  for (n = 0; n < _stackprofx.raw_samples_len; n++) {
      len = (size_t)_stackprofx.raw_samples[n];
      rb_ary_push(raw_samples, SIZET2NUM(len));

      for (o = 0, n++; o < len; n++, o++)
    rb_ary_push(raw_samples, rb_obj_id(_stackprofx.raw_samples[n]));
      rb_ary_push(raw_samples, SIZET2NUM((size_t)_stackprofx.raw_samples[n]));
  }

  free(_stackprofx.raw_samples);
  _stackprofx.raw_samples = NULL;
  _stackprofx.raw_samples_len = 0;
  _stackprofx.raw_samples_capa = 0;
  _stackprofx.raw_sample_index = 0;
  _stackprofx.raw = 0;

  rb_hash_aset(results, sym_raw, raw_samples);
    }

    if (argc == 1)
  _stackprofx.out = argv[0];

    if (RTEST(_stackprofx.out)) {
  VALUE file;
  if (RB_TYPE_P(_stackprofx.out, T_STRING)) {
      file = rb_file_open_str(_stackprofx.out, "w");
  } else {
      file = rb_io_check_io(_stackprofx.out);
  }
  rb_marshal_dump(results, file);
  rb_io_flush(file);
  _stackprofx.out = Qnil;
  return file;
    } else {
  return results;
    }
}

.run(*args) ⇒ Object

# File 'ext/stackprofx.c', line 328

static VALUE
stackprofx_run(int argc, VALUE *argv, VALUE self)
{
    rb_need_block();
    stackprofx_start(argc, argv, self);
    rb_ensure(rb_yield, Qundef, stackprofx_stop, self);
    return stackprofx_results(0, 0, self);
}

.running? ⇒ Boolean

Returns:

• (Boolean)

# File 'ext/stackprofx.c', line 337

static VALUE
stackprofx_running_p(VALUE self)
{
    return _stackprofx.running ? Qtrue : Qfalse;
}

.sample ⇒ Object

# File 'ext/stackprofx.c', line 522

static VALUE
stackprofx_sample(VALUE self)
{
    if (!_stackprofx.running)
  return Qfalse;

    _stackprofx.overall_signals++;
    stackprofx_job_handler(0);
    return Qtrue;
}

.start(*args) ⇒ Object

# File 'ext/stackprofx.c', line 81

static VALUE
stackprofx_start(int argc, VALUE *argv, VALUE self)
{
    struct sigaction sa;
    struct itimerval timer;
    VALUE opts = Qnil, mode = Qnil, interval = Qnil, out = Qfalse, threads = Qnil;
    int raw = 0, aggregate = 1;

    if (_stackprofx.running)
  return Qfalse;

    rb_scan_args(argc, argv, "0:", &opts);

    if (RTEST(opts)) {
  mode = rb_hash_aref(opts, sym_mode);
  interval = rb_hash_aref(opts, sym_interval);
  out = rb_hash_aref(opts, sym_out);
  threads = rb_hash_aref(opts, sym_threads);

  if (RTEST(rb_hash_aref(opts, sym_raw)))
      raw = 1;
  if (rb_hash_lookup2(opts, sym_aggregate, Qundef) == Qfalse)
      aggregate = 0;
    }
    if (!RTEST(mode)) mode = sym_wall;

  if (RTEST(threads))
  {
    _stackprofx.threads = st_init_numtable();
    for (int i = 0; i < RARRAY_LEN(threads); i++)
    {
        VALUE thr = rb_ary_entry(threads, i);
        st_add_direct(_stackprofx.threads, thr, 0);
        rb_gc_mark(thr);
    }
  }
  else
  {
      _stackprofx.threads = 0;
  }

    if (!_stackprofx.frames) {
  _stackprofx.frames = st_init_numtable();
  _stackprofx.overall_signals = 0;
  _stackprofx.overall_samples = 0;
  _stackprofx.during_gc = 0;
    }

    if (mode == sym_object) {
  if (!RTEST(interval)) interval = INT2FIX(1);

  objtracer = rb_tracepoint_new(Qnil, RUBY_INTERNAL_EVENT_NEWOBJ, stackprofx_newobj_handler, 0);
  rb_tracepoint_enable(objtracer);
    } else if (mode == sym_wall || mode == sym_cpu) {
  if (!RTEST(interval)) interval = INT2FIX(1000);

  sa.sa_sigaction = stackprofx_signal_handler;
  sa.sa_flags = SA_RESTART | SA_SIGINFO;
  sigemptyset(&sa.sa_mask);
  sigaction(mode == sym_wall ? SIGALRM : SIGPROF, &sa, NULL);

  timer.it_interval.tv_sec = 0;
  timer.it_interval.tv_usec = NUM2LONG(interval);
  timer.it_value = timer.it_interval;
  setitimer(mode == sym_wall ? ITIMER_REAL : ITIMER_PROF, &timer, 0);
    } else if (mode == sym_custom) {
  /* sampled manually */
  interval = Qnil;
    } else {
  rb_raise(rb_eArgError, "unknown profiler mode");
    }

    _stackprofx.running = 1;
    _stackprofx.raw = raw;
    _stackprofx.aggregate = aggregate;
    _stackprofx.mode = mode;
    _stackprofx.interval = interval;
    _stackprofx.out = out;

    return Qtrue;
}

.stop ⇒ Object

# File 'ext/stackprofx.c', line 163

static VALUE
stackprofx_stop(VALUE self)
{
    struct sigaction sa;
    struct itimerval timer;

    if (!_stackprofx.running)
  return Qfalse;
    _stackprofx.running = 0;

    st_free_table(_stackprofx.threads);

    if (_stackprofx.mode == sym_object) {
  rb_tracepoint_disable(objtracer);
    } else if (_stackprofx.mode == sym_wall || _stackprofx.mode == sym_cpu) {
  memset(&timer, 0, sizeof(timer));
  setitimer(_stackprofx.mode == sym_wall ? ITIMER_REAL : ITIMER_PROF, &timer, 0);

  sa.sa_handler = SIG_IGN;
  sa.sa_flags = SA_RESTART;
  sigemptyset(&sa.sa_mask);
  sigaction(_stackprofx.mode == sym_wall ? SIGALRM : SIGPROF, &sa, NULL);
    } else if (_stackprofx.mode == sym_custom) {
  /* sampled manually */
    } else {
  rb_raise(rb_eArgError, "unknown profiler mode");
    }

    return Qtrue;
}