From: Ben Tilly <ben_tilly@...>
Date: 2001-02-28T23:37:33+09:00
Subject: [ruby-talk:11775] Re: Comparison Caching

ts <decoux@moulon.inra.fr> wrote:
>
> >>>>> "B" == Ben Tilly <ben_tilly@hotmail.com> writes:
>
>B> Why the swap?  It buys you the ability to see the
>B> elements no matter what order they were in at the
>B> start, but outside of artificial benchmarks, will
>B> you see that?
>
>  To reduce the number of entries.

If the original data structures being compared do
not share data (the common case), you will get the
same number of entries either way, won't you?

>B> I have to wonder about this.  We are defining ==
>B> for an array.  And we are creating new arrays and
>B> putting them in a hash, an act that causes == to
>B> be called on them.  Your id sanity check makes that
>B> work, but it seems fragile.
>
>  it has actually the 2 methods (but with the swap). Apparently your method
>  is faster with b.rb
>
>B> Passing data in a thread local variable has the
>B> advantage that you don't need to explicitly pass a
>B> cache around.
>
>  An Array which contain a recursive Hash and recursive Array, no ?

No.  The design that Chris and I used has a set of methods
with the cache, and a parallel set without.  In Object the
parallel set with the cache is transparently aliased to the
set without.  (Just throw away the cache.)  Therefore the
same cache can be passed between arrays and hashes.  (Note
that the types work out because only object ids go in there.)

Where the design fails is if, say, an Array contains user
defined objects whose == method compares a local variable,
and those local variables contain the original Array.  Then
we create a cache, pass to a method without the cache, then
re-enter the logic but with no memory of the (currently out
of scope) cache, redo our logic, etc.  A global cannot get
into this situation.

>B>              The disadvantage is that if you want
>B> the code to behave correctly upon hitting an
>B> exception, you need to protect various calls.
>
>pigeon% grep rb_ensure tangle.c
>         return rb_ensure(inspect_call, (VALUE)&iarg, protect_reset, 0);
>pigeon%
>
And this takes time, doesn't it?

I will have to look tonight, but I suspect that if you
had parallel sets of methods you could speed your code
up.  == in Array and Hash just protect calls to a
parallel method that assumes you are protected, and in
Object that is aliased back to ==.

Cheers,
Ben
_________________________________________________________________
Get your FREE download of MSN Explorer at http://explorer.msn.com