World: r3wp

That combination of 8-bit values into 16-bit registers has got to 
be a common code pattern. Are the 16-bit operations distinct from 
the 8-bit ones? This is the kind of code pattern that you could combine 
and optimize. Internally, do you need to have the 16-bit registers 
be a combination of the 8, or could they be seperate and have their 
values transfered over if it would be faster?

Are the 16-bit values loaded in one statement or two?

Need there be a difference?

It's what the modern processor designers call register renaming :)

sorry,
disconnected

not sure to understand what u mean

I would have to read your Z80 manual to be sure, but it seems to 
me that these 16-bit operations seem to be great candidates for opcode 
combining. It may even be a good idea to have the 16-bit registers 
be seperate variables internally.

At the very least you should have seperate macros for 16-bit reads 
from and writes to memory, rather than a combination of 8-bit ops.

but i'm afraid that synchronization of 16bits registers with the 
8bits (transfer of values) cause an overhead

what u gain in one side, u lost it in the other side

synchronisation needs more operations

How does that overhead compare to that of doing it the straight-forward 
way? Remember that every loop of the interpreter is overhead.

moreover , i'm not that writing/reading  a word in memory is more 
faster than to write/read 1 byte 2 times

*i'm not sure

i explain

because instructions in rebcode are different

i have to test

to write a word, u need to use change

and you need to build a binary data

for example to write 01 and 02 , you need to build the serie #{0102}

u see what i mean ?

u can not just write a 16 bit value like that

i could handle 16 bit registers directly in binary series

Yeah, that is likely slower. You are likely to have to do some bytewise 
reads and writes internally. You would be faster if you had seperate 
read/write macros for the 16-bit load/store instructions.

hu ?

what are you saying ?

i said that the faster way is to write 2 times 8bit instead of writing 
16 bit in one time

I was agreeing.

so there is no optimization to have different macro for access/writing 
16bit or 8bits registers

ah ok

'scuse me

I wonder if there would be a fast way to cache the 16-bit values 
in _HL, _BC and such, and writing them quickly.

that could be faster if 16 bits register was handled internally as 
binary series

but that will be a problem to perform math operation on them

It occurs to me that overflow on these inserts isn't handled the 
way you think.

?

explain

If you poke a value over 255 into a string/binary, the upper bytes 
may be ignored rather that triggering an overflow error. Test that.

ok

It might save on some AND x 255 statements.

could be a usefull trick if it works

It doesn't work in REBOL code, but it might in rebcode.

you're right

the upper byte of 16bit value is not kept

hum

so i could remove some and var 255 from my code

That provides a way to optimize the 16-bit load/store ops, particularly 
if there are 16-bit registers.

hmm...

You could invalidate the affected 16-bit register if you use an 8-bit 
op, or perhaps combine 2 8-bit load/stores that would add up to a 
16-bit load/store into their 16-bit operation.

perhaps...