CS241 Computer Organization Spring

Transcription

1 CS241 Computer Organization Spring 2015 Prof. Searleman

2 ! Name (as you like to be called)! Major! Graduating Year! Hometown! Programming & Computer Experience! Something about yourself! Goals for this course

3 Overview! Introduction and course goals! Administrivia! Organization and Anatomy of a Computer Reading: CSAPP2, Chapter 1 & Chapter 2, section 2.1 if you have K&R, do the tutorial in Chapter 1

4 Course Objectives!To learn low-level representation of data and data structures in memory!to learn how a high-level language program is implemented in machine code, and how to interpret and debug assembly language programs!to learn how a modern computer operates at the level of the processor and the memory hierarchy!to learn about techniques used to maximize the performance of programs!to become familiar with the C programming language

5 What are Machine Structures? Software Hardware Application (Firefox) Compiler Assembler Processor Memory Digital Design Circuit Design transistors Operating System (Windows 7) Datapath & Control I/O system Instruction Set Architecture CS241!Coordination of many levels of abstraction

6 Levels of Representation High Level Language Program (e.g., C) Compiler Assembly Language Program Assembler Machine Language Program CS241 temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; lw $to, 0($2) lw $t1, 4($2) sw $t1, 0($2) sw $t0, 4($2) Machine Interpretation Control Signal Specification

7 Anatomy: 5 components of any Computer Personal Computer Computer Processor (active) Control ( brain ) Datapath ( brawn ) Memory (passive) (where programs & data live when running) Devices Input Output Keyboard, Mouse Disk (where programs & data live when not running) Display, Printer

8 What is Computer Architecture Computer Architecture = Instruction Set Architecture + Machine Organization

9 CS241: So what's in it for me?! Computer Organization from a programmer's point of view What the programmer writes How it is converted to something the computer understands How the computer interprets the program What makes programs go slow

10 CS241: So what's in it for me?! Learn big ideas in CS and engineering 5 classic components of a Computer Data can be anything (integers, floating point, characters): a program determines what it is Stored program concept: instructions just data Principle of abstraction, used to build systems as layers

11 C What 241 is not C++! Becoming an expert at C If you know one, you should be able to learn another programming language on your own Given that you know C++ and/or Java, should be easy to pick up its ancestor, C! Hardware design Java Hardware at abstract level, with only a little bit of physical logic to give things perspective

12 Administrivia!course webpage: info: SC375, x2377, hours: check webpage!schedule: check frequently!

13 Textbooks Required:! Computer Systems: A Programmer s Perspective (CS:APP), second edition Recommended: a good C reference; one possibility is:! The C Programming Language, ANSI C, Second Edition, by Kernighan & Ritchie, Prentice Hall, 1988, ISBN

14 Grading Policy 2 Midterm Exams 30% Final Exam: 35% Quizzes 5% HW Assignments & Labs 30% Tentative dates for the exams are: February 24 th and April 14 th These exam dates are somewhat flexible, and may be modified two weeks in advance of the tentative date, based on the exam schedules of students in the class.

15 Labs: provide in-depth understanding of systems!data Lab bit-level representation of C datatypes and behavior of operations on the data!bomb Lab defuse a binary bomb by disassembling and reverse engineering a program!buffer Lab modify the run-time behavior of a binary executable by exploiting a buffer overflow bug!performance Lab: optimize the performance of an application function

16 Course Theme: 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 details of underlying implementations

17 Course Theme: (cont.) Abstraction is Good But Don t Forget Reality! Useful outcomes Become more effective programmers Able to find and eliminate bugs efficiently Able to understand and tune for program performance Prepare for later systems classes in CS & ECE Compilers, Operating Systems, Networks, Computer Architecture, Embedded Systems

18 Great Reality #1: Int s are not Integers, Float s are not Reals! Example 1: Is x 2 0? Float s: Yes! Int s: * > * >??! Example 2: Is (x + y) + z = x + (y + z)? Unsigned & Signed Int s: Yes! Float s: (1e e20) > e20 + (-1e ) -->??

19 Code Security Example /* Kernel memory region holding user-accessible data */ #define KSIZE 1024 char kbuf[ksize]; /* Copy at most maxlen bytes from kernel region to user buffer */ int copy_from_kernel(void *user_dest, int maxlen) { /* Byte count len is minimum of buffer size & maxlen */ int len = KSIZE < maxlen? KSIZE : maxlen; memcpy(user_dest, kbuf, len); return len; }! Similar to code found in FreeBSD s implementation of getpeername! There are legions of smart people trying to find vulnerabilities in programs

20 Typical Usage #define MSIZE 528 void getstuff() { char mybuf[msize]; copy_from_kernel(mybuf, MSIZE); printf( %s\n, mybuf); } /* Kernel memory region holding user-accessible data */ #define KSIZE 1024 char kbuf[ksize]; /* Copy at most maxlen bytes from kernel region to user buffer */ int copy_from_kernel(void *user_dest, int maxlen) { /* Byte count len is minimum of buffer size and maxlen */ int len = KSIZE < maxlen? KSIZE : maxlen; memcpy(user_dest, kbuf, len); return len; }

21 Malicious Usage #define MSIZE 528 void getstuff() { char mybuf[msize]; copy_from_kernel(mybuf, -MSIZE);... } /* Kernel memory region holding user-accessible data */ #define KSIZE 1024 char kbuf[ksize]; /* Copy at most maxlen bytes from kernel region to user buffer */ int copy_from_kernel(void *user_dest, int maxlen) { /* Byte count len is minimum of buffer size and maxlen */ int len = KSIZE < maxlen? KSIZE : maxlen; memcpy(user_dest, kbuf, len); return len; }

22 Computer Arithmetic! Does not generate random values Arithmetic operations have important mathematical properties! Cannot assume all usual mathematical properties Due to finiteness of representations Integer operations satisfy ring properties Commutativity, associativity, distributivity Floating point operations satisfy ordering properties Monotonicity, values of signs

23 Computer Arithmetic (continued)! Observation Need to understand which abstractions apply in which contexts Important issues for compiler writers and serious application programmers

24 Great Reality #2: You ve Got to Know Assembly! Chances are, you ll never write program in assembly Compilers are much better & more patient than you are! But, understanding assembly key to machine-level execution model Behavior of programs in presence of bugs High-level language model breaks down Tuning program performance Understand optimizations done/not done by the compiler

25 Great Reality #2: (continued) You ve Got to Know Assembly! Understanding assembly key to machine-level execution model (continued) Implementing system software Compiler has machine code as target Operating systems must manage process state Creating / fighting malware x86 assembly is the language of choice!

26 Assembly Code Example!Time Stamp Counter Special 64-bit register in Intel-compatible machines Incremented every clock cycle Read with rdtsc instruction! Application Measure time (in clock cycles) required by procedure double t; start_counter(); P(); t = get_counter(); printf("p required %f clock cycles\n", t);

27 Code to Read Counter!Write small amount of assembly code using GCC s asm facility!inserts assembly code into machine code generated by compiler static unsigned cyc_hi = 0; static unsigned cyc_lo = 0; /* Set *hi and *lo to the high and low order bits of the cycle counter. */ void access_counter(unsigned *hi, unsigned *lo) { asm("rdtsc; movl %%edx,%0; movl %%eax,%1" : "=r" (*hi), "=r" (*lo) : : "%edx", "%eax"); }

28 Great Reality #3: Memory Matters Random Access Memory Is an Unphysical Abstraction! Memory is not unbounded It must be allocated and managed Many applications are memory dominated! Memory referencing bugs especially pernicious Effects are distant in both time and space! Memory performance is not uniform Cache and virtual memory effects can greatly affect program performance Adapting program to characteristics of memory system can lead to major speed improvements

29 Memory Referencing Bug Example double fun(int i) { volatile double d[1] = {3.14}; volatile long int a[2]; a[i] = ; /* Possibly out of bounds */ return d[0]; } fun(0) > 3.14 fun(1) > 3.14 fun(2) > fun(3) > fun(4) > 3.14, then segmentation fault

30 Memory Referencing Bug Example double fun(int i) { volatile double d[1] = {3.14}; volatile long int a[2]; a[i] = ; /*?*/ return d[0]; } fun(0) > 3.14 fun(1) > 3.14 fun(2) > fun(3) > fun(4) > 3.14, then segmentation fault Explanation: Saved State d7 d4 d3 d0 a[1] a[0] Location accessed by fun(i)

31 Memory Referencing Errors! C and C++ do not provide any memory protection Out of bounds array references Invalid pointer values Abuses of malloc/free! Can lead to nasty bugs Whether or not bug has any effect depends on system and compiler Action at a distance Corrupted object logically unrelated to one being accessed

32 Memory Referencing Errors (continued)! How can I deal with this? Program in Java or ML Understand what possible interactions may occur Use or develop tools to detect referencing errors

33 Memory System Performance Example void copyij( int src[2048][2048], int dst[2048][2048]) { int i,j; for (i = 0; i<2048; i++) for (j = 0; j<2048; j++) dst[i][j] = src[i][j]; } void copyji( int src[2048][2048], int dst[2048][2048]) { int i,j; for (j = 0; j<2048; j++) for (i = 0; i<2048; i++) dst[i][j] = src[i][j]; }! Hierarchical memory organization! Performance depends on access patterns Including how to step through a multi-dimensional array 21 times slower (Pentium 4)

34 Great Reality #4: There s more to performance than asymptotic complexity! Constant factors matter too!! And even exact op count does not predict performance Easily see 10:1 performance range depending on how code written Must optimize at multiple levels: algorithm, data representations, procedures, and loops

35 Great Reality #4: (cont) There s more to performance than asymptotic complexity! Must understand system to optimize performance How programs compiled and executed How to measure program performance and identify bottlenecks How to improve performance without destroying code modularity and generality

36 Example Matrix Multiplication Matrix-Matrix Multiplication (MMM) on 2 x Core 2 Duo 3 GHz (double precision) Gflop/s Best code (K. Goto) x Triple loop 0 2,250 4,500 6,750 9,000 matrix size!standard desktop computer, vendor compiler, using optimization flags!both implementations have exactly the same operations count (2n 3 ) What is going on?

37 MMM Plot: Analysis Matrix-Matrix Multiplication (MMM) on 2 x Core 2 Duo 3 GHz Gflop/s Multiple threads: 4x Vector instructions: 4x Memory hierarchy and other optimizations: 20x 0 2,250 4,500 6,750 9,000 matrix size Reason for 20x: Blocking or tiling, loop unrolling, array scalarization, instruction scheduling, search to find best choice Effect: less register spills, less L1/L2 cache misses, less TLB misses

38 Great Reality #5: Computers do more than execute programs! They need to get data in and out I/O system critical to program reliability and performance! They communicate with each other over networks Many system-level issues arise in presence of network Concurrent operations by autonomous processes Coping with unreliable media Cross platform compatibility Complex performance issues

39 Course Perspective! Most Systems Courses are Builder-Centric Computer Architecture Design pipelined processor in Verilog Operating Systems Implement large portions of operating system Compilers Write compiler for simple language Networking Implement and simulate network protocols

40 Course Perspective (Cont.)! This Course is Programmer-Centric Purpose is to show how by knowing more about the underlying system, one can be more effective as a programmer Enable you to Write programs that are more reliable and efficient Incorporate features that require hooks into OS, e.g., concurrency, signal handlers Not just a course for dedicated hackers We bring out the hidden hacker in everyone Covers material in this course that you won t see elsewhere

41 And in Conclusion...!14 weeks to learn big ideas in CS&E Principle of abstraction, used to build systems as layers Pliable Data: a program determines what it is Stored program concept: instructions are just data Principle of Locality, exploited via a memory hierarchy (cache) Greater performance Compilation v. interpretation to move down layers of system Principles/Pitfalls of Performance Measurement

42 And in Conclusion...!Continued rapid improvement in Computing 2X every 1.5 years in processor speed; every 2.0 years in memory size; every 1.0 year in disk capacity; Moore s Law enables processor, memory (2X transistors/chip/ ~1.5 yrs)!5 classic components of all computers Control + Datapath Memory Input Output Processor

43 CS241: Computer Organization Have Fun!

44 HelloWorld in C HelloWorld.c 1. #include <stdio.h> 2. int main() 3. { 4. printf( hello, world\n ); 5. return 0; 6. }