Example Programs for Calcutron-33

This is a follow up story on my story about inventing a RISC CPU called Calcutron-33 which has a decimal based number system rather than a binary number system.

Obviously this has no practical application for actual implementation. Rather the intention here is to come up with a simple model of a CPU, which is easy to teach.

Image for post
Image for post
A diagram of our simple Decimal RISC CPU, showing how data flows to different parts. It is the Decoder which decides what parts are enabled and thus where data can flow in. Decode only knows what to enable by looking at Instruction Register, which contains latest instruction fetched from memory.

The idea here is to play with some example programs which can be useful for a beginner to implement. What I am interested in figuring out, is what a minimal set of features are to be able to do something interesting. Such as how many instructions do we need to support? How many registers do we need at minimum?

Get two inputs, add them together and write them to output

loop:
INP x1
INP x2
ADD x1, x2
OUT x1
BRA loop

Repeatedly double inputs and write to output.

loop:
INP x1
ADD x1, x1
OUT x1
BRA loop

Take two inputs and reverse their order

loop:
INP x1
INP x2
OUT x2
OUT x1
BRA loop

Multiply each input by 8. This is the first step to understand how addition can be used for multiplication.

loop:
INP x1
ADD x1, x1
ADD x1, x1
ADD x1, x1
OUT x1
BRA loop

Sometimes you need multiple registers to achieve multipliation

loop:
INP x2
ADD x1, x2, x2
ADD x1, x2
OUT x1
BRA loop

Remove all the zeros. Early way to learn the use of branching

loop:
INP x1
BRZ x1, loop
OUT x1
BRA loop

Pick the largest of two numbers

loop:
INP x1
INP x2
SUB x1, x1, x2
BGT x1, first

second:
OUT x2
BRA loop

first:
OUT x1
BRA loop

The most primitive form of general multiplier. It picks two numbers at a time, multiplies them and outputs result.

loop:
INP x1
INP x2
CLR x3

multiply:
ADD x3, x1
DEC x2
BGT x2, multiply
OUT x3

BRA loop

The is program from original story, for how to multiple numbers.

Unlike the simple multiplier above we use a lot fewer iterations by using shifts. This speeds up the multiplication.

    INP x2  // first number to multiply. This will get added
INP x3 // second number. Treated as counter
CLR x1 // accumulator for result. Clear it out.

nextdigit:
RSH x4, x3, 1 // Push right most digit of x3 into x4

multiply:
ADD x1, x1, x2 // Add first input to accumulator
DEC x4 // Decrement counter for number of additions
BGT x4, multiply // Repeat while x4 > 0

LSH x2, x2, 1 // Left shift. x2 made 10x larger
BGT x3, nextdigit // check if all digits have been processed

OUT x1

Implementation of Calcutron-33

This made up CPU instruction set architecture now has a Julia package, Calcutron33.jl offering an assembler, disassembler and simulator.

It is still in early stages, but several of these example programs should work.

Written by

Geek dad, living in Oslo, Norway with passion for UX, Julia programming, science, teaching, reading and writing.

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store