On Mon, Jul 21, 2008 at 10:43 PM, Charles Oliver Nutter
<[EMAIL PROTECTED]> wrote:
> I've landed the second pass at JI refactoring, this time eliminating most of
> the intermediate waste and duplicate logic for method selection and argument
> coercion. Before, incoming Ruby objects were first coerced to their default
> Java type (like Fixnum to Long), and stuffed into an array. That array was
> passed to the method lookup logic, which examined each method and each
> argument to find a match. The match was cached and the method returned. Then
> the list of arguments was passed to the method, which went through each of
> them again and narrowed them to the actual target type on the target method.
>
> So, for example, if you were calling a method that takes int with a Fixnum:
>
> 1. Fixnum is coerced into a Long object and put into Object[]
> 2. Object[] is passed to method selection and your method is found
> 3. Object[] is passed into your method and Long is converted to Integer
> 4. Method is called
>
> This path, under the new code:
>
> 1. Fixnum is passed directly to method selection logic, with no Object[],
> and your method is found. Argument counts up to 3 are passed straight
> through the process without extra boxing.
> 2. Fixnum is converted directly to Integer, based on the found method.
> 3. Integer is boxed into Object[] for reflection and your method is invoked.
>
> For numeric types, this should greatly improve JI performance. It's also a
> lot easier code to cope with.
>
> More to come.
>
> - Charlie
My apologies if you've addressed this question already Charlie but do
expect to be changing the JI api's much?
-Chad
---------------------------------------------------------------------
To unsubscribe from this list, please visit:
http://xircles.codehaus.org/manage_email
