1 / 33

A Working Computer

A Working Computer. Slides based on work by Bob Woodham and others. Learning Goals: In-Class. By the end of this unit, mostly from the lab , you should be able to:

osman
Download Presentation

A Working Computer

An Image/Link below is provided (as is) to download presentation 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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. A Working Computer Slides based on work by Bob Woodham and others

  2. Learning Goals: In-Class 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.

  3. Where We Are inThe Big Stories 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…

  4. Computer Strategy 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!)

  5. A “Normal” DFA as a Sequential Circuit DFA with a bunch of states and with output on arcs Sequence ofoutputs Sequence of inputs clk

  6. Ultra-High-Level CPU View:Fetch, Decode, Execute Cycle, as DFA 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!

  7. Ultra-High-Level CPU View:Fetch, Decode, Execute Cycle 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.

  8. CPSC 121’s “circuits story” 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...

  9. CPSC 111’s “programming story” 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...

  10. Java Byte Code 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.

  11. CPSC 111’s + 121’s Story... 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...)

  12. Learning Goals: In-Class 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.

  13. Extra Slides

  14. Java Program  Machine Program // 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??

  15. Java Memory Model  Hardware Memory ??? in a memory that is just a numbered list of locations. x (int) y (int) 5 1

  16. Java Memory Model  Hardware Memory 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

  17. Java Program  Machine Program // Put 5! in y. int x; int y; x = 5; y = 1; while (x != 0) { y = y * x; x = x - 1; } // Start translating ?? ?? ?? ?? ?? ?? ?? ??

  18. Java Program  Machine Program // 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 ?? ?? ?? ?? ?? ??

  19. Available Instructions 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”.

  20. Java Program  Machine Program // 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 ?? ?? ?? ?? ?? ??

  21. Java Program  Machine Program // 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

  22. Java Program  Machine Program // 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 ?? ?? ?? ?? ??

  23. Java Program  Machine Program // 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 ?? ?? ?? ??

  24. Java Program  Machine Program // 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 ?? ?? ?? ??

  25. Java Program  Machine Program // 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?

  26. Java Program  Machine Program // 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.

  27. Java Program  Machine Program // 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?

  28. Java Program  Machine Program // 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?

  29. Java Program  Machine Program // 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.

  30. Java Program  Machine Program // 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.

  31. Java Program  Machine Program // 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

  32. Java Program  Machine Program // 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.

  33. Java Program  Machine Memory 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.

More Related