CSC 3210 Notes Computer Organization and Programming

1. CSC 3210 NotesComputer Organization and Programming Chapter 1 Dr. Anu Bourgeois

2. Layout of Chapter 1 Hand-programmable calculator Fundamental definition of a computer Basic computer cycle Classic implementations of the computer Stack machine architecture Accumulator machine architecture Load/store machine architecture

3. Programmable Calculators Numeric keyboard and function keys Single register – accumulator Arithmetic logic unit – for computations Stack provides memory LIFO data structure Pushing/popping operations No addresses for the memory cells

4. HP-15C Programmable Calculator

5. Postfix vs. Infix Postfix notation Operators follow operands 3 4 + Uses the stack to save memory No need for parenthesis Infix notation Operators are between operands 3 + 4 Need to specify order of operations -- parenthesis

6.  

8. Stack Operations

9. Use of Registers Registers are provided to hold constants 10 registers – r0 thru r9 3.14159 sto 0 – stores value in r0 and leaves it on top of stack rcl 0 -- copy contents of r0 to top of stack Must specify register name

10. Programmable Calculators In program mode, keystrokes not executed, code for each key is stored in memory Memory has an address and holds data Principal key designation Function keys Machine language – codes for keystrokes Central processing unit Program counter – holds address of next instruction to be executed

11.   10 enter 1 – 10 enter 7 – * 10 enter 11 – / sto 0   1 –   rcl 0  7 –  *    // type in particular value for x  rcl 0  // execute program to compute y  11 –  /  g rtn 

12. Memory used to store program  Memory is addressed  May compute memory addresses – unlike registers  Registers may be selected – not indexed    struct registers {   int r0, r1, r2, r3, r4, r5, r6, r7, r8, r9;  } 

13. Machine language • Program stored using machine language – key codes of the calculator • Central processing unit (CPU) executes the codes  • Program counter (PC) holds address of next  instruction to be executed 

15. • Calculator mode – codes (m/c lang.) sent to ALU  • Program mode – codes (m/c lang.) sent to memory   

16. Macros  • Macro processor m4 – translates symbols into numeric constants  Macros defined using define macro – two  arguments    define(sto, 44 0)  define(rcl, 45 0)  define(div, 10) 

17. Macros may have up to 9 arguments  • Specify arguments by $n   • If macro name followed immediately by ‘(‘, then arguments are present  define(cat, $1$2$3$4$5)    call it by: cat(a, b , c,   d, e)  ? ab cde  call it by: cat(a , b , c)   ? a b c 

19. define(f, 42)  define(g, 43)  define(loc, 0)  define(sto, ‘loc: 44 $1 define(‘loc’, eval(loc + 2))’)  define(rcl, ‘loc: 45 $1 define(‘loc’, eval(loc + 2))’)  define(div, ‘loc: 10 define(‘loc’, eval(loc + 1))’)  define(mul, ‘loc: 20 define(‘loc’, eval(loc + 1))’) 

20. Von Neumann Machine • Contains addressable memory for instructions and data  • ALU executes instructions fetched from memory  • PC register holds address for next instruction to execute  Defined an instruction cycle 

21. Von Neumann Model

22. Instruction Cycle pc = 0;  do {  instruction = memory[pc++];  decode (instruction);  fetch (operands);  execute;  store (results);  } while (instruction != halt); 

23. Stack Machine Stack architecture does not have registers  Use memory to place items onto stack  Use load and store operations for moving data between memory and the stack  Must specify memory address  MAR – memory address register  MDR – memory data register  IR – instruction register holds fetched instruction  ALU uses top two elements on the stack for all computations 

24. Stack Machine Assume address 300 holds the value 3 and address 400 holds the value 4 push [300] push [400] add pop [300]

25. Accumulator Machine Accumulator register used as source operand and destination operand Use load and store operations to move data from accumulator from/to memory No registers or stack Must access memory often

26. Accumulator Machine Assume address 300 holds the value 3 and address 400 holds the value 4 load 300 add 400 store 300

27. Load Store Machine Initially memory limited to few hundred words  Access time to all locations was the same  As memory size increased time vs. cost issue arose  New designs included variable access times  Register file – high speed memory 

28. Load Store Machine Use load and store instructions between registers and memory  ALU would function on registers only  Register file replaces the stack of the stack machine  SPARC architecture is a load/store machine 

29. Load Store Machine Assume address 300 holds the value 3 and address 400 holds the value 4 load [300], r0 load [400], r1 add r0, r1, r0 store r0, [300]

30. Assemblers An assembler is a macro processor to translate symbolic programs into machine language programs  Symbols may be used before they are defined – unlike using m4  Two pass process   Once to determine all symbol definitions  Once to apply the definitions 

31. Symbols A symbol followed by a colon defines the symbol to have as its value the current value of the location counter  The symbol is called a label