slide1
Download
Skip this Video
Download Presentation
Announcements

Loading in 2 Seconds...

play fullscreen
1 / 34

Announcements - PowerPoint PPT Presentation


  • 65 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Announcements' - miranda-tyler


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
slide1

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
slide2

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
slide3

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

slide5

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
slide6

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
slide7

Character and control codes

  • Letters, digits, special characters … are represented internally as numbers
  • ASCII 256 codes (1-byte)
    • e.g., \'A\' … \'Z\' are codes 65 - 90
    • e.g., \'0\' … \'9\' are codes 48 - 57
  • Unicode 65,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)
slide8

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
slide10

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

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

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?
slide13

Subtraction

  • Use the usual rules
    • Order matters
    • Borrow and subtract
  • Example:
  • … or negate and add
    • Example:
  • How does underflow occur?
slide14

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
slide15

Multiplication

  • Usual algorithm
  • Repeated addition
  • … or shift left (and adjust if multiplier is not a power of 2)
  • Check for overflow
slide16

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
slide17

Arithmetic operations

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

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”
slide19

Converting floating-point (decimal  binary)

  • Place values:

Integral part

Fractional part

Example: 4.5 (decimal) = 100.1 (binary)

slide20

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
slide21

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
slide22

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)

slide23

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

slide24

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

slide25

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

slide26

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

slide27

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

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
slide29

Looking inside …

  • 11010110 What 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 ?
slide30

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

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
slide32

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:
    • 101010101 error (5 one-bits)
    • 100101010 OK (4 one-bits)
  • Examples for odd-parity architecture:
    • 101010101 OK (5 one-bits)
    • 100101010 error (4 one-bits)
slide33

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)
slide34

Questions?

Do Homework #1

Quiz #1 Thursday 7/1

ad