NAR 1

NAR 1 or just NAR (Serbian Nastavni Računar, en. Educational Computer) was a theoretical model of a computer created by Faculty of Mathematics of University of Belgrade professor Nedeljko Parezanović (In Serbian:Недељко Парезановић). It was used for Assembly language and Computer architecture courses.

Specifications
NAR 1 central processing unit has a 5-bit address bus (32 bytes of addressable memory) and 8-bit data bus. Machine instructions were single-byte with three most significant bits specifying the opcode and 5 least significant bits the parameter - memory address. A single 8-bit accumulator register was available and there were no flags or flag registers. Only absolute addressing mode was available and all others were achieved by self-modifying code.

Even though this is only a theoretical computer the following physical characteristics were given:


 * Memory cycle: 1μs
 * Arithmetic operation (SABF) cycle: 0.9μs (900ns)
 * Control panel facilitates power on and off, memory data entry and readout, instruction counter entry and selection of either program execution mode or control panel mode.

Instruction coding and set

 * SABF (001aaaaa, sr. Saberi u Fiksnom zarezu, en. Add Fixed point) loads the content of memory location specified by the address parameter, adds it to the current value of the accumulator and stores the result into the accumulator
 * PZAF (010xxxxx, sr. Promeni Znak Akumulatora u Fiksnom zarezu, en. Change the sign of the accumulator in fixed point) Negates the fixed point (such as integer) value in the accumulator
 * AUM (011aaaaa, sr. Akumulator U Memoriju, en. Accumulator Into Memory) stores the content of the accumulator into memory location specified by the address parameter
 * MUA (100aaaaa, sr. Memorija U Akumulator, en. Memory Into Accumulator) loads the content of memory location specified by the address parameter into the accumulator
 * NES (101aaaaa, sr. Negativni Skok, en. Negative Jump) performs a conditional jump to the address specified by the parameter if the current value of the accumulator is negative
 * ZAR (110xxxxx, sr. Zaustavi Računar, en. Stop the Computer) stops any further processing.

Two more instructions were not specified but were commonly present in simulators and took instruction codes 000aaaaa and 111aaaaa:
 * BES (sr. Bezuslovni Skok, en. Unconditional Jump) performs an unconditional jump to the address specified by the parameter
 * NUS (sr. Nula-Skok, en. Zero Jump) performs a conditional jump to the address specified by the parameter if the current value of the accumulator is zero

Example programs
A sample program that sums up an array of 8-bit integers:

Above program adds up to 22 8-bit values if executed from address 22:
 * Values 1-21 stored at locations 1-21
 * Value 22 stored at location 0, instead of the constant 0 and will be replaced by the result

NAR 1 programs are commonly self-modifying. Unlike in some other architectures, this is not a 'trick'. As memory can not be addressed by a register, the only way to dynamically manipulate memory data is to modify memory manipulation instructions. Above example also contains a typical trick to save memory - instruction (at address 30) is reused as data by another instruction (at address 28).

If initial accumulator value can be controlled from the control pane, a 23rd value can be stored in it. Above program has to be only slightly modified - instruction SABF 1 at address 23 has to be changed to SABF 0 and the program should be executed from that address (23) and not from 22.

Other tricks included the use of the changes of the sign after instruction is modified, as shown in the following example:

Here the instruction "MUA 21" at address 23 has the binary value 10010101, which is -107 decimal when treated like signed integer in two's complement. Instructions at addresses 26, 27 and 28 decrement this value by 1 in each iteration. This will modify the 5 least significant bits specifying the address and will not touch the three bits indicating the instruction until that instruction becomes MUA 0 (10000000 binary = -128 decimal, negative). Once this is decremented by one it becomes 01111111 (+127 decimal) which is no longer negative and will cause the jump-if-negative instruction at 29 to pass, proceeding to "stop the computer" at 30.

Similarly to above, this program can add between 22 and 24 values, depending on whether address 22 can be used for both input and output and whether initial value of the accumulator can be used as input (the program should then be executed from address 24 and instruction at 23 should be MUA 22).

If particular implementation stops the computer if it encounters an unknown opcode or it implements additional unconditional jump instruction with opcode "111aaaaa", then such behaviour can be used as follows:

Above, the value of "-1" found at address 31 can either be treated as invalid instruction causing the computer to stop or as unconditional jump (BES 31) to the same address, resulting in infinite loop that does not affect the result (control panel can be used to display it).

Finally, depending on whether it is decided that a computer will stop program execution if it reaches the end of memory (address 31, will not roll back to address 0), above program can be reorganized to take one value more by eliminating the need for "stop the computer" instruction altogether, as follows:

Trivia

 * Word "nar" means Teaching computer model
 * Many NAR 1 simulators were created. One was named "Šljiva" (en. plum) as that fruit grows in Serbia, while "nar" does not.
 * One of frequently given task was to create a program that adds as many numbers as possible, having those numbers stored in 32-byte memory along with the program.
 * Some assembly language protocols are derived from the NAR1 khulil code