Skybuck's FasterSpawnGeneratorV3 (154 cycles for 100 threa..

;redcode
;name FasterSpawnGeneratorV3
;author Skybuck Flying
;version 3
;history version 1,2 and 3 created on 7 december 2007

;
; version 3:
;
; Let's try to optimize further by for example using dual data variables and
such.
;
; If there was a division instruction which stored the remainder in a and
result in b then further optimization
; would be possible, now it's not possible
; only further optimization was one less variable used so code size a bit
smaller now.
;
; It looks pretty minimized so I see no further room for optimizations or
space gain without sacrificing program flexibility
;
; So the code looks done and pretty much final...
;
; Only 26 instructions used, nice !
; 154 cycles for 100 threads.
;

;
; version 2:
;
; Let's try to optimize it for even faster performance and less code size !
=D
;
; By using only one spawn program pointer cycles have been reduced further
to:
;
; 154 cycles for 100 threads ! 4% improvement.
;


; version 1:
; Tested with 101 threads (nice figure to test with)
;
; Tested with 100 threads to compare against others: 162 cycles needed.
; Code Size: 31 not to bad !
; Beats John's implementation in cycles.
;
; and this is not even the optimized version lol
;
; Let's implement John's spawning algorithm but let's also try to write it
more efficient,
; meaning no stack and the generated spawn program will be placed before the
program start.

ProgramStart


mov #100, ThreadsToSpawn
sub #1, ThreadsToSpawn

mov.b ThreadsToSpawn, DivThreadsToSpawn
mov.ba ThreadsToSpawn, ModThreadsToSpawn

; algoritm is simple:
; just divide threads to spawn by 2
; just mod threads to spawn by 2
; use mod result as binary indicator
; place mov spawn, 0 at binary zero's in front of program start at spawn
program pointer
; place spl 1 for binary one's in front of program start at spawn program
pointer
; repeat until div result is zero.
;
; so we need two copies of threads to spawn, maybe later we can place it in
a dual data variable.
; but for now I don't want to complicate things... so for now we use two
copies or even three lol.

; initialize spawn program pointer
mov #(ProgramStart - SpawnProgramPointer), SpawnProgramPointer

; algorithm implementation:
LoopBegin

div.ab #2, DivThreadsToSpawn
mod.a #2, ModThreadsToSpawn

OutputBegin
jmz.a OutputDoubleThreadsMinusOne, ModThreadsToSpawn

OutputDoubleThreads
mov DoubleThreadsInstruction, <SpawnProgramPointer
jmp OutputEnd

OutputDoubleThreadsMinusOne
mov DoubleThreadsMinusOneInstruction, <SpawnProgramPointer
OutputEnd

mov.ba DivThreadsToSpawn, ModThreadsToSpawn

jmn LoopBegin, DivThreadsToSpawn
LoopEnd

; execute spawn program
jmp @SpawnProgramPointer

ProgramData
ModThreadsToSpawn
DivThreadsToSpawn
dat #0, #0 ; A = ModThreadsToSpawn, B = DivThreadsToSpawn

ThreadsToSpawn dat $0, #0

SpawnProgramPointer dat $0, $0

DoubleThreadsInstruction spl 1, 0
DoubleThreadsMinusOneInstruction mov DoubleThreadsInstruction, 0

ProgramEnd

Hi,

On Dec 7, 5:12 pm, "Skybuck Flying" <s....TakeThisOut@hotmail.com> wrote:
> ;redcode
> ;name FasterSpawnGeneratorV3

I've improved my code, lets see if you can beat this? For a fair
comparision you need to replace the second loop with jmp *stack.

Time to code and test original, approx 10 mins. Time to optimize and
test new version, approx 35 mins

Cheers,

John

org demo

processes equ 100 ; doesn't work for 0 or 1 processes

stack dat 0, codeout

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

demo mov #processes,pmov

procs sub #1, pmov
para mov pmov, {stack
mod #2, *stack
div #2, pmov
jmz para, *stack
mov pspl, *stack
jmn para, pmov

ploop mov }stack, >stack
jmn.a ploop, stack

codeout

end