At the moment the arbitration of the soft-threads is very simplistic. Each
soft thread is given a quota of iterations, and they are looped in the
order of their creation.
However, I noticed that when I decreased the quota of all the threads the
situation got worse. The reason is that the first or second soft threads
usually solved them in the first 500 iterations, and so the other threads
were not run. However, in this case, the step will be relatively large
throughout the entire run.
So I'm looking for a better solution for arbitrating STs. Some ideas I
thought about:
1. Define a prelude: I.e: a configuration of the run to run before the
more permanent run.
2. Allow the user to define a markov chain (some kind of randomized state
machine, but one that can also be defined as non-random). This will
require a relatively complex configuration input, that the way I see it,
won't integrate nicely with what I offer so far.
3. [Really Crazy] Create a binding to a scripting language and use it as
the engine of deciding what to do next in a search. An esteemed member of
the Linux club was apalled when I told him about it, and said it would
require too much overhead.
4. Slightly less crazy: create an arbitration API that accepts a callback
as input and let the user define this function as he pleases. Of course,
non-programmers will need to use some other solution based on it which
I'll need to supply them with.
Ideas, anyone?
Regards,
Shlomi Fish
----------------------------------------------------------------------
Shlomi Fish shlomif_at_vipe.technion.ac.il
Home Page:
http://t2.technion.ac.il/~shlomif/
Home E-mail: shlomif_at_iglu.org.il
He who re-invents the wheel, understands much better how a wheel works.
Received on Wed May 08 2002 - 06:24:21 IDT