Announcements
This presentation is the property of its rightful owner.
Sponsored Links
1 / 34

Announcements PowerPoint PPT Presentation


  • 35 Views
  • Uploaded on
  • Presentation posted in: General

Announcements. Quiz #1 In class Thursday, July 1st Covers Virtual machine (levels) Computer languages (levels) General architecture (CISC) VonNeumann architecture (stored program) Instruction Execution Cycle CPU, ALU, registers, buses, etc Internal/external representation

Download Presentation

Announcements

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.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 - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Announcements

Announcements

  • Quiz #1

    • In class Thursday, July 1st

    • Covers

      • Virtual machine (levels)

      • Computer languages (levels)

      • General architecture (CISC)

        • VonNeumann architecture (stored program)

        • Instruction Execution Cycle

        • CPU, ALU, registers, buses, etc

      • Internal/external representation

        • Signed/unsigned integer

        • IEEE floating-point

        • Binary, decimal, hexadecimal

        • Parity

        • Characters (table provided)

      • Integer arithmetic

    • Permitted: Calculator and one 8x11 notesheet (one sides)

      • No sharing


Announcements

Today’s topics

  • More internal representation

    • Signed/unsigned integers

  • External representation

    • Binary, decimal, hexadecimal number systems

  • Binary arithmetic

  • Floating-point representation

  • Error-detecting and error-correcting codes


Announcements

Other representations

  • Every integer number has a unique representation in each "base"  2

  • Hexadecimal is commonly used for easily converting binary to a more manageable form.

  • example 16-bit binary  hexadecimal:

    Binary 0001 0111 1011 1101

    Hexadecimal 1 7 B D

    Write it as 0x17BD or 17BDh


Announcements

Converting decimal to hexadecimal

  • Use same methods as decimal to binary

    • The only difference is the place values

  • Example decimal to hexadecimal

    157 decimal = 9D hex(0x9D or 9Dh)

  • … or convert to binary, then to hex


Announcements

Negative hex (signed integers)

  • How can you tell if a hexadecimal representation of a signed integer is negative?

    • Recall that a 16-bit signed integer is negative if the leftmost bit is 1

  • 16-bit (4 hex digits) examples:

    • 0x7a3e is positive

    • 0x8a3e is negative

    • 0xFFFF is negative


Announcements

Character and control codes

  • Letters, digits, special characters … are represented internally as numbers

  • ASCII256 codes (1-byte)

    • e.g., 'A' … 'Z' are codes 65 - 90

    • e.g., '0' … '9' are codes 48 - 57

  • Unicode65,536 codes (2-byte)

  • Some codes are used for controlling devices

    • e.g., code 10 is “new line” for output device

    • e.g., code 27 is “escape”

  • Device controllers translate codes (device-dependent)

  • All keyboard input is character (including digits)


Announcements

Digits

  • Digits entered from the keyboard are characters

    • E.G., ‘0’ is character number 48, … ‘9’ is character number 57

  • What happens if we add ‘3’ + ‘5’?

    • The answer is ‘h’

  • Numeric data types require conversion by the input/output operations


Announcements

Neutral representation

  • Inside the computer

    • Bytes, words, etc., can represent some finite number of combinations of off/on switches.

    • Each distinct combination is called a code.

    • Each code can be used to represent:

      • numeric value

      • memory address

      • machine instruction

      • keyboard character

  • Representation is neutral. The operating system and the programs decide how to interpret the codes.


Announcements

Arithmetic operations

  • The following examples use 8-bit twos-complement operands

    • Everything extends to 16-bit, 32-bit, n-bit representations.

    • What is the range of values for 8-bit operands?

  • The usual arithmetic operations can be performed directly in binary form with n-bit representations.


Announcements

Addition

  • Specify result size (bits)

  • Use the usual rules of add and carry

    • With two operands, the carry bit is never greater than one

    • 0+0+1 = 1,0+1+1 = 10,1+0+1 = 10,1+1+1 = 11

  • Example:

    00101101

    +00011110

    01001011

  • How does overflow occur?


Announcements

Subtraction

  • Use the usual rules

    • Order matters

    • Borrow and subtract

  • Example:

  • … or negate and add

    • Example:

  • How does underflow occur?


Announcements

Verification

  • Perform operation on binary operands

  • Convert result to decimal

  • Convert operands to decimal

  • Perform operation on decimal operands

  • [Convert result to binary]

  • Compare results


Announcements

Multiplication

  • Usual algorithm

  • Repeated addition

  • … or shift left (and adjust if multiplier is not a power of 2)

  • Check for overflow


Announcements

Division

  • Usual algorithm

  • Repeated subtraction

  • … or shift right (if divisor is a power of 2)

    • too complicated if divisor is not a power of 2

  • Check underflow for remainder


Announcements

Arithmetic operations

  • Note: all of the arithmetic operations can be accomplished using only

    • add

    • complement


Announcements

Floating-point representation

  • “decimal” means “base ten”

  • “floating-point” means “a number with an integral part and a fractional part

    • Sometimes call “real”, “float”

  • Generic term for “decimal point” is “radix point”


Announcements

Converting floating-point (decimal  binary)

  • Place values:

Integral part

Fractional part

Example: 4.5 (decimal) = 100.1 (binary)


Announcements

Converting floating-point (decimal  binary)

  • Example:6.25 = 110.01

  • Method:

    6 = 110(Integral part: convert in the usual way)

    .25 x 2 = 0.5(Fractional part: successive multiplication by 2)

    .5 x 2 = 1.0(Stop when fractional part is 0)

    • 110.01

  • Example:6.2  110.001100110011…

    6 = 110

    .2 x 2 = 0.4

    .4 x 2 = 0.8

    .8 x 2 = 1.6

    .6 x 2 = 1.2

    .2 x 2 = 0.4(repeats)

    • 110.0011 0011 0011


Announcements

Internal representation of floating-point numbers

  • Some architectures handle the integer part and the fraction part separately

    • Slow

  • Most use a completely different representation and a different ALU (IEEE standard)

  • Range of values for 32-bit

    • Approximately -3.4 x 1038 … +3.4 x 1038

  • Limited precision

    • Approximately -1.4 x 10-45 … +1.4 x 10-45


Announcements

IEEE 754 standard

  • single-precision (32-bit)

  • double-precision (64-bit)

  • extended (80-bit)

  • 3 parts

    • 1 sign bit

    • "biased" exponent (single: 8 bits,

      double: 11 bits

      extended: 15 bits)

    • "normalized" mantissa (single: 23 bits,

      double: 52 bits

      extended: 64 bits)


Announcements

Examples:

Sign

Biased exponent

Normalized mantissa

  • 6.25 in IEEE single precision is

    0 10000001 10010000000000000000000

    0100 0000 1100 1000 0000 0000 0000 0000

    40C80000 hexadecimal

  • 6.2 in IEEE is

    0 10000001 10001100110011001100110

    0100 0000 1100 0110 0110 0110 0110 0110

    40C66666 hexadecimal


Announcements

Examples:

  • 6.25 in IEEE single precision

    6.25 (decimal) = 110.01 (binary)

    Move the radix point until a single 1 appears on the left, and multiply by the corresponding power of 2

    = 1.1001x 22

    … so the sign bit is 0 (positive)

    … the “biased” exponent is 2 + 127 = 129 = 10000001

    … and the “normalized” mantissa is 1001 (drop the 1, and zero-fill).

    01000000110010000000000000000000

    0100 0000 1100 1000 0000 0000 0000 0000

    40C80000 hexadecimal


Announcements

Examples:

  • 6.2 in IEEE is

    6.2 (decimal) = 110.001100110011… (binary)

    Move the radix point until a single 1 appears on the left, and multiply by the corresponding power of 2

    = 1.10001100110011…x 22

    … so the sign bit is 0 (positive)

    … the “biased” exponent is 2 + 127 = 129= 10000001

    … and the “normalized” mantissa is 10001100110011…

    (drop the 1).

    01000000110001100110011001100110

    0100 0000 1100 0110 0110 0110 0110 0110

    40C66666 hexadecimal


Announcements

Example:

  • What decimal floating-point number is represented by C1870000H?

    1100 0001 1000 0111 0000 0000 0000 0000

    11000001100001110000000000000000

    … so the sign is negative

    … the “unbiased” exponent is 131 - 127 = 4

    … and the “unnormalized” mantissa is 1.00001110000000000000000 (add the 1 left of the radix point).

    Move the radix point 4 places to the right:10000.111

  • -10000.111 = -16.875

Sign

Biased exponent

Normalized mantissa


Announcements

Internal representation

  • Regardless of external representation, all I/O eventually is converted into electrical (binary) codes.

  • Inside the computer, everything is represented by gates (open/closed).


Announcements

Problem with Internal Representation

  • Since the number of gates in each group (byte, word, etc.) is finite, computers can represent numbers with finite precision only.

  • Examples:

    • Suppose that signed integer data is represented using 16 bits. The largest integer that can be represented is 65535. What happens if we add 1 ?

      • 0

    • What happens when we need to represent 1/3 ?

  • Representations may be truncated; overflow / underflow can occur, and the Status Register will be set

  • Limited precision for floating-point representations


Announcements

Looking inside …

  • 11010110What does this code represent?

  • Number ?

    • 8-bit unsigned 214 ?

    • 8-bit signed - 42 ?

    • partial 16-bit integer ?

    • partial floating point ?

  • Character ?

    • ASCII ‘╓’ ?

    • partial Unicode ‘Ö’

  • Address ?

  • Instruction ?

  • Garbage ?


Announcements

Neutral representation

  • Inside the computer

    • Bytes, words, etc., can represent a finite number of combinations of off/on switches.

    • Each distinct combination is called a code.

    • Each code can be used to represent:

      • numeric value

      • memory address

      • machine instruction

      • keyboard character

  • Representation is neutral. The operating system and the programs decide how to interpret the codes.


Announcements

Simple Error Checking

  • Each computer architecture is designed to use either even parity or odd parity

  • System adds a parity bit to make each code match the system's parity

  • Parity is the total number of '1' bits (including the extra parity bit) in a binary code


Announcements

Parity (error checking)

  • Example parity bits for 8-bit code 11010110

    • Even-parity system:111010110(sets parity bit to 1 to make a total of 6 one-bits)

    • Odd-parity system:011010110(sets parity bit to 0 to keep 5 one-bits)

  • Code is checked for parity error whenever it is used.

  • Examples for even-parity architecture:

    • 101010101error (5 one-bits)

    • 100101010OK (4 one-bits)

  • Examples for odd-parity architecture:

    • 101010101OK (5 one-bits)

    • 100101010error (4 one-bits)


Announcements

Parity (error checking)

  • Used for checking memory, network transmissions, etc.

    • Error detection

  • Not 100% reliable.

    • Works only when error is in odd number of bits

    • … but very good because most errors are single-bit

  • Next time …

    • Error-correcting codes (ECC)


Announcements

Questions?

Do Homework #1

Quiz #1 Thursday 7/1


  • Login