Garrett D'Amore wrote:
> I am unclear if the existence of a bug (6659110) is adequate 
> justification for not delivering this feature on SPARC.  Particularly 
> given that the named bug has not even been evaluated for accuracy, 
> much less root caused or analyzed for cost-to-fix.

 The bug it self is being scoped down by folks in the iropt and front 
end groups.  If by "not even been evaluated for accuracy" you mean user 
error, the compiler team is able to reproduce the problem, and have 
indicated that they think it's a problem with the probes.

> Architecturally, this would be far far more clear cut if the project 
> team committed to architecture feature parity here.

 SPARC support is something we really want to introduce, as soon as we 
get relief on 6659110.  It was felt that introducing SPARC support with 
a severe performance degradation was not good for Ruby/Solaris/SPARC - 
and dalaying release until the compiler bug got resolved

>   (Ultimately, this may require C-Team approval/override, due to 
> violation of Sun Big Rules, but this of course falls outside of the 
> scope of ARC review.)
>
> On a related note, I have to ask, is the project going to be 
> delivering 32-bit probes, or just 64-bit?  (I see a specific reference 
> made to x64, but none made for x86.)  I'm not familiar with Ruby, so 
> if this question is nonsensical, please so indicate. :-)
 The probes are 32 bit - they're going to be introduced into the 
existing Ruby language software which comprise 32-bit programs.  I've 
made a correction to the ARC case and inlined the new version below.
 

Template Version: @(#)sac_nextcase 1.64 07/13/07 SMI
This information is Copyright 2008 Sun Microsystems
1. Introduction
    1.1. Project/Component Working Name:
         Enhancing Ruby with DTrace probes
    1.2. Name of Document Author/Supplier:
         Author:  Sivakumar Shanmugasundaram
    1.3  Date of This Document:
        04 March, 2008
4. Technical Description
Enhancing Ruby with DTrace probes

Sivakumar Shanmugasundaram <sivakumar at Sun.COM>

4 March 2008

1.      Summary and motivation

        This project enables Ruby[1] in OpenSolaris[2] to expose DTrace[3]
        probes, thus enabling Ruby/Rails[4] users on Solaris to trace/examine
        application behavior in a more useful manner than they otherwise are
        able to. DTrace is one of Solaris' key features, and this integration
        will go a long way in making Solaris the preferred platform for
        Ruby/Rails deployment/development. 

        Ruby was originally delivered by PSARC/2007/600.

        11 DTrace probes, developed by DTrace enthusiasts at Joyent[5], are
        being integrated into Solaris.

        This case seeks Minor Release Binding.

2.      Technical issues

2.1.    Key objects.

        The DTrace probes are part of the Ruby runtime library (libruby.so.1)
        which in turn is linked in to the 'ruby' binary and hence is also part
        of the 'ruby' binary. No new files are delivered as part of this case.

2.2.    Versioning

        The DTrace interfaces for Ruby are based on subversion trunk version
        501. The interfaces are evolving, and it is unknown whether they will
        remain stable across releases.

2.3.    Packaging and Delivery

        The DTrace probes will be included as a patch to the existing 'ruby'
        binary and will be delivered as part of the existing SUNWruby18u
        package.

2.4     Platform support

        These DTrace probes will initially be available only in the x86 and x64
        versions of Solaris due to a defect (CR # 6659110). This forces us not
        to have DTrace support for Ruby on Sparc. The feature parity will be
        restored as soon as possible.

3.      DTrace Probe dependencies.

        The DTrace probes depends on the DTrace packages in Solaris SUNWdtrc
        and SUNWdtrp.

4.      DTrace probe Internationalization.

        The DTrace probes are not internationalized as DTrace does not support
        internationalization at this time.

5.      Ruby DTrace Documentation.

        The list of DTrace probes for Ruby is listed below. Examples for
        using the DTrace probes are available in the Joyent's DTrace page [6].

        Probe name           Description
        ----------------------------------------------------------------------
        function-entry       Fires when a Ruby method is entered
        function-return      Fires when a Ruby method returns
        raise                Fires when a Ruby exception is raised
        rescue               Fires when a Ruby exception is rescued
        line                 Fires for every line of Ruby executed
        gc-begin             Fires right before a GC cycle begins
        gc-end               Fires right after a GC cycle finishes
        object-create-start  Fires directly before a Ruby object is allocated
        object-create-done   Fires when Ruby is finished allocating an object
        object-free          Fires every time a Ruby object is freed
        ruby-probe           Probe that can be fired from Ruby code (see below)

        Probe Arguments

         Probe              args0         args1         args2         args3
     --------------------------------------------------------------------------
     function-entry       Ruby class    Method name   Source file   Line number
     function-return      Ruby class    Method name   Source file   Line number
     raise                Ruby class    Source file   Line number   -
     rescue               Source file   Line number   -             -
     line                 Source file   Line number   -             -
     gc-begin             -             -             -             -
     gc-end               -             -             -             -
     object-create-start  Ruby type     Source file   Line number   -
     object-create-done   Ruby type     Source file   Line number   -
     object-free          Ruby type     -             -             -
     ruby-probe           Any string    Any string    -             - 

        The man page for Ruby will be suitably modified as well, to indicate
        the addition of DTrace probes to the interpreter and the list of
        probes available as well.


        5.1.    Manual Pages.

        The man page of ruby.1 is changed to include the information about the
        availability of DTrace probes in the binary and list of DTrace probes,
        its description and their arguments.
        The changed man page fragment is in Appendix 1.

6.      Interfaces

        6.1.    Imported Interfaces.

        NAME                            STABILITY                   NOTES
        ----------------------------------------------------------------------
        Ruby language implementation    Uncommitted             PSARC/2007/600
        DTrace Provider API             Uncommitted             PSARC/2001/466


        6.2.    Exported Interfaces.

        NAME                            STABILITY                   NOTES
        ----------------------------------------------------------------------
        function-entry                  Uncommitted               DTrace Probe
        function-return                 Uncommitted               DTrace Probe
        raise                           Uncommitted               DTrace Probe
        rescue                          Uncommitted               DTrace Probe
        line                            Uncommitted               DTrace Probe
        gc-begin                        Uncommitted               DTrace Probe
        gc-end                          Uncommitted               DTrace Probe
        object-create-start             Uncommitted               DTrace Probe
        object-create-done              Uncommitted               DTrace Probe
        object-free                     Uncommitted               DTrace Probe
        ruby-probe                      Uncommitted               DTrace Probe

        The description of these probes are listed in the documentation
        section 5 above. More details about the usage of these probes, their
        decription, the arguments can be found in Joyents web site [6].

7.      References.

        [1] http://www.ruby-lang.org
        [2] http://www.opensolaris.org
        [3] http://opensolaris.org/os/community/dtrace
        [4] http://www.rubyonrails.org
        [5] http://dtrace.joyent.com
        [6] 
https://dtrace.joyent.com/projects/ruby-dtrace/wiki/Ruby+DTrace+probes+and+arguments


==============================================================================
Appendix 1: Ruby man page changes

FEATURES
...
    DTrace Probes
        Ruby has a set of DTrace probes that can be used to debug a running
        Ruby/Rails application. NOTE: This is on x86/x64 platform only.

          function-entry - Probe that fires when a Ruby method is entered
          function-return - Probe that fires when a Ruby method returns
          raise - Probe that fires when a Ruby exception is raised
          rescue - Probe that fires when a Ruby exception is rescued
          line - Probe that fires for every line of Ruby executed
          gc-begin - Probe that fires right before a GC cycle begins
          gc-end - Probe that fires right after a GC cycle finishes
          object-create-start - Probe that fires directly before a Ruby object 
is allocated
          object-create-done - Probe that fires when Ruby is fin- ished 
allocating an object
          object-free - Probe that fires every time a Ruby object is freed
          ruby-probe - Probe that can be fired from Ruby code (see below)


          Probe Arguments

          function-entry "Ruby class" "Method name" "Source file" "Line number"

          function-return  "Ruby  class"  "Method  name"  "Source file" "Line 
number"

          raise "Ruby class" "Source file" "Line number"

          rescue "Source file" "Line number"

          line "Source file" "Line number"

          gc-begin ""

          gc-end ""

          object-create-start "Ruby  type"  "Source  file"  "Line number"

          object-create-done  "Ruby  type"  "Source  file"  "Line number"

          object-free "Ruby type" ruby-probe  "Arbitrary  string" "Arbitrary 
string"


...
NOTES
    Source for ruby is available on http://opensolaris.org.
    The source for the DTrace probes for Ruby and examples are available on 
http://dtrace.joyent.com.


6. Resources and Schedule
    6.4. Steering Committee requested information
        6.4.1. Consolidation C-team Name:
                sfw
    6.5. ARC review type: Automatic
    6.6. ARC Exposure: open



Thanks,
 -ps


>
>    -- Garrett
>
>
> Jyri Virkki wrote:
>> I am sponsoring this case for Sivakumar and closing it approved 
>> automatic.
>> The only high[low]light is the feature disparity between x86 and SPARC.
>> If anyone would like to discuss it as a fast track let me know.
>>
>>
>>
>> Template Version: @(#)sac_nextcase 1.64 07/13/07 SMI
>> This information is Copyright 2008 Sun Microsystems
>> 1. Introduction
>>     1.1. Project/Component Working Name:
>>      Enhancing Ruby with DTrace probes
>>     1.2. Name of Document Author/Supplier:
>>      Author:  Sivakumar Shanmugasundaram
>>     1.3  Date of This Document:
>>     04 March, 2008
>> 4. Technical Description
>> Enhancing Ruby with DTrace probes
>>
>> Sivakumar Shanmugasundaram <sivakumar at Sun.COM>
>>
>> 4 March 2008
>>
>> 1.      Summary and motivation
>>
>>         This project enables Ruby[1] in OpenSolaris[2] to expose 
>> DTrace[3]
>>         probes, thus enabling Ruby/Rails[4] users on Solaris to 
>> trace/examine
>>         application behavior in a more useful manner than they 
>> otherwise are
>>         able to. DTrace is one of Solaris' key features, and this 
>> integration
>>         will go a long way in making Solaris the preferred platform for
>>         Ruby/Rails deployment/development.
>>     Ruby was originally delivered by PSARC/2007/600.
>>
>>         11 DTrace probes, developed by DTrace enthusiasts at 
>> Joyent[5], are
>>         being integrated into Solaris.
>>
>>         This case seeks Minor Release Binding.
>>
>> 2.      Technical issues
>>
>> 2.1.    Key objects.
>>
>>         The DTrace probes are part of the Ruby runtime library 
>> (libruby.so.1)
>>         which in turn is linked in to the 'ruby' binary and hence is 
>> also part
>>         of the 'ruby' binary. No new files are delivered as part of 
>> this case.
>>
>> 2.2.    Versioning
>>
>>         The DTrace interfaces for Ruby are based on subversion trunk 
>> version
>>         501. The interfaces are evolving, and it is unknown whether 
>> they will
>>         remain stable across releases.
>>
>> 2.3.    Packaging and Delivery
>>
>>         The DTrace probes will be included as a patch to the existing 
>> 'ruby'
>>         binary and will be delivered as part of the existing SUNWruby18u
>>         package.
>>
>> 2.4     Platform support
>>
>>         These DTrace probes will initially be available only in the x64
>>         version of Solaris due to a defect (CR # 6659110). This 
>> forces us not
>>         to have DTrace support for Ruby on Sparc. The feature parity 
>> will be
>>         restored as soon as possible.
>>
>> 3.      DTrace Probe dependencies.
>>
>>         The DTrace probes depends on the DTrace packages in Solaris 
>> SUNWdtrc
>>         and SUNWdtrp.
>>
>> 4.      DTrace probe Internationalization.
>>
>>         The DTrace probes are not internationalized as DTrace does 
>> not support
>>         internationalization at this time.
>>
>> 5.      Ruby DTrace Documentation.
>>
>>         The list of DTrace probes for Ruby is listed below. Examples for
>>         using the DTrace probes are available in the Joyent's DTrace 
>> page [6].
>>
>>         Probe name           Description
>>         
>> ----------------------------------------------------------------------
>>         function-entry       Fires when a Ruby method is entered
>>         function-return      Fires when a Ruby method returns
>>         raise                Fires when a Ruby exception is raised
>>         rescue               Fires when a Ruby exception is rescued
>>         line                 Fires for every line of Ruby executed
>>         gc-begin             Fires right before a GC cycle begins
>>         gc-end               Fires right after a GC cycle finishes
>>         object-create-start  Fires directly before a Ruby object is 
>> allocated
>>         object-create-done   Fires when Ruby is finished allocating 
>> an object
>>         object-free          Fires every time a Ruby object is freed
>>         ruby-probe           Probe that can be fired from Ruby code 
>> (see below)
>>
>>         Probe Arguments
>>
>>          Probe              args0         args1         args2         
>> args3
>>      
>> -------------------------------------------------------------------------- 
>>
>>      function-entry       Ruby class    Method name   Source file   
>> Line number
>>      function-return      Ruby class    Method name   Source file   
>> Line number
>>      raise                Ruby class    Source file   Line number   -
>>      rescue               Source file   Line number   -             -
>>      line                 Source file   Line number   -             -
>>      gc-begin             -             -             -             -
>>      gc-end               -             -             -             -
>>      object-create-start  Ruby type     Source file   Line number   -
>>      object-create-done   Ruby type     Source file   Line number   -
>>      object-free          Ruby type     -             -             -
>>      ruby-probe           Any string    Any string    -             -
>>         The man page for Ruby will be suitably modified as well, to 
>> indicate
>>         the addition of DTrace probes to the interpreter and the list of
>>         probes available as well.
>>
>>
>>         5.1.    Manual Pages.
>>
>>         The man page of ruby.1 is changed to include the information 
>> about the
>>         availability of DTrace probes in the binary and list of 
>> DTrace probes,
>>         its description and their arguments.
>>         The changed man page fragment is in Appendix 1.
>>
>> 6.      Interfaces
>>
>>         6.1.    Imported Interfaces.
>>
>>         NAME                            STABILITY                   
>> NOTES
>>         
>> ----------------------------------------------------------------------
>>         Ruby language implementation    Uncommitted             
>> PSARC/2007/600
>>         DTrace Provider API             Uncommitted             
>> PSARC/2001/466
>>
>>
>>         6.2.    Exported Interfaces.
>>
>>         NAME                            STABILITY                   
>> NOTES
>>         
>> ----------------------------------------------------------------------
>>         function-entry                  Uncommitted               
>> DTrace Probe
>>         function-return                 Uncommitted               
>> DTrace Probe
>>         raise                           Uncommitted               
>> DTrace Probe
>>         rescue                          Uncommitted               
>> DTrace Probe
>>         line                            Uncommitted               
>> DTrace Probe
>>         gc-begin                        Uncommitted               
>> DTrace Probe
>>         gc-end                          Uncommitted               
>> DTrace Probe
>>         object-create-start             Uncommitted               
>> DTrace Probe
>>         object-create-done              Uncommitted               
>> DTrace Probe
>>         object-free                     Uncommitted               
>> DTrace Probe
>>         ruby-probe                      Uncommitted               
>> DTrace Probe
>>
>>         The description of these probes are listed in the documentation
>>         section 5 above. More details about the usage of these 
>> probes, their
>>         decription, the arguments can be found in Joyents web site [6].
>>
>> 7.      References.
>>
>>         [1] http://www.ruby-lang.org
>>         [2] http://www.opensolaris.org
>>         [3] http://opensolaris.org/os/community/dtrace
>>         [4] http://www.rubyonrails.org
>>         [5] http://dtrace.joyent.com
>>         [6] 
>> https://dtrace.joyent.com/projects/ruby-dtrace/wiki/Ruby+DTrace+probes+and+arguments
>>  
>>
>>
>>
>> ==============================================================================
>>  
>>
>> Appendix 1: Ruby man page changes
>>
>> FEATURES
>> ...
>>     DTrace Probes
>>         Ruby has a set of DTrace probes that can be used to debug a 
>> running
>>         Ruby/Rails application. NOTE: This is on x86/x64 platform only.
>>
>>           function-entry - Probe that fires when a Ruby method is 
>> entered
>>           function-return - Probe that fires when a Ruby method returns
>>           raise - Probe that fires when a Ruby exception is raised
>>           rescue - Probe that fires when a Ruby exception is rescued
>>           line - Probe that fires for every line of Ruby executed
>>           gc-begin - Probe that fires right before a GC cycle begins
>>           gc-end - Probe that fires right after a GC cycle finishes
>>           object-create-start - Probe that fires directly before a 
>> Ruby object is allocated
>>           object-create-done - Probe that fires when Ruby is fin- 
>> ished allocating an object
>>           object-free - Probe that fires every time a Ruby object is 
>> freed
>>           ruby-probe - Probe that can be fired from Ruby code (see 
>> below)
>>
>>
>>           Probe Arguments
>>
>>           function-entry "Ruby class" "Method name" "Source file" 
>> "Line number"
>>
>>           function-return  "Ruby  class"  "Method  name"  "Source 
>> file" "Line number"
>>
>>           raise "Ruby class" "Source file" "Line number"
>>
>>           rescue "Source file" "Line number"
>>
>>           line "Source file" "Line number"
>>
>>           gc-begin ""
>>
>>           gc-end ""
>>
>>           object-create-start "Ruby  type"  "Source  file"  "Line 
>> number"
>>
>>           object-create-done  "Ruby  type"  "Source  file"  "Line 
>> number"
>>
>>           object-free "Ruby type" ruby-probe  "Arbitrary  string" 
>> "Arbitrary string"
>>
>>
>> ...
>> NOTES
>>     Source for ruby is available on http://opensolaris.org.
>>     The source for the DTrace probes for Ruby and examples are 
>> available on http://dtrace.joyent.com.
>>
>>
>> 6. Resources and Schedule
>>     6.4. Steering Committee requested information
>>        6.4.1. Consolidation C-team Name:
>>         sfw
>>     6.5. ARC review type: Automatic
>>     6.6. ARC Exposure: open
>>
>>   
>


-- 
Prashant Srinivasan
F/OSS Enthusiast
Sun Microsystems, Inc.
http://blogs.sun.com/prashant
GnuPG key: http://pgp.mit.edu:11371/pks/lookup?op=get&search=0x82FBDE5A


Reply via email to