What is TOY?

The TOY Machine

Basic Characteristics of TOY Machine TOY is a general-purpose computer.

 Sufficient power to perform ANY computation.

 Limited only by amount of memory and time.

Stored-program computer. (von Neumann memo, 1944)

 Data and instructions encoded in binary.

 Data and instructions stored in SAME memory.

John von Neumann

Maurice Wilkes (left) EDSAC (right)

All modern computers are general-purpose computers and have same (von Neumann/Princeton) architecture.

What is TOY?

An imaginary machine similar to:

 Ancient computers. (PDP-8, world's first commercially successful minicomputer.

1960s)

– 12-bit words

– 2K words of memory

– Used in Apollo project

What is TOY?

An imaginary machine similar to:

 Ancient computers.

 Today's microprocessors.

Pentium Celeron

What is TOY?

An imaginary machine similar to:

 Ancient computers.

 Today's microprocessors.

Why study TOY?

 Machine language programming.

– how do high-level programs relate to computer?

– a favor of assembly programming

 Computer architecture.

– how is a computer put together?

– how does it work?

 Optimized for understandability, not cost or performance.

Inside the Box

Switches. Input data and programs.

Lights. View data.

Memory.

 Stores data and programs.

 256 "words." (16 bits each)

 Special word for stdin / stdout.

Program counter (PC).

 An extra 8-bit register.

 Keeps track of next

instruction to be executed.

Registers.

 Fastest form of storage.

 Scratch space during computation.

 16 registers. (16 bits each)

 Register 0 is always 0.

Arithmetic-logic unit (ALU). Manipulate data stored in registers.

Standard input, standard output. Interact with

outside world.

Machine "Core" Dump

Machine contents at a particular place and time.

 Record of what program has done.

 Completely determines what machine will do.

0008 0005 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 8A00 8B01 1CAB 9C02 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000

0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 00:

08:

10:

18:

20:

28:

. . E8:

F0:

Main Memory pc

10

instructionnext

program Registers

0000 R2

0000 R3

0000 R8

0000 R9 R0

0000 R1

0000 RA

0000 RB 0000

0000 R6

0000 R7

0000 RC

0000 RD R4

0000 R5

0000 RE

0000 RF 0000

variables

data

Program and Data

Program: Sequence of instructions.

16 instruction types:

 16-bit word (interpreted one way).

 Changes contents of registers, memory, and

PC in specified, well-defined ways.

Data:

 16-bit word (interpreted other way).

Program counter (PC):

 Stores memory address of "next instruction.“

 TOY usually starts at address 10.

0: halt

Instructions

1: add

2: subtract 3: and

4: xor

5: shift left 6: shift right 7: load address 8: load

9: store

A: load indirect B: store indirect C: branch zero D: branch positive E: jump register F: jump and link

TOY Reference Card

0: halt

#

1: add 2: subtract 3: and

4: xor

5: shift left 6: shift right 7: load addr

exit(0)

R[d]  R[s] + R[t]

R[d]  R[s] - R[t]

R[d]  R[s] & R[t]

R[d]  R[s] ^ R[t]

R[d]  R[s] << R[t]

R[d]  R[s] >> R[t]

R[d]  addr 8: load

9: store

A: load indirect B: store indirect C: branch zero D: branch positive E: jump register

R[d]  mem[addr]

mem[addr]  R[d]

R[d]  mem[R[t]]

mem[R[t]]  R[d]

if (R[d] == 0) pc  addr if (R[d] > 0) pc  addr pc  R[t]

13 12 11 10

15 14 9 8 7 6 5 4 6 3 2 1 0

opcode dest d addr

opcode dest d source s source t

Format 2 Format 1

Operation Pseudocode

1 Fmt

1 1 1 1 1 1 2 2 2 1 1 2 2 1

Register 0 always 0.

Loads from mem[FF]

from stdin.

Stores to mem[FF] to stdout.

TOY Architecture (level 1)

level 0

Programming in TOY Hello, World. Add two numbers.

 Adds 8 + 5 = D.

A Sample Program A sample program.

 Adds 8 + 5 = D.

00: 0008 8 01: 0005 5

10: 8A00 RA  mem[00]

11: 8B01 RB  mem[01]

12: 1CAB RC  RA + RB 13: 9CFF mem[FF]  RC 14: 0000 halt

add.toy

Memory

Since PC = 10, machine interprets 8A00 as an instruction.

10 pc 0000

RC RA

0000 RB 0000

Registers

Load Load. (opcode 8)

 Loads the contents of some memory location into a register.

 8A00 means load the contents of memory cell ⁰⁰ into register ^A.

addr 0

13 0 12

1 11

0 10 1

15 0 14

0 7

? 6 1

9

0 8

0 6

0 4

0 1

0 0 0

3

0 2 0

5

8₁₆ A₁₆ 00₁₆

opcode dest d

00: 0008 8 01: 0005 5

10: 8A00 RA  mem[00]

11: 8B01 RB  mem[01]

12: 1CAB RC  RA + RB 13: 9CFF mem[FF]  RC 14: 0000 halt

add.toy

10 pc 0000

RC RA

0000 RB 0000

Registers

Load Load. (opcode 8)

 Loads the contents of some memory location into a register.

 8B01 means load the contents of memory cell ⁰¹ into register ^B.

0 0 1 0

1 0 1 1 0 0 0 0 ? 0 0 0 1

8₁₆ B₁₆

00: 0008 8 01: 0005 5

10: 8A00 RA  mem[00]

11: 8B01 RB  mem[01]

12: 1CAB RC  RA + RB 13: 9CFF mem[FF]  RC 14: 0000 halt

add.toy

01₁₆ 13 12 11 10

15 14 9 8 7 6 5 4 6 3 2 1 0

addr

opcode dest d

11 pc 0000

RC RA

0000 RB 0008

Registers

Add Add. (opcode 1)

 Add contents of two registers and store sum in a third.

 1CAB adds the contents of registers ^A and ^B and put the result into register ^C.

source s

0 1 1 1

0 0 0 0 1 0 1 0 ? 1 0 1 1

1₁₆ C₁₆ A₁₆ B₁₆

opcode dest d source t

00: 0008 8 01: 0005 5

10: 8A00 RA  mem[00]

11: 8B01 RB  mem[01]

12: 1CAB RC  RA + RB 13: 9CFF mem[FF]  RC 14: 0000 halt

add.toy

13 12 11 10

15 14 9 8 7 6 5 4 6 3 2 1 0

12 pc 0000

RC RA

0005 RB 0008

Registers

Store Store. (opcode 9)

 Stores the contents of some register into a memory cell.

 9CFF means store the contents of register ^C into memory cell ^FF (stdout).

addr

0 1 1 1

1 0 0 0 0 0 0 0 ? 0 0 1 0

9₁₆ C₁₆

opcode dest d

00: 0008 8 01: 0005 5

10: 8A00 RA  mem[00]

11: 8B01 RB  mem[01]

12: 1CAB RC  RA + RB 13: 9CFF mem[FF]  RC 14: 0000 halt

add.toy

02₁₆ 13 12 11 10

15 14 9 8 7 6 5 4 6 3 2 1 0

13 pc 000D

RC RA

0005 RB 0008

Registers

Halt Halt. (opcode 0)

 Stop the machine.

00: 0008 8 01: 0005 5

10: 8A00 RA  mem[00]

11: 8B01 RB  mem[01]

12: 1CAB RC  RA + RB 13: 9CFF mem[FF]  RC 14: 0000 halt

add.toy

14 pc 000D

RC RA

0005 RB 0008

Registers

Simulation Consequences of simulation.

 Test out new machine or microprocessor using simulator.

– cheaper and faster than building actual machine

 Easy to add new functionality to simulator.

– trace, single-step, breakpoint debugging

– simulator more useful than TOY itself

 Reuse software from old machines.

Ancient programs still running on modern computers.

 Lode Runner on Apple IIe.

 Gameboy simulator on PCs.

Interfacing with the TOY Machine To enter a program or data:

 Set 8 memory address switches.

 Set 16 data switches.

 Press LOAD.

– data written into addressed word of memory

To view the results of a program:

 Set 8 memory address switches.

 Press LOOK: contents of addressed word appears in lights.

Using the TOY Machine: Run To run the program:

 Set 8 memory address switches to address of first instruction.

 Press LOOK to set PC to first instruction.

 Press RUN button to repeat fetch-execute cycle until halt opcode.

Fetch

Execute

Branch in TOY

To harness the power of TOY, need loops and conditionals.

 Manipulate PC to control program flow.

Branch if zero. (opcode C)

 Changes PC depending of value of some register.

 Used to implement: ^for, ^while, ^if-^else.

Branch if positive. (opcode D)

 Analogous.

An Example: Multiplication Multiply.

 No direct support in TOY hardware.

 Load in integers a and b, and store c = a  b.

 Brute-force algorithm:

– initialize c = 0

– add b to c, a times

Issues ignored: slow, overflow, negative numbers.

int a = 3;

int b = 9;

int c = 0;

while (a != 0) { c = c + b;

a = a - 1;

}

Java

Multiply

int a = 3;

int b = 9;

int c = 0;

while (a != 0) { c = c + b;

a = a - 1;

}

0A: 0003 3 0B: 0009 9 0C: 0000 0

0D: 0000 0 0E: 0001 1

10: 8A0A RA  mem[0A] a

11: 8B0B RB  mem[0B] b

12: 8C0D RC  mem[0D] c = 0

13: 810E R1  mem[0E] always 1

14: CA18 if (RA == 0) pc  18 while (a != 0) {

15: 1CCB RC  RC + RB c = c + b

16: 2AA1 RA  RA - R1 a = a - 1

17: C014 pc  14 }

18: 9CFF mem[FF]  RC 19: 0000 halt

Multiply

loop

inputs

constants output

R1 RA RB RC

10: 8A0A RA  mem[0A] 0003

11: 8B0B RB  mem[0B] 0009

12: 8C0D RC  mem[0D] 0000

13: 810E R1  mem[0E] 0001

14: CA18 if (RA == 0) pc  18

15: 1CCB RC  RC + RB 0009

16: 2AA1 RA  RA – R1 0002

17: C014 pc  14

14: CA18 if (RA == 0) pc  18

15: 1CCB RC  RC + RB 0012

16: 2AA1 RA  RA – R1 0001

17: C014 pc  14

14: CA18 if (RA == 0) pc  18

15: 1CCB RC  RC + RB 001B

16: 2AA1 RA  RA – R1 0000

17: C014 pc  14

14: CA18 if (RA == 0) pc  18 18: 9CFF mem[FF]  RC

19: 0000 halt

Step-By-Step Trace

multiply.toy

An Efficient Multiplication Algorithm Inefficient multiply.

 Brute force multiplication algorithm loops a times.

 In worst case, 65,535 additions!

"Grade-school" multiplication.

 Always 16 additions to multiply 16-bit integers.

1 1 1 1 0 1 0

1 0 1 1 1

0 0 0 0

1 1 0 1

1 1 0 1

0 0 0 1

*

1 1 1 1 4

2 8 3

1 6 2 5 4 1 1 2

4 3 2 1

0 7 1 6

4 3 2 1

6 8 1 0

*

8 0 8 5

Decimal Binary

Binary Multiplication

Grade school binary multiplication algorithm to compute c = a  b.

 Initialize c = 0.

 Loop over i bits of b.

– if b_i = 0, do nothing

– if b_i = 1, shift a left i bits and add to c

Implement with built-in TOY shift instructions.

1 1 1 1 0 1 0

1 0 1 1 1

0 0 0 0

1 1 0 1

1 1 0 1

0 0 0 1

*

1 1 1 1

a b

c a << 3 a << 2 a << 0 b_i = i^th bit of b

int c = 0;

for (int i = 15; i >= 0; i--) if (((b >> i) & 1) == 1)

c = c + (a << i); b_i = i^th bit of b

Shift Left Shift left. (opcode 5)

 Move bits to the left, padding with zeros as needed.

 1234₁₆ << 7₁₆ = 1A00₁₆

0 1 0 0

0 0 1 0 0 0 1 1 0 1 0 0

1₁₆ 2₁₆ 3₁₆ 4₁₆

0 1 1 0

0 0 1 0 0 0 0 0 0 0 0 0

1₁₆ A₁₆ 0₁₆ 0₁₆

<< 7

discard

pad with 0’s

Shift Right Shift right. (opcode 6)

 Move bits to the right, padding with sign bit as needed.

 1234₁₆ >> 7₁₆ = 0024₁₆

0 1 0 0

0 0 1 0 0 0 1 1 ? 0 1 0 0

1₁₆ 2₁₆ 3₁₆ 4₁₆

0 0 0 0

0 0 0 0 0 0 1 0 0 1 0 0

0₁₆ 0₁₆ 2₁₆ 4₁₆

>> 7

discard

pad with 0’s sign bit

Shift Right (Sign Extension) Shift right. (opcode 6)

 Move bits to the right, padding with sign bit as needed.

 FFCA₁₆ >> 2₁₆ = FFF2₁₆

 -53₁₀ >> 2₁₀ = -13₁₀

1 1 1 1

1 1 1 1 1 1 0 0 1 0 1 0

F₁₆ F₁₆ C₁₆ A₁₆

1 1 1 1

1 1 1 1 1 1 1 1 0 0 1 0

F₁₆ F₁₆ F₁₆ 2₁₆

>> 2

discard

pad with 1s sign bit

Bitwise AND Logical AND. (opcode 3)

 Logic operations are BITWISE.

 0024₁₆ & 0001₁₆ = 0000₁₆

0 0 0 0

0 0 0 0 0 0 0 0 ? 0 0 0 1

0₁₆ 0₁₆ 0₁₆ 1₁₆

0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

0₁₆ 0₁₆ 0₁₆ 0₁₆

0 0 0 0

0 0 0 0 0 0 1 0 ? 0 1 0 0

0₁₆ 0₁₆ 2₁₆ 4₁₆

&

=

x y ^AND

0 0 0

0 1 0

1 0 0

1 1 1

Shifting and Masking

Shift and mask: get the 7

bit of

.

 Compute ¹²³⁴16 >> 7₁₆ = 0024₁₆.

 Compute ⁰⁰²⁴16 && 1₁₆ = 0₁₆.

0 1 0 0

0 0 1 0 0 0 1 1 ? 0 1 0 0

1₁₆ 2₁₆ 3₁₆ 4₁₆

0 0 0 0

0 0 0 0 0 0 1 0 0 1 0 0

0₁₆ 0₁₆ 2₁₆ 4₁₆

>> 7

&

0 0 0 0

0 0 0 0 0 0 0 0 ? 0 0 0 1

0₁₆ 0₁₆ 0₁₆ 1₁₆

0 0 0 0

0 0 0 0 0 0 0 0 0 0 0 0

0 0 0 0

=

Binary Multiplication

int c = 0;

for (int i = 15; i >= 0; i--) if (((b >> i) & 1) == 1)

c = c + (a << i);

Binary Multiplication

0A: 0003 3 0B: 0009 9 0C: 0000 0 0D: 0000 0 0E: 0001 1 0F: 0010 16

10: 8A0A RA  mem[0A] a

11: 8B0B RB  mem[0B] b

12: 8C0D RC  mem[0D] c = 0 13: 810E R1  mem[0E] always 1 14: 820F R2  mem[0F] i = 16

do {

15: 2221 R2  R2 - R1 i--

16: 53A2 R3  RA << R2 a << i 17: 64B2 R4  RB >> R2 b >> i

18: 3441 R4  R4 & R1 b_i = i^th bit of b 19: C41B if (R4 == 0) goto 1B if b_i is 1

1A: 1CC3 RC  RC + R3 add a << i to sum 1B: D215 if (R2 > 0) goto 15 } while (i > 0);

1C: 9CFF mem[FF]  RC multiply-fast.toy

16 bit words loop

branch

constants inputs output

Useful TOY "Idioms"

Jump absolute.

 Jump to a fixed memory address.

– branch if zero with destination

– register 0 is always 0

Register assignment.

 No instruction that transfers contents of one register into another.

 Pseudo-instruction that simulates assignment:

– add with register 0 as one of two source registers

No-op.

 Instruction that does nothing.

 Plays the role of whitespace in C programs.

– numerous other possibilities!

17: C014 pc  14

17: 1230 R[2]  R[3]

17: 1000 no-op

Standard Input and Output: Implications Standard input and output enable you to:

 Process more information than fits in memory.

 Interact with the computer while it is running.

Standard output.

 Writing to memory location ^FF sends one word to TOY stdout.

 9AFF writes the integer in register ^A to stdout.

Standard input.

 Loading from memory address ^FF loads one word from TOY stdin.

 8AFF reads in an integer from stdin and store it in register ^A.

Fibonacci Numbers

Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, . . .

F_n 

0 if n 0

1 if n 1

F_n1 F_n2 otherwise







Standard Output

00: 0000 0 01: 0001 1

10: 8A00 RA  mem[00] a = 0 11: 8B01 RB  mem[01] b = 1 do {

12: 9AFF print RA print a

13: 1AAB RA  RA + RB a = a + b 14: 2BAB RB  RA - RB b = a - b 15: DA12 if (RA > 0) goto 12 } while (a > 0) 16: 0000 halt

0000 0001 0001 0002 0003 0005 0008 000D 0015 0022 0037 0059 0090 00E9 0179 0262 03DB 063D 0A18 1055 1A6D 2AC2 452F 6FF1 fibonacci.toy

Standard Input

Ex: read in a sequence of integers and print their sum.

 In Java, stop reading when EOF.

 In TOY, stop reading when user enters ⁰⁰⁰⁰.

while(!StdIn.isEmpty()) { a = StdIn.readInt();

sum = sum + a;

}

System.out.println(sum);

00: 0000 0

10: 8C00 RC <- mem[00]

11: 8AFF read RA

12: CA15 if (RA == 0) pc  15 13: 1CCA RC  RC + RA

14: C011 pc  11 15: 9CFF write RC 16: 0000 halt

00AE 0046 0003 0000 00F7

addr

Load Address (a.k.a. Load Constant) Load address. (opcode 7)

 Loads an 8-bit integer into a register.

 7A30 means load the value ³⁰ into register ^A.

Applications.

 Load a small constant into a register.

 Load a 8-bit memory address into a register.

– register stores "pointer" to a memory cell

1 13

1 12

1 11

0 10 0

15 1 14

0 7

? 6 1

9

0 8

0 6

1 4

0 1

0 0 0

3

0 2 1

5

7₁₆ A₁₆ 3₁₆ 0₁₆

opcode dest d

a = 30;

Java code

Arrays in TOY

TOY main memory is a giant array.

 Can access memory cell ³⁰ using load and store.

 8C30 means load ^mem[30] into register ^C.

 Goal: access memory cell ⁱ where ⁱ is a variable.

Load indirect. (opcode A)

 AC06 means load ^mem[R6] into register ^C.

Store indirect. (opcode B)

 BC06 means store contents of register ^C into

mem[R6].

for (int i = 0; i < N; i++) a[i] = StdIn.readInt();

for (int i = 0; i < N; i++)

System.out.println(a[N-i-1]);

Reverse.java a variable index

a variable index (like a pointer)

TOY Implementation of Reverse TOY implementation of reverse.

 Read in a sequence of integers and store in memory

30, ³¹, ³², …

 Stop reading if ⁰⁰⁰⁰.

 Print sequence in reverse order.

TOY Implementation of Reverse TOY implementation of reverse.

 Read in a sequence of integers and store in memory

30, ³¹, ³², …

 Stop reading if ⁰⁰⁰⁰.

 Print sequence in reverse order.

10: 7101 R1  0001 constant 1

11: 7A30 RA  0030 a[]

12: 7B00 RB  0000 n

while(true) {

13: 8CFF read RC c = StdIn.readInt();

14: CC19 if (RC == 0) goto 19 if (c == 0) break;

15: 16AB R6  RA + RB address of a[n]

16: BC06 mem[R6]  RC a[n] = c;

17: 1BB1 RB  RB + R1 n++;

18: C013 goto 13 }

read in the data

TOY Implementation of Reverse TOY implementation of reverse.

 Read in a sequence of integers and store in memory

30, ³¹, ³², …

 Stop reading if ⁰⁰⁰⁰.

 Print sequence in reverse order.

19: CB20 if (RB == 0) goto 20 while (n > 0) { 1A: 16AB R6  RA + RB address of a[n]

1B: 2661 R6  R6 – R1 address of a[n-1]

1C: AC06 RC  mem[R6] c = a[n-1];

1D: 9CFF write RC System.out.println(c);

1E: 2BB1 RB  RB – R1 n--;

1F: C019 goto 19 }

20: 0000 halt print in reverse order

Unsafe Code at any Speed

What happens if we make array start at

instead of

?

 Self modifying program.

 Exploit buffer overrun and run arbitrary code!

10: 7101 R1  0001 constant 1

11: 7A00 RA  0000 a[]

12: 7B00 RB  0000 n

while(true) {

13: 8CFF read RC c = StdIn.readInt();

14: CC19 if (RC == 0) goto 19 if (c == 0) break;

15: 16AB R6  RA + RB address of a[n]

16: BC06 mem[R6]  RC a[n] = c;

17: 1BB1 RB  RB + R1 n++;

18: C013 goto 13 }

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 8888 8810

98FF C011

Crazy 8s Input

#include <stdio.h>

int main(void) {

char buffer[100];

scanf("%s", buffer);

printf("%s\n", buffer);

return 0;

}

Buffer overrun.

 Array ^buffer[] has size 100.

 User might enter 200 characters.

 Might lose control of machine behavior.

 Majority of viruses and worms caused by similar errors.

Robert Morris Internet Worm.

 Cornell grad student injected worm into Internet in 1988.

 Exploited buffer overrun in finger daemon fingerd.

What Can Happen When We Lose Control?

unsafe C program

Function Call: A Failed Attempt Goal: x  y  z.

 Need two multiplications: x  y, (x  y)  z.

 Solution 1: write multiply code 2 times.

 Solution 2: write a TOY function.

A failed attempt:

 Write multiply loop at 30-36.

 Calling program agrees to store arguments in registers A and B.

 Function agrees to leave result in register C.

 Call function with jump absolute to 30.

 Return from function with jump absolute.

Reason for failure.

 Need to return to a VARIABLE memory address.

10: 8AFF 11: 8BFF 12: C030 13: 1AC0 14: 8BFF 15: C030 16: 9CFF 17: 0000 30: 7C00 31: 7101 32: CA36 33: 1CCB 34: 2AA1 35: C032 36: C013?

function?

Multiplication Function Calling convention.

 Jump to line 30.

 Store a and b in registers A and B.

 Return address in register F.

 Put result c = a  b in register C.

 Register 1 is scratch.

 Overwrites registers A and B.

30: 7C00 R[C]  00 31: 7101 R[1]  01

32: CA36 if (R[A] == 0) goto 36 33: 1CCB R[C] += R[B]

34: 2AA1 R[A]-- 35: C032 goto 32

 R[F]

function.toy

return

opcode E

jump register

10: 8AFF 11: 8BFF 12: FF30 13: 1AC0 14: 8BFF 15: FF30 16: 9CFF 17: 0000 30: 7C00 31: 7101 32: CA36 33: 1CCB 34: 2AA1 35: C032 36: EF00 function

Multiplication Function Call Client program to compute x  y  z.

 Read x, y, z from standard input.

 Note: PC is incremented before instruction is executed.

– value stored in register F is correct return address

10: 8AFF read R[A] x

11: 8BFF read R[B] y

12: FF30 R[F]  pc; goto 30 x * y 13: 1AC0 R[A]  R[C] (x * y)

14: 8BFF read R[B] z

15: FF30 R[F]  pc; goto 30 (x * y) * z 16: 9CFF write R[C]

17: 0000 halt

function.toy (cont)

opcode F

jump and link

R[F]  16 R[F] 

13

Function Call: One Solution Contract between calling program and function:

 Calling program stores function parameters in specific registers.

 Calling program stores return address in a specific register.

– jump-and-link

 Calling program sets PC to address of function.

 Function stores return value in specific register.

 Function sets PC to return address when finished.

– jump register

What if you want a function to call another function?

 Use a different register for return address.

 More general: store return addresses on a stack.

Virtual machines

High-Level Language

Assembly Language

Operating System

Instruction Set Architecture

Microarchitecture

Digital Logic

Level 0 Level 1 Level 2 Level 3 Level 4 Level 5

Abstractions for computers

Problems with programming using machine code

 Difficult to remember instructions

 Difficult to remember variables

 Hard to calculate addresses/relocate variables or functions

 Need to handle instruction encoding

Virtual machines

High-Level Language

Assembly Language

Operating System

Instruction Set Architecture

Microarchitecture

Digital Logic

Level 0 Level 1 Level 2 Level 3 Level 4 Level 5

Abstractions for computers