Better concept for a mini cpu: Load instructions from the ..

Hello,

The first minicpu I tried had many drawbacks... but maybe also some
adventages... but for a moving warrior the minicpu is unusuable... because
the real instruction pointer always moves forward by 1, and the warrior
moves forward by 1 so this cancels out each other... and the warrior will
always execute the same instruction over and over again... this could be
nice... but it would also be nice if a moving warrior can have a mini cpu
embedded so that it can even have normal program flow while it moves !

And for that to work it must have a good functioning cpu ! =D

However writing a fully functionaly cpu might require lot's of working and
maybe even lot's of instructions... but for those that dare to write one
here are some little hints to help you out, here goes:

1. Consider the program to be executed to be main memory.
2. Consider the minicpu to have it's own local memory.

3. The minicpu should load instructions from main memory, into it's local
memory.
4. The minicpu should execute the instruction located inside it's local
memory.

Thus some easy concepts:

The minicpu should have:

1. An instruction pointer which it can increment, decrement, add, subtract.
2. An instruction register where instructions from main memory, via the
instruction pointer, will be loaded to.
3. The cpu should execute the instruction which is loaded inside the
instruction register.

There are more difficulties to overcome:

The cpu should not execute jump statements. Instead the cpu should add the
jump parameter to the instruction pointer.

And then there are other problems like addressing modes.

In short it might be quite a task to write a good functioning mini cpu
inside redcode !

Sigh.. I might try to write a minicpu myself... if anyone already wrote
one... please share that will save me some time

There go folks ! Some hints for ya ! =D

Bye,
Skybuck.

Then again... maybe the minicpu will never working inside a moving warrior,
if and only if the minicpu needs to execute compares and jumps...

Because if it needs to execute compares or jumps then ofcourse the threads
which would execute the cpu in serial-threaded fashion... would start
executing elsewhere and would never return to their true position ?!

This could be a problem !

So maybe I need to try a totally different cpu with that crazy idea of mine:

A couple of threads:

1. Thread 1 stores the instruction at the instruction pointer.
2. Thread 2 splits off execution to the instruction pointer
3. Thread 3 bombs the instruction at the instruction pointer
(To bomb is to try and kill splitted off processes.)
4. Thread 4 restores the execution at the instruction pointer.
5. Thread 5 increments the instruction pointer.
(Something like that)

6. Programs could modify the instruction pointer directly instead of using
jumps and such.

Only problem which remains is with jumps and spl's and compares and such
which jump somewhere else...
Those instructions will never get bombed ?! so they will keep executing ?!
hmmmmmmm.

Maybe three other threads can be used which store and bomb the indirect
locations

like:

Thread 1b stores the indirect instruction from the instruction pointer.
Thread 2b bombs the indirect instruction from the instruction pointer.
Thread 4b restores the indirect instruction from the instruction pointer.

This could actually solve the problem... as long as the program makes sure
to change the instruction pointer when needed...

Could work ! Nice idea ! =D

Bye,
Skybuck.