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.
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.
track_allocations: Whether to track object allocations while profiling. True or false.
exclude_common: Exclude common methods from the profile. True or false.
exclude_threads: Threads to exclude from the profiling results.
include_threads: Focus profiling on only the given threads. This will ignore
all other threads.
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 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 |
# File 'ext/ruby_prof/rp_profile.c', line 540
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);
rb_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);
rb_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
848 849 850 851 |
# File 'ext/ruby_prof/rp_profile.c', line 848
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:
880 881 882 883 884 885 |
# File 'ext/ruby_prof/rp_profile.c', line 880
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:
888 889 890 891 892 893 894 895 896 897 898 899 900 901 |
# File 'ext/ruby_prof/rp_profile.c', line 888
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 = prof_get_thread(thread);
rb_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.
858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 |
# File 'ext/ruby_prof/rp_profile.c', line 858
static VALUE prof_exclude_method(VALUE self, VALUE klass, VALUE msym)
{
prof_profile_t* profile = prof_get_profile(self);
if (profile->running == Qtrue)
{
rb_raise(rb_eRuntimeError, "RubyProf.start was already called");
}
st_data_t key = method_key(klass, msym);
prof_method_t* method = method_table_lookup(profile->exclude_methods_tbl, key);
if (!method)
{
method = prof_method_create(self, klass, msym, Qnil, 0);
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.
649 650 651 652 653 |
# File 'ext/ruby_prof/rp_profile.c', line 649
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.
711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 |
# File 'ext/ruby_prof/rp_profile.c', line 711
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);
rb_st_foreach(profile->threads_tbl, pause_thread, (st_data_t)profile);
}
return self;
}
|
#paused? ⇒ Boolean
Returns whether a profile is currently paused.
628 629 630 631 632 |
# File 'ext/ruby_prof/rp_profile.c', line 628
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
814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 |
# File 'ext/ruby_prof/rp_profile.c', line 814
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.
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 734
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);
rb_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.
638 639 640 641 642 643 |
# File 'ext/ruby_prof/rp_profile.c', line 638
static VALUE
prof_running(VALUE self)
{
prof_profile_t* profile = prof_get_profile(self);
return profile->running;
}
|
#start ⇒ self
Starts recording profile data.
669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 |
# File 'ext/ruby_prof/rp_profile.c', line 669
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.
756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 |
# File 'ext/ruby_prof/rp_profile.c', line 756
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.
795 796 797 798 799 800 801 |
# File 'ext/ruby_prof/rp_profile.c', line 795
static VALUE prof_threads(VALUE self)
{
VALUE result = rb_ary_new();
prof_profile_t* profile = prof_get_profile(self);
rb_st_foreach(profile->threads_tbl, collect_threads, result);
return result;
}
|
#track_allocations ⇒ Boolean
Returns if object allocations were tracked in this profile.
659 660 661 662 663 |
# File 'ext/ruby_prof/rp_profile.c', line 659
static VALUE prof_profile_track_allocations(VALUE self)
{
prof_profile_t* profile = prof_get_profile(self);
return profile->measurer->track_allocations ? Qtrue : Qfalse;
}
|