Computers’ Basic Organization Von Neumann model MIPS programming model Registers Memory ALU Control Unit I/O Textbook: Appendix A .

C program to explain the Von Neumann model #include <stdio.h>   unsigned char array[1024]; unsigned char a,b,c; // temporary variables int i1,i2,j; // array indexes for operands and result char operation; // which operation to do int main() { printf( "Enter the operation sign +, -, /, * \n" ); scanf( "%c", &operation ); printf( "Enter the first operand's index in array \n" ); scanf( "%d", &i1 ); printf( "Enter the second operand's index in array \n" ); scanf( "%d", &i2 ); printf( "Enter the result's index in array \n" ); scanf( "%d", &j ); a = array[i1]; b = array[i2]; switch (operation) case '+': c = a+b; break; case '-': c = a-b; case '/': c = a/b; case '*': c = a*b; } array[j] = c; return 0; We have an array of bytes – this is similar to computer random access memory (RAM). It holds bytes’ values. It could be addressed – in our case for 1024 byte memory the addresses are from 0 to 1023. We can write into the array and read from it like with the memory. Variables – are similar to registers: They hold temporary values of operands after reading of the memory and hold the result before writing to memory. Operations are done with the variables (like with the registers). Input output results are kept in variables. Switch block decodes the operation like Control Unit and launches appropriate operation. The operation statements - similar to Arithmetic Logic Unit. ALU performs operations on the operands (registers) and writes the result back to variable (register). This simple C program by its behavior will help us to understand computer general organization. We should find here 5 main components of Von Neumann architecture: Memory Registers Control Unit ALU Input / Output Printf(), Scanf() – similar to Input / Output blocks. The input output is done through the registers (variables).

Von Neumann model Memory: keeps the program code and data. The other units periodically refer to memory to fetch (load) the data or program or to write (store) some information. Control Unit (CU): fetches instructions from memory decodes them to produce signals which control the other parts of the computer. transfers data between memory and ALU activates peripherals to perform input or output. Arithmetic and Logic Unit (ALU): performs operations such as addition, subtraction, multiplication of integers bit-wise AND, OR, NOT and other Boolean operations. Registers ( Accumulator): The data exchange between ALU, Memory and Input/Output is done through the Registers Registers are the memory which have the fastest access for CPU instructions. Input and Output devices are used when there is need to exchange information with the outside world. The Control Unit and ALU are included in single device called Central Processing Unit (CPU).

What is CPU and datapath ? Processor (CPU): the active part of the computer that does all the work (data manipulation and decision-making) Datapath: portion of the processor that contains hardware necessary to perform operations required by the processor (the brawn) Control: portion of the processor (also in hardware) that tells the datapath what needs to be done (the brain)

Harvard architecture physically separate storage and signal pathways for instructions and data. Allows high performance. Complex to implement 2 memories are needed Von Neumann bottleneck often limits the performance of the system But is simple to implement as only one memory is needed for both instructions and data

MIPS Programming Model A programming model is an abstract view of a processor that is appropriate for programming but omits details that are not needed for that task. It is the view of the machine a programmer uses when programming. Based on this model we can suppose the existence of several groups of MIPS instructions: Inter Register transfer instructions. Memory - register transfer instructions. Input / output instructions. Arithmetic or Logical instructions with registers.

Another MIPS programming model from the textbook MIPS contains: Integer arithmetic processor Floating point arithmetic processor Whole system’s Control Processor In this model from the textbook we can see several additional groups of MIPS instructions : Integer Multiplication Division instructions. Floating point arithmetic instructions. System Control instructions We have to learn all components of the model separately and all instructions and groups in details.

Assembly variables: Registers Assembly Operands are registers A register is a part of the processor that can hold a bit pattern operations can only be performed on these registers. Assembly – registers, Languages - local variables Local variables in C and Java can be unlimited and can have different length Registers in Assembly limited, same length. The Hardware should be simple. It’s impossible to create unlimited amount of unknown types of bit containers in the hardware. Benefit: Since registers are directly in hardware, they are very fast Registers are the memory which have the fastest access for CPU instructions. Drawback: Since registers are in hardware, there are a predetermined number of them Solution: MIPS code must be very carefully put together to efficiently use registers

General Purpose Registers A group of registers that are visible in MIPS assembly language are called general purpose registers. There are 32 general purpose registers. Why 32 ? More registers - less operations with memory . Each general purpose register holds a 32 bit pattern. Groups of 32 bits called a word in MIPS

Registers – Names and Numbers Each register can be referred to by number or name Registers are numbered from 0 to 31 Number references: $0, $1, $2, … $30, $31 By convention, each register also has a name to make it easier to code The names make your code more readable For example: $16 - $23  $s0 - $s7 (saved registers – more close to local variables in C) $8 - $15  $t0 - $t7 (temporary registers – more close to global variables in C) One of the general purpose registers, Register $0, is hard-wired to always contain the value 0x00000000 (all zero bits).

Registers have no type. In C (and most High Level Languages) variables declared first and given a type Example: int fahr, celsius; char a, b, c, d, e; Each variable can ONLY represent a value of the type it was declared as (cannot mix and match int and char variables). In Assembly Language, the registers have no type; operation or a program determines how register contents are treated

Register use convention