Computer SystemsOverview

Topics:Topics: Staff, text, and policies Lecture topics and assignments Lab rationale

CS 105overview.ppt

CS 105“Tour of the Black Holes of Computing!”

Geoff KuenningFall 2006

– 2 – CS 105

TextbooksRandal E. Bryant and David R. O’Hallaron, Randal E. Bryant and David R. O’Hallaron,

“Computer Systems: A Programmer’s Perspective”, Prentice Hall 2003.

Brian Kernighan and Dennis Ritchie, Brian Kernighan and Dennis Ritchie, “The C Programming Language, Second Edition”, Prentice Hall, 1988

Larry Miller and Alex QuiliciLarry Miller and Alex Quilici The Joy of C, Wiley, 1997

– 3 – CS 105

Syllabus

Syllabus on Web Calendar defines due dates Labs - cs105submit for some, others have specific directions

– 4 – CS 105

Course ComponentsLecturesLectures

Higher-level concepts

Problems and QuizzesProblems and Quizzes Applied concepts, important tools and skills for labs, clarification of lectures, exam coverage

LabsLabs The heart of the course 1 or 2 weeks Provide in-depth understanding of an aspect of systems

Programming and measurement Time to learn, avoid trying to optimize Teams of two

– 5 – CS 105

Notes:Work groupsWork groups

You must work in pairs on all labs Honor-code violation to work without your partner!

HandinsHandins Check calendar. Electronic submissions only.

Appealing gradesAppealing grades Labs - Talk to the lead person on the assignment.

Grading CharacteristicsGrading 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

– 6 – CS 105

CheatingWhat is cheating?What is cheating?

Sharing code: either by copying (web search, etc), retyping, looking at, or supplying a copy of a file.

What is NOT cheating?What is NOT cheating? Helping others use systems or tools. Helping others with high-level design issues. Helping others debug their code.

– 7 – CS 105

FacilitiesAssignments will use Intel Computer Assignments will use Intel Computer SystemsSystems Wilkes - X86, Linux Directories cross-mounted, so you must create an X86 worldEasy way: subdirectory for this classFancy way: put $HOME/bin/$ARCH in path

– 8 – CS 105

Programs and Data

TopicsTopics Bit operations, arithmetic, assembly language programs, representation of C control and data structures

Includes aspects of computer architecture and compilers

AssignmentsAssignments L1: Manipulating bits L2: Debugger L3: Defusing a binary bomb L4: Cracking with a buffer overflow

– 9 – CS 105

Performance

TopicsTopics High-level processor models Compiler optimizations Helping the compiler Includes aspects of architecture, compilers, and OS

AssignmentsAssignments No specific lab

– 10 – CS 105

The Memory Hierarchy, Caching, VM

TopicsTopics Memory technology, memory hierarchy, caches, disks, locality

Virtual memory, address translation Dynamic storage allocation

AssignmentsAssignments L5: Memory allocator

– 11 – CS 105

Linking and Exceptions Topics - OverviewTopics - Overview

Object files, static and dynamic linking, libraries, loading

Hardware exceptions, Unix signals, non-local jumps Includes aspects of compilers, OS, and architecture

AssignmentsAssignments No specific lab

– 12 – CS 105

Processes and Concurrency TopicsTopics

Process creation, process hierarchy, shared memory between processes

Semaphores, critical sections Threads

AssignmentsAssignments L6: Threads

– 13 – CS 105

I/O, Networking

TopicsTopics High level and low-level I/O, network programming, Internet services, Web servers

Includes aspects of networking, OS, and architecture.

AssignmentsAssignments No specific lab

– 14 – CS 105

Lab Rationale Each lab has a well-defined goal such as solving a Each lab has a well-defined goal such as solving a

puzzle or winning a contest. puzzle or winning a contest. Defusing a binary bomb Winning a performance contest

Doing a lab should result in new skills and conceptsDoing a lab should result in new skills and concepts Data Lab: computer arithmetic, digital logic Bomb Labs: assembly language, using a debugger, understanding the stack

Threads Lab: Concurrency Sockets Lab: Intercomputer communication

We try to use competition in a fun and healthy way.We try to use competition in a fun and healthy way. Set a threshold for full credit Post intermediate results (anonymized) on Web page for glory!

– 15 – CS 105

Good Luck!

– 16 – CS 105

Introduction to Computer Systems

Topics:Topics: Theme Five great realities of computer systems

How this fits within CS curriculum

intro.ppt

CS 105“Tour of the Black Holes of Computing”

Geoff Kuenning

Fall, 2006

– 17 – CS 105

Course Theme Abstraction is good, but don’t forget reality!

Many CS Courses emphasize abstractionMany CS Courses emphasize abstraction Abstract data types Asymptotic analysis

These abstractions have limitsThese abstractions have limits Especially in the presence of bugs Need to understand underlying implementations

Useful outcomesUseful outcomes Become more effective programmers

Able to find and eliminate bugs efficientlyAble to tune program performance

Prepare for later “systems” classes in CSCompilers, Operating Systems, Networks, Computer Architecture, Robotics, etc.

– 18 – CS 105

Great Reality #1Ints are not Integers, Floats are not Ints are not Integers, Floats are not

Reals !!Reals !!

ExamplesExamples Is x2 ≥ 0?

Floats: Yes!Ints:

» 40000 * 40000 --> 1600000000» 50000 * 50000 --> ??

Is (x + y) + z = x + (y + z)?Unsigned & Signed Ints: Yes!Floats:

» (1e20 + -1e20) + 3.14 --> 3.14» 1e20 + (-1e20 + 3.14) --> ??

– 19 – CS 105

Computer ArithmeticDoes not generate random valuesDoes not generate random values

Arithmetic operations have important mathematical properties…BUT

Cannot assume “usual” propertiesCannot assume “usual” properties Due to finiteness of representations Integer operations satisfy “ring” properties

Commutativity, associativity, distributivity Floating-point operations satisfy “ordering” properties

Monotonicity, values of signs

ObservationObservation Need to understand which abstractions apply in which contexts

Important issues for compiler writers and serious application programmers

– 20 – CS 105

Great Reality #2You’ve got to know assemblyYou’ve got to know assembly

Chances are, you’ll never program in Chances are, you’ll never program in assembly…Cassembly…C Compilers are much better & more patient than you are

Understanding assembly key to machine-level Understanding assembly key to machine-level execution modelexecution model Behavior of programs in presence of bugs

High-level language model breaks down Tuning program performance

Understanding sources of program inefficiency Implementing system software

Compiler has machine code as targetOperating systems must manage process state

– 21 – CS 105

Assembly Code ExampleTime Stamp CounterTime Stamp Counter

Special 64-bit register in Intel-compatible machines

Incremented every clock cycle Read with rdtsc instruction

ApplicationApplication Measure time required by procedure

In units of clock cycles…NOT instructionsdouble t;start_counter(); ---need to access regP();t = get_counter(); ---need to access regprintf("P required %f clock cycles\n", t);

– 22 – CS 105

Code to Read Counter Write small amount of assembly code using GCC’s asm facility

Inserts assembly code into machine code generated by compilerstatic 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");

}

– 23 – CS 105

Code to Read Counter/* Record the current value of the cycle counter. */void start_counter(){ access_counter(&cyc_hi, &cyc_lo);}

/* Number of cycles since the last call to start_counter. */double get_counter(){ unsigned ncyc_hi, ncyc_lo; unsigned hi, lo, borrow; /* Get cycle counter */ access_counter(&ncyc_hi, &ncyc_lo); /* Do double precision subtraction */ lo = ncyc_lo - cyc_lo; borrow = lo > ncyc_lo; hi = ncyc_hi - cyc_hi - borrow; return (double) hi * (1 << 30) * 4 + lo;}

– 24 – CS 105

Measuring TimeTrickier than it Might LookTrickier than it Might Look

Many sources of variation

ExampleExample Sum integers from 1 to n

n Cycles Cycles/n100 961 9.61

1,000 8,407 8.411,000 8,426 8.4310,000 82,861 8.2910,000 82,876 8.29

1,000,000 8,419,907 8.421,000,000 8,425,181 8.43

1,000,000,000 8,371,305,591 8.37

– 25 – CS 105

Great Reality #3Memory MattersMemory Matters

Memory is not unboundedMemory is not unbounded It must be allocated and managed Many applications are memory-dominated

Memory-referencing bugs especially perniciousMemory-referencing bugs especially pernicious Effects are distant in both time and space - SegFault

Memory performance is not uniformMemory 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

– 26 – CS 105

Memory Referencing Bug Example

main (){ long int a[2]; double d = 3.14; a[2] = 1073741824; /* Out of bounds reference */ printf("d = %.15g\n", d); exit(0);}

Alpha MIPS x86-g 5.30498947741318e-315 3.1399998664856 3.14

-O 3.14 3.14 3.14

(x86 version gives correct result, but implementing it as a separate function gives a segmentation fault!)

– 27 – CS 105

Memory Referencing ErrorsC and C++ do not provide any memory protectionC and C++ do not provide any memory protection

Out-of-bounds array references Invalid pointer values Abuses of malloc/free

Can lead to nasty bugsCan lead to nasty bugs Whether or not bug has any effect depends on system and compiler

Action at a distanceCorrupted object logically unrelated to one being accessedEffect of bug may be first observed long after it is generated

How can I deal with this?How can I deal with this? Program in Java, Lisp, or ML Understand what possible interactions may occur Use or develop tools to detect referencing errors

– 28 – CS 105

Memory Performance ExampleImplementations of Matrix MultiplicationImplementations of Matrix Multiplication

Multiple ways to nest loops

/* ijk */for (i=0; i<n; i++) { for (j=0; j<n; j++) { sum = 0.0; for (k=0; k<n; k++) sum += a[i][k] * b[k][j]; c[i][j] = sum; }}

/* jik */for (j=0; j<n; j++) { for (i=0; i<n; i++) { sum = 0.0; for (k=0; k<n; k++) sum += a[i][k] * b[k][j]; c[i][j] = sum; }}

– 29 – CS 105

0

20

40

60

80

100

120

140

160

matrix size (n)

ijkikjjikjkikijkji

Matmult Performance (Alpha 21164)

Too big for L1 Cache Too big for L2 Cache

– 30 – CS 105

Blocked matmult perf (Alpha 21164)

0

20

40

60

80

100

120

140

160

50 75 100 125 150 175 200 225 250 275 300 325 350 375 400 425 450 475 500matrix size (n)

bijkbikjijkikj

– 31 – CS 105

Great Reality #4There’s more to performance than asymptotic There’s more to performance than asymptotic

complexity !!!complexity !!!Constant factors matter too!Constant factors matter too!

Easily see 10:1 performance range depending on how code written

Must optimize at multiple levels: algorithm, data representations, procedures, and loops

Must understand system to optimize Must understand system to optimize performanceperformance How programs compiled and executed How to measure program performance and identify bottlenecks

How to improve performance without destroying code modularity and generality

– 32 – CS 105

Great Reality #5Computers do more than execute programsComputers do more than execute programs

They need to get data in and outThey need to get data in and out I/O system critical to program reliability and performance

They communicate with each other over They communicate with each other over networksnetworks Many system-level issues arise in presence of network

Concurrent operations by autonomous processesCoping with unreliable mediaCross-platform compatibilityComplex performance issues

– 33 – CS 105

Role within Curriculum

Transition from Abstract Transition from Abstract to Concrete!to Concrete! From: high-level language model

To: underlying implementation

CS 70C++ &

Structures

CS 105Systems

CS 134 OperatingSystems

CS 132Compilers

ProcessesMem. Mgmt

Machine CodeOptimization

Data StructuresApplicationsProgramming

CS 125Networks

NetworkProtocols

CS 156Parallel

CS 136Advanced Arch

Exec. ModelMemory System

CS 60Principles of CS

– 34 – CS 105

Course PerspectiveMost systems courses are builder-centricMost systems courses are builder-centric

Computer ArchitectureDesign pipelined processor in Verilog

Operating SystemsImplement large portions of operating system

CompilersWrite compiler for simple language

NetworkingImplement and simulate network protocols

– 35 – CS 105

Course Perspective (Cont.)This course is programmer-centricThis 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 toWrite programs that are more reliable and efficientIncorporate features that require hooks into OS

» E.g., concurrency, signal handlers Not just a course for dedicated hackers

Though we bring out the hidden hacker in everyone Cover material in this course that you won’t see elsewhere