I have implemented a tool for helping me debug some algorithms that are
very similar but I need some help in improving how it works.

I have a set of implementations of algorithms that all compute the same
result.
I normally run two implementations (lets say  C  and  E)  at a time and
compare the runs for speed, space used, and other characteristics.
If the implementations are correct both runs return the same result but
if there is a bug the results may be different.

If the results are different I track down the problem by running a method
called traceBug.  (Tracebug is started by pressing a button).
The high level part of each implementation is the same but they each invoke
a method
which is different for each implementation.
Let's say  C  invokes  Mc  and  E  invokes  Me  where  Mc  and  Me  are
different.
Note that  Mc  (if it has no bugs) always computes the same result for the
same
input parameters.  Similarly for  Me.

Conceptually, TraceBug works as follows.
Repeat
    If  C has not been started start it.  Continue running C  until  Mc is
invoked.
    Store the result of  Mc, in Ac.
    If  E has not been started start it.  Continue running  E  until  Me is
invoked.
    Store the result of  Me  in  Ae.
Until Ac  and  Ae  are different.   //  since there is a bug this must
happen

Ac  and  Ae  are arrays.  Since they are different, for some index  i,
Ac[i] != Ae[i].
TraceBug  now  invokes  M'c  where is  M'c takes the same parameters as  Mc
except for one additional parameter  i.  M'c  does the same computations as
Mc
except that when the value  Ac[i] is about to be computed a halt is invoked
thus
bringing up the debugger.

I can now use the debugger to investigate how Ac[i] is computed!
I also invoke traceBug so that the halt occurs when  Ae[i] is about to be
computed.

Thus by running traceBug twice  I am able to bring up two debuggers
somewhere
near where my bug is!  Having two debuggers up at the same time
is very useful in finding where my bug is!

I would like to be able to improve traceBug in two ways.

First, I would like to only press the traceBug button once.
This means that once the debugger is brought up traceBug needs to be
restarted
so that it can cause the second debugger to come up.
Obviously this can be done but I don't know how to do it.

Second, instead of restarting traceBug from the beginning,  I would like to
have it be restarted at the point immediately after the line where  M'c is
invoked.
It could then immediately invoke  M'e.   This would avoid running  C  and
E  twice
and thus be faster.  This is not that important to me since  C  and  E  are
usually fast (a few seconds), but I would like to know how to do this and I
may
deal with slower algorithms in the future.

Thanks in advance for any advice.

Ralph
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.squeakfoundation.org/pipermail/squeak-dev/attachments/20070105/4c02cac2/attachment.htm