- 49 Views
- Uploaded on
- Presentation posted in: General

A Working Computer

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

A Working Computer

Slides based on work by Bob Woodham and others

By the end of this unit, mostly from the lab, you should be able to:

- Trace execution of an instruction through our computer: the basic fetch-decode-execute instruction cycle and the data flow to/from the arithmetic logic unit (ALU), the main memory, the Instruction Register (IR) and the Program Counter (PC) under control of the microController, down to individual wires and gates.

Discuss point of learning goals.

Theory

Hardware

How do we build devices to compute?

Now: Done! A full working computer!

How do we model computational systems?

Now: Not really a theory show…

Instead of a new DFA circuit for each problem:

- Make a DFA with “instructions” as input.
- Design a set of instructions that combine to solve many problems
- Solve new tasks with new instructions, not a new circuit.

With appropriate instructions, this design is “universal”: it can perform any conceivable computation. (We won’t prove this, but we did see it implement basic Java instructions!)

DFA with a bunch of states and with output on arcs

Sequence ofoutputs

Sequence of inputs

clk

DFA with LOTS of states and output on arcs

Sequence ofoutputs

clk

A stored-program computer includes data and code in its memory.Load memory with code/data and start the machine, and it “acts out” its program.

Load new code/data, and restart, and it “acts out” a totally different program!

A stored-program computer can simulate any other computer that we can now practically or theoretically envision!

Memory:

code and data

Next instructionand data

CombinationalCircuitry, esp.

ALU and controller

Updatesto addressand newdata

Data to use in next instruction

Data to store back in memory

Accumulator (ACC)

Address of next instruction

Program Counter (PC)

ACC and PC are “registers”: extra little pieces of fast memory.

From the bottom up...

- we can build digital logic in physical devices (remember the water computers and switches?)
- we can use logic gates to organize our digital circuits
- we can organize logic gates into combinational circuits that calculate any logical function of their inputs (any truth table)
- we can use feedback to create sequential circuits that remember values and act on events
- we can implement any DFA using a sequential circuit
- we can build a working computer: a DFA with configurable memory that determines its own next instruction, which can perform any conceivable computation

Wow! Too bad it’s a pain in the butt to program in our computer’s language!

If only...

From the top down:

- we can design algorithms to solve an enormous variety of computational problems
- we can encode those algorithms into programs in high-level programming languages
- compilers and interpreters can automatically transform those programs into low-level programming languages

Any guesses what those low-level programming languages might look like?

Here’s one we already saw...

Part of our Java code:

// Let's do something a hundred times.

int i = 100;

do {

// Make i one smaller.

i--;

} while (i > 0);

Here’s a typical “hex” view of ~1/5th of the program’s byte code.

High-level languages all the way down to physical devices that compute.

What’s left? HUGE TREMENDOUS AMAZING AMOUNTS OF STUFF:

Software engineering: implementing incredibly complex systems as programs and helping programmers manage that complexity.

Human-computer interaction: understanding how people work with computers and designing interfaces that are effective for them.

Systems: building structures on top of the machine that knit computers together and let people and programs communicate and collaborate effectively.

Artificial intelligence: recognizing, extracting, and acting on high-level patterns in complex and meaningful ways.

Theory: analyzing the capabilities and limitations of computing systems to accomplish all of these tasks.

Computer engineering: redesigning the machine to more efficiently (in terms of speed, power consumption, size, memory usage, etc.) execute programs. (And so on...)

By the end of this unit, mostly from the lab, you should be able to:

- Trace execution of an instruction through our computer: the basic fetch-decode-execute instruction cycle and the data flow to/from the arithmetic logic unit (ALU), the main memory, the Instruction Register (IR) and the Program Counter (PC) under control of the microController, down to individual wires and gates.

Discuss point of learning goals.

Extra Slides

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

SOMETHING that can run on a bare bones computer??

???

in a memory that is just a numbered list of locations.

x

(int)

y

(int)

5

1

Pick “slots” for x and y, say memory locations 0x100 and 0x101:

x

(int)

y

(int)

5

1

0x000

0x001

.

.

.

0x0FF

0x100

0x101

.

.

5

1

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Start translating

??

??

??

??

??

??

??

??

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Start translating

// Note: x is in 100

// Note: y is in 101

??

??

??

??

??

??

ADD addr: ACC = ACC + M[addr]

SUB addr: ACC = ACC - M[addr]

MUL addr: ACC = ACC * M[addr]

DIV addr: ACC = ACC / M[addr]

MOD addr: ACC = ACC % M[addr]

LOAD addr: ACC = M[addr]

STORE addr: M[addr] = ACC

JUMP addr: go to line addr

BRANCH addr: if ACC == 0, go to line addr

else, go to next line

ACC stands for “accumulator”. It’s a little extra piece of memory called a “register”.

Think of it as the place where we store scratch work.

And.. that’s it.

Note: we will usually call “addr” an “immediate” or “imm”.

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Translate x = 5.

// Note: x is in 100

// Note: y is in 101

??

??

??

??

??

??

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Translate x = 5.

// Note: x is in 100

// Note: y is in 101

// Start w/5 in 200.

LOAD 200

STORE 100

??

??

??

??

??

Most computers have an instruction that makes this easier like:

LOADI imm: ACC = imm

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Translate y = 1.

// Note: x is in 100

// Note: y is in 101

// Start w/5 in 200.

LOAD 200

STORE 100

??

??

??

??

??

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Translate y = 1.

// Note: x is in 100

// Note: y is in 101

// Start w/5 in 200.

// Start w/1 in 201.

LOAD 200

STORE 100

LOAD 201

STORE 101

??

??

??

??

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Translate “while”.

// Note: x is in 100

// Note: y is in 101

// 5 in 200, 1 in 201.

LOAD 200

STORE 100

LOAD 201

STORE 101

??

??

??

??

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Translate “while”.

// Note: x is in 100

// Note: y is in 101

// 5 in 200, 1 in 201.

0x0 LOAD 200

0x1 STORE 100

0x2 LOAD 201

0x3 STORE 101

0x4 ??

0x5 ??

0x6 ??

0x7 ??

Let’s start by translating the end.

What happens at the end of a loop?

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Translate “while”.

// Note: x is in 100

// Note: y is in 101

// 5 in 200, 1 in 201.

0x0 LOAD 200

0x1 STORE 100

0x2 LOAD 201

0x3 STORE 101

0x4 ??

0x5 ??

0x6 ??

0x7 JUMP 4

At the end of a loop, we jump back to the start.

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Translate “while”.

// Note: x is in 100

// Note: y is in 101

// 5 in 200, 1 in 201.

0x0 LOAD 200

0x1 STORE 100

0x2 LOAD 201

0x3 STORE 101

0x4 ??

0x5 ??

0x6 ??

0x7 JUMP 4

Now the beginning.How do we make a choice?

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Translate “while”.

// Note: x is in 100

// Note: y is in 101

// 5 in 200, 1 in 201.

0x0 LOAD 200

0x1 STORE 100

0x2 LOAD 201

0x3 STORE 101

0x4 BRANCH 8

0x5 ??

0x6 ??

0x7 JUMP 4

Choose based on whether x equals 0...But what’s wrong with this?

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Translate the rest.

// Note: x is in 100

// Note: y is in 101

// 5 in 200, 1 in 201.

0x0 LOAD 201

0x1 STORE 101

0x2 LOAD 200

0x3 STORE 100

0x4 BRANCH 8

0x5 ??

0x6 ??

0x7 JUMP 4

BRANCH chooses based on what’s in the accumulator.With the loads for x and y switched, what’s in the ACC is now x.

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Translate the rest.

// Note: x is in 100

// Note: y is in 101

// Put 5 in 200, 1 in 201.

0x0 LOAD 201

0x1 STORE 101

0x2 LOAD 200

0x3 STORE 100

0x4 BRANCH A

0x5 LOAD 101 // 101 is y

0x6 MUL 100 // x

0x7 STORE 101 // back in y

0x8 ??

0x9 JUMP 4

To multiply x and y, we load in y and multiply in x.

Then, we store the result back into y.

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Translate the rest.

// Note: x is in 100

// Note: y is in 101

// Put 5 in 200, 1 in 201.

0x0 LOAD 201

0x1 STORE 101

0x2 LOAD 200

0x3 STORE 100

0x4 BRANCH A

0x5 LOAD 101 // 101 is y

0x6 MUL 100 // x

0x7 STORE 101 // back in y

0x8 ??

0x9 JUMP 4

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

while (x != 0) {

y = y * x;

x = x - 1;

}

// Translate the rest.

// Note: x is in 100

// Note: y is in 101

// Put 5 in 200, 1 in 201.

0x0 LOAD 201

0x1 STORE 101

0x2 LOAD 200

0x3 STORE 100

0x4 BRANCH C

0x5 LOAD 101 // 101 is y

0x6 MUL 100 // x

0x7 STORE 101 // back in y

0x8 LOAD 100 // x

0x9 SUB 201 // 1

0xA STORE 100 // back in x

0xB JUMP 4

Same style as the last step.Note that we already had the constant 1 stored in address 201.

0x000

0x001

0x002

0x003

0x004

0x005

0x006

0x007

0x008

0x009

0x00A

0x00B

.

.

0x100

0x101

.

.

.

0x200

0x201

0x20000200

0x21000100

0x20000201

0x21000101

0x4100000C

0x20000101

0x12000100

0x21000101

0x20000100

0x11000201

0x21000100

0x40000004

.

.

0x00000000

0x00000000

.

.

.

0x00000005

0x00000001

// Put 5! in y.

int x;

int y;

x = 5;

y = 1;

do {

y = y * x;

x = x - 1;

} while (x != 0);

The opcode references gives us the first two hex digits of each instruction. The rest is just the hex numbers we already had.