Computer Systems Introduction

Slides:



Advertisements
Similar presentations
When NOT to use Unsigned? Don’t Use Just Because Number Nonzero – C compilers on some machines generate less efficient code unsigned i; for (i = 1; i
Advertisements

Fabián E. Bustamante, Spring 2007 Integers Today Numeric Encodings Programming Implications Basic operations Programming Implications Next time Floats.
CS213 Topics Numeric Encodings Unsigned & Two’s complement Programming Implications C promotion rules Basic operations Addition, negation, multiplication.
“The course that gives CMU its Zip!” Topics Numeric Encodings –Unsigned & Two’s complement Programming Implications –C promotion rules CS 213 F’00.
“The course that gives CMU its Zip!” Topics Numeric Encodings –Unsigned & Two’s complement Programming Implications –C promotion rules Basic operations.
CS213 Integers Apr 3, 2006 Topics Numeric Encodings
“The course that gives CMU its Zip!” Topics Numeric Encodings Unsigned & Two’s complement Programming Implications C promotion rules Basic operations.
ICS 2005 Instructor: Peter A. Dinda TA: Bin Lin Recitation 2.
February 4, 2003 CSCE 212 Computer Architecture Lecture 3 Representing Integers.
Carnegie Mellon 1 This Week: Integers Integers  Representation: unsigned and signed  Conversion, casting  Expanding, truncating  Addition, negation,
Topics Numeric Encodings Unsigned & Two’s complement Programming Implications C promotion rules Basic operations Addition, negation, multiplication Programming.
Int’s and Integers CENG331: Introduction to Computer Systems 3 rd Lecture Instructor: Erol Sahin Acknowledgement: Most of the slides are adapted from the.
– 1 – CS 105 Computer Systems Introduction Topics: Class Intro Data Representation CS 105 “Tour of the Black Holes of Computing!” Geoff Kuenning Fall 2015.
Carnegie Mellon 1 Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition Bits, Bytes, and Integers MCS-284 : Computer Organization.
Carnegie Mellon 1 Bits, Bytes, and Integers Lecture, Jan. 24, 2013 These slides are from website which accompanies the book “Computer.
1 Integer Representations. 2 Outline Encodings –Unsigned and two’s complement Conversions –Signed vs. unsigned –Long vs. short Suggested reading –Chap.
Comp Integers Spring 2015 Topics Numeric Encodings
– 1 – CS 105 Computer Systems Introduction Topics: Staff, text, and policies Lecture topics and assignments Lab rationale CS 105 “Tour of the Black Holes.
“The course that gives CMU its Zip!” Topics Basic operations –Addition, negation, multiplication Programming Implications –Consequences of overflow.
Topics Numeric Encodings Unsigned & Two’s complement Programming Implications C promotion rules Basic operations Addition, negation, multiplication Programming.
University of Washington Integers The Hardware/Software Interface CSE351 Winter 2013.
CS 105 “Tour of the Black Holes of Computing” Topics Numeric Encodings Unsigned & Two’s complement Programming Implications C promotion rules Basic operations.
Carnegie Mellon Introduction to Computer Systems /18-243, spring rd Lecture, Jan. 20 th Instructors: Gregory Kesden and Markus Püschel.
CS 105 “Tour of the Black Holes of Computing” Topics Numeric Encodings Unsigned & Two’s complement Programming Implications C promotion rules Basic operations.
Int’s and Integers CENG331: Introduction to Computer Systems 3 rd Lecture Instructor: Erol Sahin Acknowledgement: Most of the slides are adapted from the.
“The course that gives CMU its Zip!” Topics Basic operations –Addition, negation, multiplication Programming Implications –Consequences of overflow.
Integers Topics Representations of Integers Basic properties and operations Implications for C.
Lecture 2 Two’s Complement Proofs Topics Two’s complement January 11, 2016 CSCE 212H Computer Architecture.
Lecture 2 Ints revisited Topics Unsigned Integers Signed magnitude Two’s complement January 11, 2016 CSCE 212H Computer Architecture.
Lecture 4: Representing Negative Numbers CS 2011 Spring 2016, Dr. Rozier.
Topics Numeric Encodings –Unsigned & Two’s complement Programming Implications –C promotion rules Basic operations –Addition, negation, multiplication.
– 1 – CS 105 Computer Systems Introduction Topics: Class Intro Data Representation CS 105 “Tour of the Black Holes of Computing!” Geoff Kuenning Fall 2014.
Instructors: Greg Kesden
Today’s Instructor: Randy Bryant
This Week: Integers Integers Summary
Integers Topics Numeric Encodings (2.2) Programming Implications
CS 367 Integers Topics (Ch. 2.2, 2.3) Numeric Encodings
Bits, Bytes, and Integers CSE 238/2038/2138: Systems Programming
University of Washington
Instructor: David Ferry
Integer Representations and Arithmetic
Computer Systems Introduction
“The course that gives CMU its Zip!”
CS213 Integers Topics Numeric Encodings Programming Implications
CS 105 “Tour of the Black Holes of Computing”
CS 105 “Tour of the Black Holes of Computing”
CS140 Lecture 08: Data Representation: Bits and Ints
Comp Integers Spring 2015 Topics Numeric Encodings
Representing Information (2)
Computer Systems Introduction
Integers II CSE 410 Winter 2017 Instructor: Teaching Assistants:
Bits, Bytes, and Integers January 16, 2008
Bits, Bytes, and Integers 2nd Lectures
Integers Topics Numeric Encodings Programming Implications
1 The Hardware/Software Interface CSE351 Spring 2011 Module 3: Integers Monday, April 4, 2011.
Representing Information (2)
Integers II CSE 351 Autumn 2018 Instructor: Teaching Assistants:
Representing Information (2)
Arithmetic Topics Basic operations Programming Implications
Bits, Bytes, and Integers
Representing Information (2)
Introduction to Computer Systems
Computer Organization COMP 210
Bits, Bytes, and Integers Part 2 3rd Lectures
Integer Representations Jan. 23, 2001
Computer Organization COMP 210
Computer Organization COMP 210
CS 105 “Tour of the Black Holes of Computing!”
Bits, Bytes, and Integers
Integers II CSE 351 Spring 2019 Instructor: Teaching Assistants:
Presentation transcript:

Computer Systems Introduction CS 105 “Tour of the Black Holes of Computing!” Computer Systems Introduction Geoff Kuenning Spring 2009 Topics: Staff, text, and policies Lecture topics and assignments Lab rationale

Course Theme Many CS Courses emphasize abstraction Abstraction is good, but don’t forget reality! Many CS Courses emphasize abstraction Abstract data types Asymptotic analysis These abstractions have limits Especially in the presence of bugs Need to understand underlying implementations Useful outcomes Become more effective programmers Able to find and eliminate bugs efficiently Able to tune program performance Prepare for later “systems” classes in CS Compilers, Operating Systems, Networks, Computer Architecture, Robotics, etc.

Textbooks Randal E. Bryant and David R. O’Hallaron, “Computer Systems: A Programmer’s Perspective”, Prentice Hall, 2003. Brian Kernighan and Dennis Ritchie, “The C Programming Language, Second Edition”, Prentice Hall, 1988 Larry Miller and Alex Quilici The Joy of C, Wiley, 1997

Syllabus Syllabus on Web: http://www.cs.hmc.edu/~geoff/cs105 Calendar defines due dates Labs: cs105submit for some, others have specific directions

Notes: Work groups Handins Grading Characteristics You must work in pairs on all labs Honor-code violation to work without your partner! Handins Check calendar Electronic submissions only Grading Characteristics Lab scores tend to be high Serious handicap if you don’t hand a lab in Tests & quizzes typically have a wider range of scores I.e., they’re primary determinant of your grade …but not the ONLY one Do your share of lab work and reading, or bomb tests

Facilities Assignments will use Intel computer systems Not all machines are created alike Some Macs are PowerPCs Even Intel Macs aren’t necessarily compatible Knuth is a 64-bit server Wilkes: x86/Linux specifically set up for this class Log in on a Mac, then ssh to Wilkes If you want fancy programs, start X11 first Directories are cross-mounted, so you can edit on Knuth or your Mac, and Wilkes will see your files …or ssh into Wilkes from your dorm All programs must run on Wilkes: that’s where we grade

CS 105 “Tour of the Black Holes of Computing” Integers Topics Numeric Encodings Unsigned & two’s complement Programming Implications C promotion rules Basic operations Addition, negation, multiplication Consequences of overflow Using shifts to perform power-of-2 multiply/divide CS 105

C Puzzles Taken from old exams Assume machine with 32 bit word size, two’s complement integers For each of the following C expressions, either: Argue that it is true for all argument values Give example where it is not true x < 0  ((x*2) < 0) ux >= 0 x & 7 == 7  (x<<30) < 0 ux > -1 x > y  -x < -y x * x >= 0 x > 0 && y > 0  x + y > 0 x >= 0  -x <= 0 x <= 0  -x >= 0 Initialization int x = foo(); int y = bar(); unsigned ux = x; unsigned uy = y;

Encoding Integers Unsigned Two’s Complement Sign Bit short int x = 15213; short int y = -15213; Sign Bit C short 2 bytes long Sign Bit For 2’s complement, most-significant bit indicates sign 0 for nonnegative 1 for negative

Encoding Integers (Cont.) x = 15213: 00111011 01101101 y = -15213: 11000100 10010011

Numeric Ranges Unsigned Values UMin = 0 UMax = 2w – 1 000…0 UMax = 2w – 1 111…1 Two’s Complement Values TMin = –2w–1 100…0 TMax = 2w–1 – 1 011…1 Other Values Minus 1 111…1 Values for W = 16

Values for Different Word Sizes Observations |TMin | = TMax + 1 Asymmetric range UMax = 2 * TMax + 1 C Programming  #include <limits.h> K&R App. B11 Declares constants, e.g.,  ULONG_MAX  LONG_MAX  LONG_MIN Values platform-specific

Unsigned & Signed Numeric Values Equivalence Same encodings for nonnegative values Uniqueness Every bit pattern represents unique integer value Each representable integer has unique bit encoding X B2T(X) B2U(X) 0000 0001 1 0010 2 0011 3 0100 4 0101 5 0110 6 0111 7 –8 8 –7 9 –6 10 –5 11 –4 12 –3 13 –2 14 –1 15 1000 1001 1010 1011 1100 1101 1110 1111

Casting Signed to Unsigned C Allows Conversions from Signed to Unsigned Resulting Value No change in bit representation Nonnegative values unchanged ux = 15213 Negative values change into (large) positive values uy = 50323 short int x = 15213; unsigned short int ux = (unsigned short) x; short int y = -15213; unsigned short int uy = (unsigned short) y;

Relation Between Signed & Unsigned uy = y + 2 * 32768 = y + 65536

Signed vs. Unsigned in C Constants Casting By default are considered to be signed integers Unsigned if have “U” as suffix 0U, 4294967259u Casting Explicit casting between signed & unsigned same as U2T and T2U int tx, ty; unsigned ux, uy; tx = (int) ux; uy = (unsigned) ty; Implicit casting also occurs via assignments and procedure calls tx = ux; uy = ty;

Casting Surprises Expression Evaluation If mix unsigned and signed in single expression, signed values implicitly cast to unsigned Including comparison operations <, >, ==, <=, >= Examples for W = 32 Constant1 Constant2 Relation Evaluation 0 0u -1 0 -1 0u 2147483647 -2147483648 2147483647u -2147483648 -1 -2 (unsigned) -1 -2 2147483647 2147483648u 2147483647 (int) 2147483648u

Casting Surprises Expression Evaluation If you mix unsigned and signed in single expression, signed values are implicitly cast to unsigned Including comparison operations <, >, ==, <=, >= Examples for W = 32 Constant1 Constant2 Relation Evaluation 0 0u -1 0 -1 0u 2147483647 -2147483648 2147483647u -2147483648 -1 -2 (unsigned) -1 -2 2147483647 2147483648u 2147483647 (int) 2147483648u 0 0U == unsigned -1 0 < signed -1 0U > unsigned 2147483647 -2147483648 > signed 2147483647U -2147483648 < unsigned -1 -2 > signed (unsigned) -1 -2 > unsigned 2147483647 2147483648U < unsigned 2147483647 (int) 2147483648U > signed

Explanation of Casting Surprises 2’s Comp.  Unsigned Ordering Inversion Negative  Big Positive TMax TMin –1 –2 UMax UMax – 1 TMax + 1 2’s Comp. Range Unsigned

Sign Extension Task: Rule: Given w-bit signed integer x Convert it to w+k-bit integer with same value Rule: Make k copies of sign bit: X  = xw–1 ,…, xw–1 , xw–1 , xw–2 ,…, x0 • • • X X  w k k copies of MSB

Sign Extension Example short int x = 15213; int ix = (int) x; short int y = -15213; int iy = (int) y; Decimal Hex Binary x 15213 3B 6D 00111011 01101101 ix 00 00 3B 6D 00000000 00000000 00111011 01101101 y -15213 C4 93 11000100 10010011 iy FF FF C4 93 11111111 11111111 11000100 10010011 Converting from smaller to larger integer data type C automatically performs sign extension

Why Should I Use Unsigned? Be careful using C compilers on some machines generate less efficient code unsigned i; for (i = 1; i < cnt; i++) a[i] += a[i-1]; Easy to make mistakes for (i = cnt-2; i >= 0; i--) a[i] += a[i+1]; Do use when performing modular arithmetic Multiprecision arithmetic Other esoteric stuff Do use when need extra bit’s worth of range Working right up to limit of word size E.g., array sizes

Negating with Complement & Increment Claim: Following holds for 2’s complement ~x + 1 == -x Complement Observation: ~x + x == 1111…112 == -1 Increment ~x + x + (-x + 1) == -1 + (-x + 1) ~x + 1 == -x Warning: Be cautious treating int’s as integers OK here (associativity holds) 1 x ~x + -1

Comp. & Incr. Examples x = 15213

Unsigned Addition Standard Addition Function • • • Operands: w bits + v • • • True Sum: w+1 bits u + v • • • Discard Carry: w bits UAddw(u , v) • • • Standard Addition Function Ignores carry output Implements Modular Arithmetic s = UAddw(u , v) = u + v mod 2w

Two’s Complement Addition u • • • Operands: w bits + v • • • True Sum: w+1 bits u + v • • • Discard Carry: w bits TAddw(u , v) • • • TAdd and UAdd have identical bit-level behavior Signed vs. unsigned addition in C: int s, t, u, v; s = (int) ((unsigned) u + (unsigned) v); t = u + v Will give s == t

Detecting 2’s Comp. Overflow Task Given s = TAddw(u , v) Determine if s = Addw(u , v) Example int s, u, v; s = u + v; Claim Overflow iff either: u, v < 0, s  0 (NegOver) u, v  0, s < 0 (PosOver) 2w –1 2w–1 PosOver NegOver

Multiplication Computing exact product of w-bit numbers x, y Ranges Either signed or unsigned Ranges Unsigned: 0 ≤ x * y ≤ (2w – 1) 2 = 22w – 2w+1 + 1 Up to 2w bits Two’s complement min: x * y ≥ (–2w–1)*(2w–1–1) = –22w–2 + 2w–1 Up to 2w–1 bits (including 1 for sign) Two’s complement max: x * y ≤ (–2w–1) 2 = 22w–2 Up to 2w bits, but only for (TMinw)2 Maintaining exact results Would need to keep expanding word size with each product computed Done in software by “arbitrary precision” arithmetic packages

Power-of-2 Multiply by Shifting Operation u << k gives u * 2k Both signed and unsigned Examples u << 3 == u * 8 u << 5 - u << 3 == u * 24 Most machines shift and add much faster than multiply Compiler generates this code automatically k u • • • Operands: w bits * 2k ••• 1 ••• True Product: w+k bits u · 2k • • • ••• UMultw(u , 2k) ••• ••• Discard k bits: w bits TMultw(u , 2k)

Unsigned Power-of-2 Divide by Shifting Quotient of unsigned by power of 2 u >> k gives  u / 2k  Uses logical shift k u Binary Point ••• ••• Operands: / 2k ••• 1 ••• Division: u / 2k . ••• ••• ••• Result:  u / 2k  ••• •••