Class: RubyProf::Profile
- Inherits:
-
Object
- Object
- RubyProf::Profile
- Includes:
- LegacyMethodElimination
- Defined in:
- lib/ruby-prof/profile.rb,
lib/ruby-prof/profile/exclude_common_methods.rb,
lib/ruby-prof/profile/legacy_method_elimination.rb,
ext/ruby_prof/ruby_prof.c
Defined Under Namespace
Modules: LegacyMethodElimination Classes: ExcludeCommonMethods
Class Method Summary collapse
-
.profile(*args) ⇒ Object
Profiles the specified block and returns a RubyProf::Profile object.
Instance Method Summary collapse
-
#exclude_common_methods! ⇒ Object
Hides methods that, when represented as a call graph, have extremely large in and out degrees and make navigation impossible.
- #exclude_method!(klass, sym) ⇒ Object
- #exclude_methods!(mod, *method_or_methods) ⇒ Object
- #exclude_singleton_methods!(mod, *method_or_methods) ⇒ Object
-
#initialize(*args) ⇒ Object
constructor
Returns a new profiler.
-
#pause ⇒ self
Pauses collecting profile data.
-
#paused? ⇒ Boolean
Returns whether a profile is currently paused.
-
#profile { ... } ⇒ RubyProf::Result
Profiles the specified block and returns a RubyProf::Result object.
-
#resume ⇒ Object
Resumes recording profile data.
-
#running? ⇒ Boolean
Returns whether a profile is currently running.
-
#start ⇒ self
Starts recording profile data.
-
#stop ⇒ self
Stops collecting profile data.
-
#threads ⇒ Array of RubyProf::Thread
Returns an array of RubyProf::Thread instances that were executed while the the program was being run.
Methods included from LegacyMethodElimination
Constructor Details
#new ⇒ Object #new(options) ⇒ Object
Returns a new profiler. Possible options for the options hash are:
measure_mode:: Measure mode. Specifies the profile measure mode.
If not specified, defaults to RubyProf::WALL_TIME.
exclude_threads:: Threads to exclude from the profiling results.
include_threads:: Focus profiling on only the given threads. This will ignore
all other threads.
merge_fibers:: Whether to merge all fibers under a given thread. This should be
used when profiling for a callgrind printer.
allow_exceptions:: Whether to raise exceptions encountered during profiling,
or to suppress all exceptions during profiling
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 |
# File 'ext/ruby_prof/ruby_prof.c', line 450
static VALUE
prof_initialize(int argc, VALUE *argv, VALUE self)
{
prof_profile_t* profile = prof_get_profile(self);
VALUE mode_or_options;
VALUE mode = Qnil;
VALUE exclude_threads = Qnil;
VALUE include_threads = Qnil;
VALUE merge_fibers = Qnil;
VALUE exclude_common = Qnil;
VALUE allow_exceptions = Qnil;
int i;
switch (rb_scan_args(argc, argv, "02", &mode_or_options, &exclude_threads))
{
case 0:
break;
case 1:
if (FIXNUM_P(mode_or_options))
{
mode = mode_or_options;
}
else
{
Check_Type(mode_or_options, T_HASH);
mode = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("measure_mode")));
merge_fibers = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("merge_fibers")));
allow_exceptions = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("allow_exceptions")));
exclude_common = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("exclude_common")));
exclude_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("exclude_threads")));
include_threads = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("include_threads")));
}
break;
case 2:
Check_Type(exclude_threads, T_ARRAY);
break;
}
if (mode == Qnil)
{
mode = INT2NUM(MEASURE_WALL_TIME);
}
else
{
Check_Type(mode, T_FIXNUM);
}
profile->measurer = prof_get_measurer(NUM2INT(mode));
profile->merge_fibers = merge_fibers != Qnil && merge_fibers != Qfalse;
profile->allow_exceptions = allow_exceptions != Qnil && allow_exceptions != Qfalse;
if (exclude_threads != Qnil)
{
Check_Type(exclude_threads, T_ARRAY);
assert(profile->exclude_threads_tbl == NULL);
profile->exclude_threads_tbl = threads_table_create();
for (i = 0; i < RARRAY_LEN(exclude_threads); i++)
{
VALUE thread = rb_ary_entry(exclude_threads, i);
VALUE thread_id = rb_obj_id(thread);
unsigned LONG_LONG thread_value = NUM2ULL(thread_id);
st_insert(profile->exclude_threads_tbl, thread_value, Qtrue);
}
}
if (include_threads != Qnil)
{
Check_Type(include_threads, T_ARRAY);
assert(profile->include_threads_tbl == NULL);
profile->include_threads_tbl = threads_table_create();
for (i = 0; i < RARRAY_LEN(include_threads); i++)
{
VALUE thread = rb_ary_entry(include_threads, i);
VALUE thread_id = rb_obj_id(thread);
unsigned LONG_LONG thread_value = NUM2ULL(thread_id);
st_insert(profile->include_threads_tbl, thread_value, Qtrue);
}
}
if (RTEST(exclude_common)) {
prof_exclude_common_methods(self);
}
return self;
}
|
Class Method Details
.profile(&block) ⇒ self .profile(options, &block) ⇒ self
Profiles the specified block and returns a RubyProf::Profile object. Arguments are passed to Profile initialize method.
736 737 738 739 740 |
# File 'ext/ruby_prof/ruby_prof.c', line 736
static VALUE
prof_profile_class(int argc, VALUE *argv, VALUE klass)
{
return prof_profile_object(rb_class_new_instance(argc, argv, cProfile));
}
|
Instance Method Details
#exclude_common_methods! ⇒ Object
Hides methods that, when represented as a call graph, have extremely large in and out degrees and make navigation impossible.
12 13 14 |
# File 'lib/ruby-prof/profile.rb', line 12 def exclude_common_methods! ExcludeCommonMethods.apply!(self) end |
#exclude_method!(klass, sym) ⇒ Object
742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 |
# File 'ext/ruby_prof/ruby_prof.c', line 742
static VALUE
prof_exclude_method(VALUE self, VALUE klass, VALUE sym)
{
prof_profile_t* profile = prof_get_profile(self);
ID mid = SYM2ID(sym);
prof_method_key_t key;
prof_method_t *method;
if (profile->running == Qtrue)
{
rb_raise(rb_eRuntimeError, "RubyProf.start was already called");
}
method_key(&key, klass, mid);
method = method_table_lookup(profile->exclude_methods_tbl, &key);
if (!method) {
method = prof_method_create_excluded(klass, mid);
method_table_insert(profile->exclude_methods_tbl, method->key, method);
}
return self;
}
|
#exclude_methods!(mod, *method_or_methods) ⇒ Object
16 17 18 19 20 |
# File 'lib/ruby-prof/profile.rb', line 16 def exclude_methods!(mod, *method_or_methods) [method_or_methods].flatten.each do |name| exclude_method!(mod, name) end end |
#exclude_singleton_methods!(mod, *method_or_methods) ⇒ Object
22 23 24 |
# File 'lib/ruby-prof/profile.rb', line 22 def exclude_singleton_methods!(mod, *method_or_methods) exclude_methods!(mod.singleton_class, *method_or_methods) end |
#pause ⇒ self
Pauses collecting profile data.
604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 |
# File 'ext/ruby_prof/ruby_prof.c', line 604
static VALUE
prof_pause(VALUE self)
{
prof_profile_t* profile = prof_get_profile(self);
if (profile->running == Qfalse)
{
rb_raise(rb_eRuntimeError, "RubyProf is not running.");
}
if (profile->paused == Qfalse)
{
profile->paused = Qtrue;
profile->measurement_at_pause_resume = profile->measurer->measure();
st_foreach(profile->threads_tbl, pause_thread, (st_data_t) profile);
}
return self;
}
|
#paused? ⇒ Boolean
Returns whether a profile is currently paused.
539 540 541 542 543 544 |
# File 'ext/ruby_prof/ruby_prof.c', line 539
static VALUE
prof_paused(VALUE self)
{
prof_profile_t* profile = prof_get_profile(self);
return profile->paused;
}
|
#profile { ... } ⇒ RubyProf::Result
Profiles the specified block and returns a RubyProf::Result object.
705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 |
# File 'ext/ruby_prof/ruby_prof.c', line 705
static VALUE
prof_profile_object(VALUE self)
{
int result;
prof_profile_t* profile = prof_get_profile(self);
if (!rb_block_given_p())
{
rb_raise(rb_eArgError, "A block must be provided to the profile method.");
}
prof_start(self);
rb_protect(rb_yield, self, &result);
self = prof_stop(self);
if (profile->allow_exceptions && result != 0)
{
rb_jump_tag(result);
}
return self;
}
|
#resume ⇒ self #resume(&block) ⇒ self
Resumes recording profile data.
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 |
# File 'ext/ruby_prof/ruby_prof.c', line 628
static VALUE
prof_resume(VALUE self)
{
prof_profile_t* profile = prof_get_profile(self);
if (profile->running == Qfalse)
{
rb_raise(rb_eRuntimeError, "RubyProf is not running.");
}
if (profile->paused == Qtrue)
{
profile->paused = Qfalse;
profile->measurement_at_pause_resume = profile->measurer->measure();
st_foreach(profile->threads_tbl, unpause_thread, (st_data_t) profile);
}
return rb_block_given_p() ? rb_ensure(rb_yield, self, prof_pause, self) : self;
}
|
#running? ⇒ Boolean
Returns whether a profile is currently running.
550 551 552 553 554 555 |
# File 'ext/ruby_prof/ruby_prof.c', line 550
static VALUE
prof_running(VALUE self)
{
prof_profile_t* profile = prof_get_profile(self);
return profile->running;
}
|
#start ⇒ self
Starts recording profile data.
561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 |
# File 'ext/ruby_prof/ruby_prof.c', line 561
static VALUE
prof_start(VALUE self)
{
char* trace_file_name;
prof_profile_t* profile = prof_get_profile(self);
if (profile->running == Qtrue)
{
rb_raise(rb_eRuntimeError, "RubyProf.start was already called");
}
profile->running = Qtrue;
profile->paused = Qfalse;
profile->last_thread_data = NULL;
/* open trace file if environment wants it */
trace_file_name = getenv("RUBY_PROF_TRACE");
if (trace_file_name != NULL)
{
if (strcmp(trace_file_name, "stdout") == 0)
{
trace_file = stdout;
}
else if (strcmp(trace_file_name, "stderr") == 0)
{
trace_file = stderr;
}
else
{
trace_file = fopen(trace_file_name, "w");
}
}
prof_install_hook(self);
return self;
}
|
#stop ⇒ self
Stops collecting profile data.
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 |
# File 'ext/ruby_prof/ruby_prof.c', line 651
static VALUE
prof_stop(VALUE self)
{
prof_profile_t* profile = prof_get_profile(self);
if (profile->running == Qfalse)
{
rb_raise(rb_eRuntimeError, "RubyProf.start was not yet called");
}
prof_remove_hook(self);
/* close trace file if open */
if (trace_file != NULL)
{
if (trace_file !=stderr && trace_file != stdout)
{
#ifdef _MSC_VER
_fcloseall();
#else
fclose(trace_file);
#endif
}
trace_file = NULL;
}
prof_pop_threads(profile);
/* Unset the last_thread_data (very important!)
and the threads table */
profile->running = profile->paused = Qfalse;
profile->last_thread_data = NULL;
return self;
}
|
#threads ⇒ Array of RubyProf::Thread
Returns an array of RubyProf::Thread instances that were executed while the the program was being run.
692 693 694 695 696 697 698 699 |
# File 'ext/ruby_prof/ruby_prof.c', line 692
static VALUE
prof_threads(VALUE self)
{
VALUE result = rb_ary_new();
prof_profile_t* profile = prof_get_profile(self);
st_foreach(profile->threads_tbl, collect_threads, result);
return result;
}
|