This is very interesting, and it answers a question I've had about the original Kenbak-1.
I've seen lots of statements on various web sites regarding the 'speed' of the Kenbak. Some say that the clock speed is 1Mhz, some say that the oscillator is 1Mhz, some even say that the instruction cycle time is 1Mhz, or even worse that it executes 1 megaflop. In the Kenbak-1 Threory of Operation manual it says that oscillator runs at twice the system clock speed, but it doesn't say what speed it actually is. This video demonstrates that the clock speed is 1Mhz, the oscillator is 2Mhz.
The clock speed of 1Mhz is the rate at which bits are shifted through the memory. The two 1K shift registers run in parallel, so every memory byte is available once every 1024 clocks, or about every millisecond. Since every instruction begins with a fetch of the program counter (at address 3), every instruction must take an integer multiple of 1024 clocks. It is easier to think about this in terms of byte clocks rather than bit clocks, so this is equivalent to saying that every instruction takes an integer multiple of 128 byte clocks. Based on the state machine described in the Theory of Operation manual, you can predict how many complete cycles through the memory each instruction will take. For the three instructions desribed here you can compute that they will take:
the 'add a,c=1' instruction takes 1 trip through the memory (128 byte cycles) or about 1ms
the 'store a,200 ' instruction takes 2 trips through the memory (256 byte cycles) or about 2ms
the 'jpd loop' instruction also takes 2 trips, or 2ms.
Of course that only adds up to 5ms, while the video shows the loop taking 6ms. It turns out that any instruction located at address 4 takes an extra trip around the memory, adding the 6th millisecond. (This is because after fetching the program counter at address 3, it is too late to fetch the instruction at the very next address (4), so the machine has to wait for 4 to come around again 1ms later) Therefore the loop running in the video must have started at address 4.
I've built a simulator which simulates the state machine (as described in the Theory of Operation manual, and have run a number of programs through it. Typically, the average instruction time is around 256 byte cycles (now seen to be about 2ms). The longest running instruction I've been able to concoct is a 'load x,(1)+x', located at address 4, location 1 (reg B) containing the value 1 and location 2 (reg X) containing the value 0. This instruction takes 6 trips around the memory, or 768 byte cycles totalling 6ms.