Class: RubyProf::Profile
- Inherits:
-
Object
- Object
- RubyProf::Profile
- Defined in:
- ext/ruby_prof/rp_profile.c,
lib/ruby-prof/profile.rb,
ext/ruby_prof/rp_profile.c
Overview
The Profile class represents a single profiling run and provides the main API for using ruby-prof. After creating a Profile instance, start profiling code by calling the Profile#start method. To finish profiling, call Profile#stop. Once profiling is completed, the Profile instance contains the results.
profile = RubyProf::Profile.new
profile.start
...
result = profile.stop
Alternatively, you can use the block syntax:
profile = RubyProf::Profile.profile do
...
end
Class Method Summary collapse
-
.profile(*args) ⇒ Object
call-seq: profile(&block) -> RubyProf::Profile profile(options, &block) -> RubyProf::Profile.
Instance Method Summary collapse
-
#_dump_data ⇒ Object
:nodoc:.
-
#_load_data(data) ⇒ Object
:nodoc:.
-
#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! ⇒ self
Excludes the method from profiling results.
- #exclude_methods!(mod, *method_or_methods) ⇒ Object
- #exclude_singleton_methods!(mod, *method_or_methods) ⇒ Object
-
#initialize(*args) ⇒ Object
constructor
Returns a new profiler.
-
#mode ⇒ Object
Returns the measure mode used in this profile.
-
#measure_mode_string ⇒ Object
:nodoc:.
-
#pause ⇒ self
Pauses collecting profile data.
-
#paused? ⇒ Boolean
Returns whether a profile is currently paused.
-
#profile ⇒ Object
call-seq: profile(&block) -> self.
-
#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 profiled.
-
#track_allocations ⇒ Boolean
Returns if object allocations were tracked in this profile.
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.
allow_exceptions:: Whether to raise exceptions encountered during profiling,
or to suppress all exceptions during profiling
merge_fibers:: Whether profiling data for a given thread's fibers should all be
subsumed under a single entry. Basically only useful to produce
callgrind profiles.
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 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 |
# File 'ext/ruby_prof/rp_profile.c', line 494
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 exclude_common = Qnil;
VALUE allow_exceptions = Qfalse;
VALUE merge_fibers = Qfalse;
VALUE track_allocations = Qfalse;
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")));
track_allocations = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("track_allocations")));
allow_exceptions = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("allow_exceptions")));
merge_fibers = rb_hash_aref(mode_or_options, ID2SYM(rb_intern("merge_fibers")));
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), track_allocations == Qtrue);
profile->allow_exceptions = (allow_exceptions == Qtrue);
profile->merge_fibers = (merge_fibers == Qtrue);
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);
st_insert(profile->exclude_threads_tbl, thread, 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);
st_insert(profile->include_threads_tbl, thread, Qtrue);
}
}
if (RTEST(exclude_common))
{
prof_exclude_common_methods(self);
}
return self;
}
|
Class Method Details
.profile(*args) ⇒ Object
call-seq:
profile(&block) -> RubyProf::Profile
profile(options, &block) -> RubyProf::Profile
Profiles the specified block and returns a RubyProf::Profile
object. Arguments are passed to Profile initialize method.
profile = RubyProf::Profile.profile do
..
end
812 813 814 815 816 |
# File 'ext/ruby_prof/rp_profile.c', line 812
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
#_dump_data ⇒ Object
:nodoc:
848 849 850 851 852 853 |
# File 'ext/ruby_prof/rp_profile.c', line 848
VALUE prof_profile_dump(VALUE self)
{
VALUE result = rb_hash_new();
rb_hash_aset(result, ID2SYM(rb_intern("threads")), prof_threads(self));
return result;
}
|
#_load_data(data) ⇒ Object
:nodoc:
856 857 858 859 860 861 862 863 864 865 866 867 868 869 |
# File 'ext/ruby_prof/rp_profile.c', line 856
VALUE prof_profile_load(VALUE self, VALUE data)
{
prof_profile_t* profile = prof_get_profile(self);
VALUE threads = rb_hash_aref(data, ID2SYM(rb_intern("threads")));
for (int i = 0; i < rb_array_len(threads); i++)
{
VALUE thread = rb_ary_entry(threads, i);
thread_data_t* thread_data = DATA_PTR(thread);
st_insert(profile->threads_tbl, (st_data_t)thread_data->fiber_id, (st_data_t)thread_data);
}
return data;
}
|
#exclude_common_methods! ⇒ Object
Hides methods that, when represented as a call graph, have extremely large in and out degrees and make navigation impossible.
19 20 21 |
# File 'lib/ruby-prof/profile.rb', line 19 def exclude_common_methods! ExcludeCommonMethods.apply!(self) end |
#exclude_method! ⇒ self
Excludes the method from profiling results.
823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 |
# File 'ext/ruby_prof/rp_profile.c', line 823
static VALUE
prof_exclude_method(VALUE self, VALUE klass, VALUE msym)
{
prof_profile_t* profile = prof_get_profile(self);
st_data_t key = method_key(klass, msym);
prof_method_t *method;
if (profile->running == Qtrue)
{
rb_raise(rb_eRuntimeError, "RubyProf.start was already called");
}
method = method_table_lookup(profile->exclude_methods_tbl, key);
if (!method)
{
method = prof_method_create_excluded(klass, msym);
method_table_insert(profile->exclude_methods_tbl, method->key, method);
}
return self;
}
|
#exclude_methods!(mod, *method_or_methods) ⇒ Object
23 24 25 26 27 |
# File 'lib/ruby-prof/profile.rb', line 23 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
29 30 31 |
# File 'lib/ruby-prof/profile.rb', line 29 def exclude_singleton_methods!(mod, *method_or_methods) exclude_methods!(mod.singleton_class, *method_or_methods) end |
#mode ⇒ Object
Returns the measure mode used in this profile.
605 606 607 608 609 610 |
# File 'ext/ruby_prof/rp_profile.c', line 605
static VALUE
prof_profile_measure_mode(VALUE self)
{
prof_profile_t* profile = prof_get_profile(self);
return INT2NUM(profile->measurer->mode);
}
|
#measure_mode_string ⇒ Object
:nodoc:
8 9 10 11 12 13 14 15 |
# File 'lib/ruby-prof/profile.rb', line 8 def measure_mode_string case self.measure_mode when WALL_TIME then "wall_time" when PROCESS_TIME then "process_time" when ALLOCATIONS then "allocations" when MEMORY then "memory" end end |
#pause ⇒ self
Pauses collecting profile data.
669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 |
# File 'ext/ruby_prof/rp_profile.c', line 669
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 = prof_measure(profile->measurer, NULL);
st_foreach(profile->threads_tbl, pause_thread, (st_data_t) profile);
}
return self;
}
|
#paused? ⇒ Boolean
Returns whether a profile is currently paused.
583 584 585 586 587 588 |
# File 'ext/ruby_prof/rp_profile.c', line 583
static VALUE
prof_paused(VALUE self)
{
prof_profile_t* profile = prof_get_profile(self);
return profile->paused;
}
|
#profile ⇒ Object
call-seq:
profile(&block) -> self
Profiles the specified block.
profile = RubyProf::Profile.new
profile.profile do
..
end
776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 |
# File 'ext/ruby_prof/rp_profile.c', line 776
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.
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 |
# File 'ext/ruby_prof/rp_profile.c', line 693
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 = prof_measure(profile->measurer, NULL);
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.
594 595 596 597 598 599 |
# File 'ext/ruby_prof/rp_profile.c', line 594
static VALUE
prof_running(VALUE self)
{
prof_profile_t* profile = prof_get_profile(self);
return profile->running;
}
|
#start ⇒ self
Starts recording profile data.
627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 |
# File 'ext/ruby_prof/rp_profile.c', line 627
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 = threads_table_insert(profile, get_fiber(profile));
/* 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.
716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 |
# File 'ext/ruby_prof/rp_profile.c', line 716
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_stop_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 profiled.
756 757 758 759 760 761 762 763 |
# File 'ext/ruby_prof/rp_profile.c', line 756
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;
}
|
#track_allocations ⇒ Boolean
Returns if object allocations were tracked in this profile.
616 617 618 619 620 621 |
# File 'ext/ruby_prof/rp_profile.c', line 616
static VALUE
prof_profile_track_allocations(VALUE self)
{
prof_profile_t* profile = prof_get_profile(self);
return profile->measurer->track_allocations ? Qtrue : Qfalse;
}
|