Call to action: if you are reading this and have a working retro-computer with any CPU running Tiny Basic (esp. the version with TBIL) please run the same benchmark test and share the results here!

Update 2025-11-27

@msolajic also ran the benchmark on a computer very special and dear to all enthusiasts from ex-Yugoslavia: the Galaksija.

Update 2025-11-26

Running the benchmark in "extended" mode using FOR/NEXT loops improves performance about 3% but the data in tables below are for "original" version of the Tiny Basic interpreter.

Update 2025-11-23 / 27

@msolajic graciously ran the 1000-primes benchmark on some additional retro-computers. Here are the results and comparison with Basic CPU (see table at the bottom of this project log)

As soon as the CPU started semi-working, I set out to measure and improve the performance. To be precise, I added the elapsed run timer into the CPU. It is driven by 1kHz clock (so has 1ms resolution of "ticks"). It is started when Lino register (holding the line of executing statement) goes from 0 to != (program execution starts) and stops when it goes back to 0.

-- counting ticks (typically 1ms) while the program is running (to be displayed at the end of execution
on_clk_tick: process(clk_tick, reset)
begin
    if (reset = '1') then
        cnt_tick <= (others => '0');
        cnt_tick1000 <= (others => '0');
        lino_tick <= (others => '0');
    else
        if (rising_edge(clk_tick)) then
            lino_tick <= Lino;
            if (is_runmode = '1') then
                if (lino_tick = X"0000") then
                    -- going from stopped to running, reset counters
                    cnt_tick <= (others => '0');
                    cnt_tick1000 <= (others => '0');
                else
                    -- when running, load increment counters
                    if (cnt_tick = X"03E7") then        -- wrap around at 1000
                        cnt_tick <= (others => '0');
                        cnt_tick1000 <= std_logic_vector(unsigned(cnt_tick1000) + 1);
                    else
                        cnt_tick <= std_logic_vector(unsigned(cnt_tick) + 1);
                    end if;
                end if;
            end if;
        end if;
    end if;
end process;

At the end of program execution, the value of these 2 counters (seconds and milliseconds elapsed) is displayed:

 For benchmark, I used the "find first 1000 primes" test which has the advantage of simplicity and portability. Because this version has no FOR/NEXT (I plan to implement it), the test had to slightly change and replace that with IF/GOTO.

There are two variations of the test code:

• Without GOSUB (proposed here, modified Basic program here)
• With GOSUB (proposed here, modified Basic program here) - not surprisingly, it is about 20% slower across all clock frequencies.

Below is the direct comparison with my previous Tiny Basic project. Meaningless (because it is different interpreter and CPU) but still fun:

Going back to the original article from 1980, I attempted to compare by reducing the Basic CPU clock speed to be same as those systems. 

As can be seen, Basic CPU is faster than all compared systems, except AMD's own HEX-29 system / CPU which was a showcase of their own bit-slice technology. Interestingly, it is also controlled by similar "horizontal" micro-code just like the Basic CPU. This CPU has been described in the classic "Bit-slice Microprocessor Design" book.

Update 2025-11-20: with some tweaks in microcode, I improved the perf numbers above by about 1-2%. More info about perf here.