IT225: Computer Organizations

August 25, 2014 (Monday)Lecture 3

Overview Today

1.5 (metric units) Ch 2.1.1-2.1.4 (processors and CPU)

For Wednesday 2.1.5-2.1.6 (instruction-level parallelism, Processor-level

parallelism) 2.2.1-2.2. (memory) Homework #1 Due On Wednesday at 11:55pm Will need book for Homework #2 Carbon Nanotubes for CPU production https://www.youtube.com/watch?v=19nzPt62UPg https://www.youtube.com/watch?v=ikYhyjPjKBs

Metric Units

The principal metric prefixes.

NOTE: - Memory size is represented in “binary number” Therefore, 1MB is 1024 kilobytes, or 1048576 (1024x1024) bytes, not one million bytes - However, network bandwidth is represented in “decimal number”. Therefore, 1Mbps is 1000000bytes/second

CPU

• The brain of a computer is the central processing unit or CPU. This device contains all the circuitry that the computer needs to manipulate data and execute instructions. The CPU is amazingly small given the immense amount of circuitry it contains. The circuits of a computer are made of gates. Gates, however are also made of another tiny component called a transistor, and a modern CPU has millions and millions of transistors in its circuitry. The image to the below left shows just how compact a CPU can be.

• The CPU is composed of five basic components: RAM, registers, buses, the ALU, and the Control Unit. Each of these components are pictured in the diagram on the next page. The diagram shows a top view of a simple CPU with 16 bytes of RAM. To better understand the basic components of the CPU, we will consider each one in detail.

CPU

• RAM: this component is created from combining latches with a decoder. The latches create circuitry that can remember while the decoder creates a way for individual memory locations to be selected.

• Registers: these components are special memory locations that can be accessed very fast. Three registers are shown: the Instruction Register (IR), the Program Counter (PC), and the Accumulator.

• Buses: these components are the information highway for the CPU. Buses are bundles of tiny wires that carry data between components. The three most important buses are the address, the data, and the control buses.

• ALU: this component is the number cruncher of the CPU. The Arithmetic / Logic Unit performs all the mathematical calculations of the CPU. It is composed of complex circuitry similar to the adder presented in the previous lesson. The ALU, however, can add, subtract, multiply, divide, and perform a host of other calculations on binary numbers.

• Control Unit: this component is responsible for directing the flow of instructions and data within the CPU. The Control Unit is actually built of many other selection circuits such as decoders and multiplexors. In the diagram above, the Decoder and the Multiplexor compose the Control Unit.

http://courses.cs.vt.edu/csonline/MachineArchitecture/Lessons/CPU/sumprogram.html

How the CPU works

https://www.youtube.com/watch?v=B9ITn5IbMnU

https://www.youtube.com/watch?v=l019HZwGBnY

CPU• In order for a CPU to accomplish meaningful work, it must have two inputs: instructions and data. Instructions tell the CPU what actions need to be performed on the data. We have already seen how data is represented in the computer, but how do we represent

instructions? The answer is that we represent instructions with binary codes just like data. In fact, the CPU makes no distinction about the whether it is storing instructions or data in RAM. This concept is called the stored-program concept.

• Both inputs to the CPU are stored in memory, and the CPU functions by following a cycle of fetching an instruction, decoding it, and executing it. This process is known as the fetch-decode-execute cycle. The cycle begins when an instruction is transferred from memory to the IR along the data bus. In the IR, the unique bit patterns that make up the machine-language are extracted and sent to the Decoder. This component is responsible for the second step of the cycle, that is, recognizing which operation the bit pattern represents and activating the correct circuitry to perform the operation. Sometimes this involves reading data from memory, storing data in memory, or activating the ALU to perform a mathematical operation. Once the operation is performed, the cycle begins again with the next instruction. The CPU always knows where to find the next instruction because the Program Counter holds the address of the current instruction. Each time an instruction is completed, the program counter is advanced by one memory location.

CPU

a) Each machine instruction is composed of two parts: the op-code and the operand. According to Brookshear [1997], "the bit pattern appearing in the op-code field indicates which of the elementary operations, such as STORE or JUMP, is requested by the instruction. The bit patterns found in the operand field provide more detailed information about the operation specified by the op-code. For example, in the case of a STORE operation, the information in the operand field indicates which register contains the data to be stored and which memory cell is to receive the data." The image below shows the format of an instruction for our CPU. The first three bits represent the op-code and the final six bits represent the operand. The middle bit distinguishes between operands that are memory addresses and operands that are numbers. When the bit is set to '1', the operand represents a number. Notice that all the op-codes are given an English mnemonic to simplify programming. Together these mnemonics are called an assembly language. Programs written in assembly language must be converted to their binary representation before the CPU can understand them. This usually done by another program called an assembler, hence the name.

A simple machine languageOp-code Mnemonic Function Example

001 LOADLoad the value of the operand into the

Accumulator LOAD 10

010 STORE Store the value of the Accumulator at the address specified by the operand STORE 8

011 ADD Add the value of the operand to the Accumulator ADD #5

100 SUB Subtract the value of the operand from the Accumulator SUB #1

101 EQUAL If the value of the operand equals the value of the Accumulator, skip the next instruction EQUAL #20

110 JUMP Jump to a specified instruction by setting the Program Counter to the value of the operand JUMP 6

111 HALT Stop execution HALT

•In the machine language to the right, notice that some of the operands include a # symbol. This symbol tells the CPU that the operand represents a number rather than a memory address. Thus, when the assembler translates an instruction with a # symbol, the resulting machine code will have a '1' in the position of the number bit. Also notice the central role that the Accumulator register plays. Nearly all the operations affect the value of this register since the Accumulator acts as a temporary memory location for storing calculations in progress. With our machine language defined, we are ready to take a look at some simple programs.

Sum Program

•The first program is called Sum. This program adds the numbers stored in two memory locations. Mathematically, this program represents the formulas x = 2, y = 5, x + y = z where the variables x, y, and z correspond with the memory locations 13, 14, and 15 respectively. The instructions for the program are listed below. Read through the program, and then view the animation of this program by clicking the "View Animation" link.

•http://courses.cs.vt.edu/csonline/MachineArchitecture/Lessons/CPU/sumprogram.html

# Machine code Assembly code Description

0 001 1 000010 LOAD   #2 Load the value 2 into the Accumulator

1 010 0 001101 STORE  13 Store the value of the Accumulator in

memory location 13

2 001 1 000101 LOAD   #5 Load the value 5 into the Accumulator

3 010 0 001110 STORE  14 Store the value of the Accumulator in

memory location 14

4 001 0 001101 LOAD   13 Load the value of memory location 13 into

the Accumulator

5 011 0 001110 ADD    14 Add the value of memory location 14 to

the Accumulator

6 010 0 001111 STORE  15 Store the value of the Accumulator in

memory location 15

7 111 0 000000 HALT      Stop execution

Count Program

•The second program is called Count. This program counts up to a number specified by the programmer in the first instruction. Notice that this program incorporates a loop construction by using the JUMP and EQUAL instructions. Every time the value in the Accumulator is incremented, the count is tested to see if it has reached the specified amount.

•http://courses.cs.vt.edu/csonline/MachineArchitecture/Lessons/CPU/countprogram.html

# Machine code Assembly code Description

0 001 1 000101 LOAD   #5

These two operations set the count value to five

1 010 0 001111 STORE  15

2 001 1 000000 LOAD   #0 Initialize the count to zero

3 101 0 001111 EQUAL  15

Test to see if count is complete; if yes, skip next instruction and go to instruction

5; if no, go to next instruction

4 110 1 000110 JUMP   #6 Set Program Counter to 6

5 111 0 000000 HALT     Stop execution

6 011 1 000001 ADD    #1 Increment the count in the Accumulator

7 110 1 000011 JUMP   #3 Set Program Count to 3

Conclusion