Algorithm for spawning any number of threads.

Hello,

Listen if you want to spawn a number of threads then do the following:

First substract 1 from the number of threads.

Then determine where it lies on the binary scale for example
1-2-4-8-16-32-64-128-256-512-1024

For example (101-1) = 100 threads to be created to get 101 threads lies
between 64 and 128.

Simple idea, start with 1, multiply it by 2, keep multiplieing it by 2 until
it's greater than the number of threads.

Now divide it once and you have something which you can use to find the
binary number for 100.

Call it the divisor. For example for 100 the divisor starts with 64.

Here's the rest of algo:

Divide Number of Threads (100) by the divisor (64).

If it can divide it gives 1 if not it gives a 0.

Now comes the interesting part.

For a 1, the number of threads need to dubbel.
For a 0, the number of threads need to dubbel-1.

Depending on the outcome, dubbel or dubbel-1 the threads.

To dubbel use spl 1
To dubbel-1 use mov spawn, 0 (spawn is spl 1)

Then make all threads jump to generated instruction as described in the two
lines above.

So for a 1:

spl 1 should be executed.

So for a zero

mov spawn, 0 will be executed for the first thread.
all other threads will execute
spl 1, 0

This has the effect that one less thread will be created which is exactly
what it should.

Now divide the divisor by 2 and repeat the loop, until the divisor is zero.

Here is an example:

100 div 64 = 1, remainder 35
36 div 32 = 1, remainder 4
4 div 16 = 0, remainder 4
4 div 8 = 0, remainder 4
4 div 4 = 1, remainder 0
0 div 2 = 0, remainder 0
0 div 1 = 0, remainder 0
0 div 0 = death of thread. you could try to avoid it or use it to your
adventage to kill off any calculating thread or so.

binary 1100100 = 100

Now you have an algorithm to extract the binary one's and zero's from the
number 100.

And thus you can create a nice spawning program which will execute fast.

The spawning program should look something like:
spl 1
spl 1
mov -1, 0
mov -1, 0
spl 1
mov -1, 0
mov -1, 0
jmp 0

An alternative method (untested but will probably work just as well):

spl 1
spl 1
mov SplInstruction, 0
mov SplInstruction, 0
spl 1
mov SplInstruction, 0
mov SplInstruction, 0
jmp 0
SplInstruction spl 1

After this code has been executed there will be 100 threads created plus the
main thread so 101 threads ! nice eh !

Now the only thing to do is for example write some nice redcode code which
implements the algorithm with div's, mod's and such.

Bye,
Skybuck.

On Dec 6, 5:06 pm, "Skybuck Flying" <s... RemoveThis @hotmail.com> wrote:
Now the only thing to do is for example write some nice redcode code
which
> implements the algorithm with div's, mod's and such.

Hi Skybuck,

Here's some code which creates the code to generate any required
number of processes using spl 1 and mov -1,0. There's room for
improvement - it can be made smaller and faster!

Cheers,

John

org demo

stack dat 0, count+1

pspl spl 1
pmov mov.i -1, #0

demo mov.a #13, {stack

sub.a #1, *stack
para mov.a *stack, {stack
div.a #2, }stack
mod.a #2, *stack
add #1, count
jmn.a para, {stack
add.a #1, stack
ploop mov pmov, @stack
seq.a #0, }stack
mov pspl, @stack
add #1, stack
count djn ploop, #0

end