I had the idea to rewrite my emulator so that it uses the same decoder ROM images that the real machine will. This was quite a good move - the emulator now stays in sync with any changes I make to the instruction set. It also means the emulator is now cycle accurate - it can tell me exactly how long a program will take to run. With that, I thought I'd implement the "Byte sieve" and see how my architecture performs.

Statistics:
    328882 instructions
    1184625 cycles
    0.5923125 sec at 2.0 MHz
    3.60 cycles/inst

I was surprised by this - one iteration of the sieve (of size 8191, the standard size) takes 0.59 seconds. How does that compare to other processors? I found this article from 1983 that lists reader-submitted times for various systems and languages. Those times are for 10 iterations so I need to multiply my number by 10:

1 MHz 6502  asm   13.9
? MHz Z80   asm    6.8
5 MHz 8088  asm    4.0
8 MHz 8086  asm    1.9

2 MHz DIP8  asm    5.9

Not bad! It performs about the same as a 6502 at the same clock rate, which I wasn't expecting. Maybe the 6502 code wasn't a very efficient implementation. Anyway, it's just one benchmark. I have some nice addressing modes and 16-bit registers which will have helped here, but modifying variables in memory is quite clunky at the moment. Luckily I have a plan to fix that.

The downside to this new emulator is that it's a bit slow - it can't run in real time. Which I think is a bit funny - my Python code running at 3 GHz can't emulate a system running at a puny 2 MHz!

Byte sieve assembly code is here for anyone interested: https://github.com/kylesrm/dip8-computer/blob/main/src/sieve.asm