Introduction to Computer Systems at University of Texas at Austin, Lecture notes of Computer Networks

A summary of the course Introduction to Computer Systems taught by Don Fussell at the University of Texas at Austin in Fall 2011. The course covers topics such as the five great realities of computer systems, the importance of understanding assembly, and memory management. examples of assembly code and memory referencing bugs. The course is intended to help students become more effective programmers and prepare for later systems classes in CS such as compilers, operating systems, networks, and computer architecture.

Typology: Lecture notes

2010/2011

Uploaded on 05/11/2023

cristelle
cristelle 🇺🇸

4.5

(53)

374 documents

1 / 30

Toggle sidebar

This page cannot be seen from the preview

Don't miss anything!

bg1
University of Texas at Austin CS429H - Introduction to Computer Systems Fall 2011 Don Fussell
Systems I
Introduction to Computer Systems
Don Fussell
Spring 2011
Topics:
Theme
Five great realities of computer systems
How this fits within CS curriculum
pf3
pf4
pf5
pf8
pf9
pfa
pfd
pfe
pff
pf12
pf13
pf14
pf15
pf16
pf17
pf18
pf19
pf1a
pf1b
pf1c
pf1d
pf1e

Partial preview of the text

Download Introduction to Computer Systems at University of Texas at Austin and more Lecture notes Computer Networks in PDF only on Docsity!

Systems I

Introduction to Computer Systems

Don Fussell

Spring 2011

Topics:

Theme Five great realities of computer systems How this fits within CS curriculum

Course Theme

Abstraction is good, but don’t forget reality!

Courses to date 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, etc.

Computer Arithmetic

Does not generate random values

Arithmetic operations have important mathematical properties

Cannot 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

Observation

Need to understand which abstractions apply in which contexts

Important issues for compiler writers and serious application

programmers

Great Reality

You’ve got to know assembly

Chances are, you’ll never write program in assembly

Compilers are much better & more patient than you are

Understanding assembly key to machine-level execution

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 target Operating systems must manage process state

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"); }

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; }

Great Reality

Memory Matters

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

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 Linux -g 5.30498947741318e-315 3.1399998664856 3. -O 3.14 3.14 3. (Linux version gives correct result, but implementing as separate function gives segmentation fault.)

Memory Performance Example

Implementations 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 } }

0 20 40 60 80 100 120 140 160 matrix size (n) ijk ikj jik jki kij kji

Matmult Performance (Alpha 21164)

Too big for L1 Cache Too big for L2 Cache

Great Reality

There’s more to performance than asymptotic complexity

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 performance

How programs compiled and executed

How to measure program performance and identify bottlenecks

How to improve performance without destroying code modularity

and generality

Great Reality

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

Course Perspective (Cont.)

Our 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

Cover material in this course that you won’t see elsewhere

Teaching staff

Instructor - Don Fussell

Office: ACES 2. Office Hours: MW 11- Email: [email protected] http://www.cs.utexas.edu/~fussell/

TA - Christian Miller

Office: TBD Office Hours: TBD Email: [email protected] http://www.cs.utexas.edu/~ckm