ruby-changes:26704
From: tenderlove <ko1@a...>
Date: Thu, 10 Jan 2013 11:16:18 +0900 (JST)
Subject: [ruby-changes:26704] tenderlove:r38755 (trunk): * probes.d: updating probes to be more symmetrical, adding
tenderlove 2013-01-10 11:16:00 +0900 (Thu, 10 Jan 2013) New Revision: 38755 http://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=rev&revision=38755 Log: * probes.d: updating probes to be more symmetrical, adding documentation. * load.c: ditto Modified files: trunk/ChangeLog trunk/load.c trunk/probes.d Index: ChangeLog =================================================================== --- ChangeLog (revision 38754) +++ ChangeLog (revision 38755) @@ -1,3 +1,10 @@ https://github.com/ruby/ruby/blob/trunk/ChangeLog#L1 +Thu Jan 10 11:15:04 2013 Aaron Patterson <aaron@t...> + + * probes.d: updating probes to be more symmetrical, adding + documentation. + + * load.c: ditto + Thu Jan 10 04:23:07 2013 Aaron Patterson <aaron@t...> * ext/psych/lib/psych/scalar_scanner.rb: strip trailing dots from Index: load.c =================================================================== --- load.c (revision 38754) +++ load.c (revision 38755) @@ -638,7 +638,9 @@ rb_f_load(int argc, VALUE *argv) https://github.com/ruby/ruby/blob/trunk/load.c#L638 rb_load_internal(path, RTEST(wrap)); if (RUBY_DTRACE_LOAD_RETURN_ENABLED()) { - RUBY_DTRACE_LOAD_RETURN(StringValuePtr(fname)); + RUBY_DTRACE_LOAD_RETURN(StringValuePtr(fname), + rb_sourcefile(), + rb_sourceline()); } return Qtrue; @@ -941,7 +943,9 @@ rb_require_safe(VALUE fname, int safe) https://github.com/ruby/ruby/blob/trunk/load.c#L943 th->errinfo = errinfo; if (RUBY_DTRACE_REQUIRE_RETURN_ENABLED()) { - RUBY_DTRACE_REQUIRE_RETURN(StringValuePtr(fname)); + RUBY_DTRACE_REQUIRE_RETURN(StringValuePtr(fname), + rb_sourcefile(), + rb_sourceline()); } return result; Index: probes.d =================================================================== --- probes.d (revision 38754) +++ probes.d (revision 38755) @@ -1,29 +1,173 @@ https://github.com/ruby/ruby/blob/trunk/probes.d#L1 #include "vm_opts.h" provider ruby { + /* + ruby:::method-entry(classname, methodname, filename, lineno); + + This probe is fired just before a method is entered. + + * `classname` name of the class (a string) + * `methodname` name of the method about to be executed (a string) + * `filename` the file name where the method is _being called_ (a string) + * `lineno` the line number where the method is _being called_ (an int) + */ probe method__entry(const char *, const char *, const char *, int); + /* + ruby:::method-return(classname, methodname, filename, lineno); + + This probe is fired just after a method has returned. The arguments are + the same as "ruby:::function-entry". + */ probe method__return(const char *, const char *, const char *, int); + /* + ruby:::cmethod-entry(classname, methodname, filename, lineno); + + This probe is fired just before a C method is entered. The arguments are + the same as "ruby:::function-entry". + */ probe cmethod__entry(const char *, const char *, const char *, int); + /* + ruby:::cmethod-return(classname, methodname, filename, lineno); + + This probe is fired just before a C method returns. The arguments are + the same as "ruby:::function-entry". + */ probe cmethod__return(const char *, const char *, const char *, int); + /* + ruby:::require-entry(requiredfile, filename, lineno); + + This probe is fired on calls to `rb_require_safe` (when a file is + required). + + * `requiredfile` is the name of the file to be required (string). + * `filename` is the file that called "require" (string). + * `lineno` is the line number where the call to require was made (int). + */ probe require__entry(const char *, const char *, int); - probe require__return(const char *); + /* + ruby:::require-return(requiredfile, filename, lineno); + + This probe is fired just before `rb_require_safe` (when a file is required) + returns. The arguments are the same as "ruby:::require-entry". This + probe will not fire if there was an exception during file require. + */ + probe require__return(const char *, const char *, int); + + /* + ruby:::find-require-entry(requiredfile, filename, lineno); + + This probe is fired right before `search_required` is called. + `search_required` determines whether the file has already been required by + searching loaded features ($"), and if not, figures out which file must be + loaded. + + * `requiredfile` is the file to be required (string). + * `filename` is the file that called "require" (string). + * `lineno` is the line number where the call to require was made (int). + */ probe find__require__entry(const char *, const char *, int); + + /* + ruby:::find-require-return(requiredfile, filename, lineno); + + This probe is fired right after `search_required` returns. See the + documentation for "ruby:::find-require-entry" for more details. Arguments + for this probe are the same as "ruby:::find-require-entry". + */ probe find__require__return(const char *, const char *, int); + /* + ruby:::load-entry(loadedfile, filename, lineno); + + This probe is fired when calls to "load" are made. The arguments are the + same as "ruby:::require-entry". + */ probe load__entry(const char *, const char *, int); - probe load__return(const char *); + /* + ruby:::load-return(loadedfile, filename, lineno); + + This probe is fired when "load" returns. The arguments are the same as + "ruby:::load-entry". + */ + probe load__return(const char *, const char *, int); + + /* + ruby:::raise(classname, filename, lineno); + + This probe is fired when an exception is raised. + + * `classname` is the class name of the raised exception (string) + * `filename` the name of the file where the exception was raised (string) + * `lineno` the line number in the file where the exception was raised (int) + */ probe raise(const char *, const char *, int); + /* + ruby:::object-create(classname, filename, lineno); + + This probe is fired when an object is about to be allocated. + + * `classname` the class of the allocated object (string) + * `filename` the name of the file where the object is allocated (string) + * `lineno` the line number in the file where the object is allocated (int) + */ probe object__create(const char *, const char *, int); + + /* + ruby:::array-create(length, filename, lineno); + + This probe is fired when an Array is about to be allocated. + + * `length` the size of the array (long) + * `filename` the name of the file where the array is allocated (string) + * `lineno` the line number in the file where the array is allocated (int) + */ probe array__create(long, const char *, int); + + /* + ruby:::hash-create(length, filename, lineno); + + This probe is fired when a Hash is about to be allocated. + + * `length` the size of the hash (long) + * `filename` the name of the file where the hash is allocated (string) + * `lineno` the line number in the file where the hash is allocated (int) + */ probe hash__create(long, const char *, int); + + /* + ruby:::string-create(length, filename, lineno); + + This probe is fired when a String is about to be allocated. + + * `length` the size of the string (long) + * `filename` the name of the file where the string is allocated (string) + * `lineno` the line number in the file where the string is allocated (int) + */ probe string__create(long, const char *, int); + /* + ruby:::parse-begin(sourcefile, lineno); + + Fired just before parsing and compiling a source file. + + * `sourcefile` the file being parsed (string) + * `lineno` the line number where the source starts (int) + */ probe parse__begin(const char *, int); + + /* + ruby:::parse-end(sourcefile, lineno); + + Fired just after parsing and compiling a source file. + + * `sourcefile` the file being parsed (string) + * `lineno` the line number where the source ended (int) + */ probe parse__end(const char *, int); #if VM_COLLECT_USAGE_DETAILS @@ -31,9 +175,32 @@ provider ruby { https://github.com/ruby/ruby/blob/trunk/probes.d#L175 probe insn__operand(const char *, const char *); #endif + /* + ruby:::gc-mark-begin(); + + Fired at the beginning of a mark phase. + */ probe gc__mark__begin(); + + /* + ruby:::gc-mark-end(); + + Fired at the end of a mark phase. + */ probe gc__mark__end(); + + /* + ruby:::gc-sweep-begin(); + + Fired at the beginning of a sweep phase. + */ probe gc__sweep__begin(); + + /* + ruby:::gc-sweep-end(); + + Fired at the end of a sweep phase. + */ probe gc__sweep__end(); }; -- ML: ruby-changes@q... Info: http://www.atdot.net/~ko1/quickml/