Topics
This page collects class material by topic.
Contents
Textbooks
Electronic options are available for all required sources. At least one physical copy of each text is also available in the physical SCI L037 CS Systems Lab for use within the CS department area. Please use them in the data lab area and return them to the shelf when you are done. If using these shared physical books, please wash your hands before and after. (WWW)
We use one primary textbook extensively:
- CSAPP 3e:
Computer Systems: A Programmer’s Perspective, 3/E. (3rd edition, significant changes since 2nd)
Bryant and O’Hallaron, Pearson, 2016. ISBN-13: 9780134092669.- We need the 3rd edition. See the errata.
- Unfortunately, the library is not able to acquire an electronic
version, but there are several options to access the book,
including, but not limited to:
- If you prefer physical books, paperback copies are available for much less than the hardcover version. “Global” 3rd editions mostly work, but have some additional errors (not listed on the errata page).
- 6 months of access to an electronic version is available for $35.
- During difficult pandemic circumstances, we have scans of the relevant excerpts available for CS 240 students (Wellesley ONLY). Being scans, these excerpts are not quite as good quality as some other electronic or paper options.
- Please contact the instructors if none of the available options work for you.
Other textbooks are used during the first part of the course:
- DDCA:
Digital Design and Computer Architecture.
Harris and Harris, Morgan Kaufmann, 2007. - SCO: References to this book are +optional.
Structured Computer Organization, any edition.
Tanenbaum, Prentice Hall, various.
We recommend a good reference on the C programming language. Here are a couple solid options:
- Essential C (PDF)
Nick Parlante, 2003. Stanford University. - K&R:
The C Programming Language, 2nd edition.
Kernighan and Ritchie, Prentice Hall, 1988. ISBN-13: 978-0131103627, ISBN-10: 0131103628.
Additional materials will be posted directly on the course website.
Preparing for Class Meetings
Before each class meeting, please complete the preparation steps listed in the topic material. Preparation varies from day to day, but usually consists of some combination of watching videos, reading, or trying small exercises.
Completing the preparation is essential to get the most out of each class meeting. Class time itself will assume basic familiarity with the ideas covered in the assigned preparation. Full mastery is not expected. Questions based on the preparation are expected. We will often start with a brief summary of the prep highlights, with time to answer questions upfront or as we start to apply the ideas together, but we will not spend the class time “re-teaching” the complete preparation material from scratch.
How to watch videos for CS 240
Many topics will have videos attached. When asked to watch these videos for preparation, or if you use them for reference at any time:
- You can view them on YouTube (nocookie version without tracking) or download/watch the MP4 files directly.
- Take notes like you would in class.
- You might find it helpful to download a copy of the slides to follow along or take notes.
- It’s fine to pause and take breaks whenever you want!
- You do not need to watch all the videos from one topic or even all the videos assigned for one day of preparation in one sitting. The videos are usually broken up into chunks usually between 5 and 15 minutes length, occasionally a little shorter or longer.
- When the talking Ben head says to “try this,” please pause the video and actually try it, just like you would in class when we do an exercise together. (Don’t worry, the talking Ben head will wait for you in whatever bizarre pose he struck when you hit pause!)
How to read for CS 240
Effective reading for computer science courses demands a staged approach. Aim for two types of reading:
- Do an initial reading in preparation for the class when the topic is scheduled.
- Revisit the reading later for deeper details or reference.
Before class, do an initial reading of the any reading material assigned as preparation for class.
Do not worry about understanding every last detail.
Do aim to acquire:
- A big-picture view of the pieces we will consider about this topic.
- Some familiarity with basic mechanics of the ideas introduced.
To help distinguish core points from secondary concerns during initial reading, each reading is listed with one of two style directives:
- Read means read for enough detail to do indicated reading exercises. If you do get stuck or confused by some details, do not worry. Make a note and move on. If we do not clear up your confusion in class, ask a question or come to office hours.
- Skim means read for high-level ideas. Perhaps pick out a couple details that look interesting and accessible. Do not spend much time trying to understand all the details before moving on.
Learning how to identify essential vs. inessential details during a first reading is an important skill that takes time to develop. As the semester progresses, we will leave more of this to you.
Readings assignments may indicate specific exercises to try as you read before class. These are typically practice problems from the reading.
- Try means work through enough of the exercise to see how the basics work. Do not feel obligated to finish every example. Do what is useful to you. (Do not submit anything.)
We typically highlight exercises that practice mechanics. Feel free to try other practice problems as well. They may require more time and critical thinking. We will explore such interesting examples in class.
After class, revisit readings in more depth and try more practice problems to work out details as needed.
More advice for reading
Our main text (CSAPP) sometimes goes into more detail than we will cover, so learning to “read around” extra detail is a useful skill, especially in your pre-class reading.
When reading from CSAPP:
- “Asides” are optional. If you read them, skim them.
- “New to C?” blocks can be useful, but usually only if they are short.
- Some sections (e.g., 2.2 - 2.4 on integer and floating point representations) can be too dense for our purposes. We try steer you around them, but if you find other things getting dense, flip to another reading or just make a note and jump ahead.
- This book really shines with later material about machine/assembly language, caching, memory management, and other topics. We use it intermittently in the first section of the course, then extensively for the latter two.
Tia Newhall (Swarthmore College) has more good advice on reading computer science textbooks.
Material by Topic
This list of topics includes:
- Topics covered in class meetings, with preparation directions listings of all lecture materials, associated readings, and activities.
- Topics covered in lab that are normally covered in lecture in full-semester versions of CS 240. We include all readings and lecture materials for lectures in full-semester versions of CS 240. Labs do not necessarily use all of this material, but we include for reference.
- +Optional items that offer opportunities to explore further, but are not required.
Data as Bits and Computation as Digital Logic
The Plan
Preparation Before Class
No preparation required for first day of class.
Lecture
Slides: ➊ plan.pdf ➍ plan-4up.pdf
Reading
Digital Logic (lab-only topic)
Lab-only: This topic is covered only in lab. These materials are provided for optional reference in addition to the lab materials.
Lecture
Slides: ➊ gates.pdf ➍ gates-4up.pdf
Reading
By our first full class day on this topic, you should be familiar with at least the basics of logic gates, notation for Boolean expressions, and a little Boolean algebra.
- Read: Syllabus
- Read: How to Read for CS 240
- Read: DDCA 1.5, 2.1-2.4 (pages 51-65)
+Optional alternatives/extras:
Try these if you want alternatives to the DDCA reading above or if you want some practice or you just can’t wait until class.
- SCO 3.1. Skip physical technologies: MOS, TTL, ECL, etc.
- Web pages covering roughly the same material with inline examples and exercises.
- Digital logic gates:
- Bucknell EE: An Introduction to Digital Logic - Signals and Gates. Stop at “Wiring a Quad NAND Gate.”
- Surrey EE: Basic Gates and Functions
- Digital Circuits and Boolean Logic. Stop at “Implementing Gates.”
- Boolean algebra
- Bucknell EE: Boolean Algebra.
- Surrey EE: Boolean Algebra
- Digital logic gates:
- Some more exercises
- Gates quiz (EXOR = XOR)
- Boolean algebra example, problem, and quiz
Data as Bits
Preparation Before Class
For Monday:
- No preparation required for first day of class.
For Tuesday:
- Readings #1-2 (below), for reading perspective and review.
- Videos #3-5 (below).
For Wednesday:
- Videos #8, 10, 12 (below).
- Follow up before or after class with Readings #3-4.
Lecture
Slides: ➊ bits.pdf ➍ bits-4up.pdf
Videos: ☰ yt playlist Data as Bits
- Positional Number Representation and Binary (LIVE Monday)
- Binary Number Conversion and Arithmetic (LIVE Monday)
- ▸ mp4 yt Bytes and Hexadecimal
- ▸ mp4 yt Fixed-size Data Types
- ▸ mp4 yt Bitwise Operators
- Bit Sets (LIVE Tuesday)
- Bitwise Operator Practice (LIVE Tuesday)
- ▸ mp4 yt Boolean Logical Operators
- Card Encoding Ideas (LIVE Tuesday)
- ▸ mp4 yt Compact Encodings with Bit Fields and Masks
- Mask Practice (LIVE Wednesday)
- ▸ mp4 yt Bit Shifting
- Shift and Mask (LIVE Wednesday)
Reading
- How to read
- Binary and hexadecimal number systems
- Information as bits + context
- Bitwise Boolean algebra and bit manipulation
Integer Representation
Preparation Before Class
For Thursday:
- +Optional review: videos 1-3.
- Addition and overflow: videos 5-6.
For Reference after Thursday Class:
Helpful for the Bits assignment!
- Reading 1, video 4.
- Videos 7-10.
- Reading 2.
Lecture
Slides: ➊ integers.pdf ➍ integers-4up.pdf
Exercises:
Videos: ☰ yt playlist Integer Representation
- ▸ mp4 yt Unsigned Representation, Modular Arithmetic, Overflow (LIVE Wednesday)
- ▸ mp4 yt Sign-Magnitude Representation (LIVE Wednesday)
- ▸ mp4 yt Two's Complement Representation (LIVE Wednesday)
- ▸ mp4 yt Two's Complement Examples (LIVE Thursday)
- ▸ mp4 yt Two's Complement Addition (LIVE Wednesday)
- ▸ mp4 yt Two's Complement Overflow
- ▸ mp4 yt Overflow and Reliability
- ▸ mp4 yt Two's Complement is Awesome, Complement Rules (LIVE Thursday)
- ▸ mp4 yt Deriving Two's Complement
- ▸ mp4 yt Sign Extension (LIVE Thursday)
- ▸ mp4 yt Shift Arithmetic (LIVE Thursday)
- ▸ mp4 yt Shift and Add (LIVE Thursday)
- ▸ mp4 yt Shift and Add Puzzle Review
- ▸ mp4 yt Muliplication
- ▸ mp4 yt Converting Between Unsigned and Signed Types
Reading
Refer to this material only after videos/class. We’d like to introduce signed integer representations before you read about them.
As you read, focus on the positional representation of signed integers more than the mechanics of how to convert from integer representation to the representation you know well.
-
For the basics, read one of:
- “Twos Complement” section of these notes. Stop at “Floating Point.”
- Fundamentals of Data Representation: Two’s Complement
- SCO A.4 - A.5
- CSAPP’s treatment of number representation is more thorough, but
some students find it too dense and prefer to skip some parts.
- Read: CSAPP 2.2 - 2.2.3.
-
Then, for reference on integer multiplication and division, their relation to bitwise operations, and sign extension:
Combinational Logic (lab-only topic)
Lab-only: This topic is covered only in lab. These materials are provided for optional reference in addition to the lab materials.
Lecture
Slides: ➊ mux.pdf ➍ mux-4up.pdf
Reading
Karnaugh Maps
Multiplexers and decoders
- Read: DDCA 2.8 (pages 79-84)
- +Optionally, read: SCO 3.2.2 (Combinational Circuits)
+Floating Point Number Representation (optional topic)
+Optional: This topic is an optional opportunity for further depth or exploration.
Lecture
Slides: ➊ floats.pdf ➍ floats-4up.pdf
Reading
- Skim one of:
- DDCA 5.3 (pages 249-253)
- SCO Appendix B
- If you want more detail (e.g., on denormalization as discussed in class, or many in-depth examples), read CSAPP 2.4.
Processor Building Blocks and the Memory Model
Arithmetic Logic (lab-only topic)
Lab-only: This topic is covered only in lab. These materials are provided for optional reference in addition to the lab materials.
Lecture
Slides: ➊ alu.pdf ➍ alu-4up.pdf
Reading
Adders
- Read one of:
- DDCA 5.1 - 5.2.1 (pages 233-234) up through Ripple Carry Adders (feel free to skim beyond if you are curious, ignore Verilog and VHDL)
- SCO 3.2.3 (Arithmetic Circuits)
- Digital Circuits: Adders up until Carry Lookahead Adder (feel free to skim beyond if you are curious)
Arithmetic Logic Unit
- Read one of these to understand the high-level organization of an ALU. We will look at details of a specific ALU design in class.
- DDCA 5.2.2 - 5.2.4 (pages 23-234) up through Ripple Carry Adders (feel free to skim beyond if you are curious)
- SCO 3.2.3 section on Arithmetic Logic Units
- Arithmetic Logic Unit sections “Signals” and “Circuit Operation”
Programming with Memory
Preparation Before Class
For Monday:
- Videos 1-6. Expect to have some questions, especially further in. This usually takes some repetition. (Note this is longer prep than usual; class time will aim to compensate.)
For Tuesday:
- As needed, review arrays and pointer arithmetic with videos 7-9 or readings.
- Complete as much of Part 1 of the
Pointer Practice
exercises from class as you can. Work with a partner if possible.
- You may find videos 10-11 and 12 (which introduces the first few examples in that exercise) useful if you’re stuck near the beginning.
- We will share solutions to review later.
For Wednesday:
- Videos 16-19 (most important), plus 20-21 (context, heads up about bugs). If you don’t get through all of these, no worries, you’ll be able to fill in the gaps during exercises in class. Happy hacking on bits!
As needed:
- Readings and other reference below for alternative perspectives on the same ideas.
Lecture
Slides: ➊ memory.pdf ➍ memory-4up.pdf
Exercises:
Videos: ☰ yt playlist Programming with Memory
- ▸ mp4 yt Byte-Addressable Memory
- ▸ mp4 yt Multi-Byte Values in Memory
- ▸ mp4 yt Data, Addresses, Pointers
- ▸ mp4 yt C Variables as Memory Locations
- ▸ mp4 yt C Pointer Primitives
- ▸ mp4 yt C Pointer Example
- ▸ mp4 yt C Arrays (LIVE Monday)
- ▸ mp4 yt C Arrays and Pointers (LIVE Monday)
- ▸ mp4 yt C Pointer Arithmetic (LIVE Monday)
- ▸ mp4 yt C Array Sizing
- ▸ mp4 yt C Array Expression Examples
- ▸ mp4 yt Pointer Practice Exercise Intro
- ▸ mp4 yt C Strings (LIVE Tuesday)
-
▸ mp4
yt
C Strings as
char*
and Cursor Pointer Style (LIVE Tuesday) -
▸ mp4
yt
C
0
,'\0'
, andNULL
- ▸ mp4 yt Memory Address Space Layout
-
▸ mp4
yt
C Memory Allocation with
malloc
/free
- ▸ mp4 yt C Arrays of Pointers to Arrays
-
▸ mp4
yt
zipCount
Review -
▸ mp4
yt
C
scanf
and Memory Errors Teaser - ▸ mp4 yt Why C?
Reading
General memory model:
- +Optionally, read: SCO 2.2.2 - 2.2.3, 5.1.2 (stop at “Note that having separate address spaces for instructions and data”)
- Read: CSAPP 2.1.0, 2.1.3 - 2.1.4
Mix and match to start learning about addresses and pointers in C:
- Read: CSAPP 3.10.1
- Read Pointer Basics and watch the silly video too.
- K&R 5 - 5.5
- The Descent to C
- The 5-minute Guide to C Pointers
+Reasoning about Programs (optional topic)
+Optional: This topic is an optional opportunity for further depth or exploration.
Lecture
Slides: ➊ assertions.pdf ➍ assertions-4up.pdf
Reading
In most semesters, we do not have time to cover this topic in lecture, but we ask you to skim these resources.
- How to use assertions in C, John Reekie.
- The benefits of programming with assertions (a.k.a. assert statements), Philip Guo.
For later:
- C Programming Tips, Philip Guo.
Sequential Logic (lab-only topic)
Lab-only: This topic is covered only in lab. These materials are provided for optional reference in addition to the lab materials.
Lecture
Slides: ➊ registers.pdf ➍ registers-4up.pdf
Reading
- Read one of:
- DDCA 3.0 - 3.2.4 (pages 103-109)
- SCO 3.3 - 3.3.2 (3rd ed.) / 3.3.3 (4th ed.), Latches, Flip-Flops, Registers
- Read DDCA 5.5 - 5.5.1 (pages 257-262) (ignore Verilog and VHDL). We will cover RAM only briefly.
The Instruction Set Architecture Model
x86 Basics
Preparation Before Class
For Thursday:
- No preparation required!
- Monday prep is a little longer, so feel free to get started on that now if you are that bored…
For Monday:
Mix and match videos or readings (whichever you prefer) to understand basics of x86, registers, data movement instructions, the lea (load effective address) intruction, and basic stack instructions.
- Videos 1-6.
- Readings 1-3.
Lecture
Slides: ➊ x86-basics.pdf ➍ x86-basics-4up.pdf
Exercises:
Videos: ☰ yt playlist x86 Basics
- ▸ mp4 yt Intro and History
- ▸ mp4 yt Registers, Data Movement Instructions, and Memory Addressing Modes
- ▸ mp4 yt Memory Examples
- ▸ mp4 yt Memory Addressing Review
- ▸ mp4 yt Load Effective Address (lea)
- ▸ mp4 yt Procedure Call Stack Basics
-
▸ mp4
yt
Arithmetic and Logic Instructions,
arith
Exercise Setup -
▸ mp4
yt
arith
Exercise Review,logical
Exercise Setup -
▸ mp4
yt
logical
Exercise Review
Reading
x86 Control Flow
Preparation Before Class
For Tuesday:
- Videos 1-2.
- Readings 1-2.
For Wednesday:
- Videos 5-8
- Readings 3-4
Lecture
Slides: ➊ x86-control.pdf ➍ x86-control-4up.pdf
Exercises:
Videos: ☰ yt playlist x86 Control Flow
- ▸ mp4 yt Condition Codes, Comparisons, and Tests
-
▸ mp4
yt
Jumps, Translating If-Else, and
absdiff
Exercise Setup -
▸ mp4
yt
absdiff
Exercise Review, goto, and If Compilation Exercise Setup - ▸ mp4 yt If Compilation Exercise Review and PC-Relative Addressing
- ▸ mp4 yt Translating Loops
- ▸ mp4 yt Conditional Moves
- ▸ mp4 yt Translating Switch Statements with Jump Tables
- ▸ mp4 yt Translating Switch Statement Cases, Reverse Engineering Switches
Reading
-
Comparisons, Tests, and Jumps
-
Translating
if
conditionals -
Translating loops
-
Translating
switch
statements- Skim: CSAPP 3.6.8, 3.6.6
The Procedure Call Stack Model and Data Layout
x86 Procedures, Call Stack
Preparation Before Class
For Thursday:
No prep required before class. We will hit the highlights of these things; the videos/readings cover additional details that may be helpful.
- Videos 1, 2.
- Reading 1
For Monday:
- Videos 3-4 for review. Videos 5-6 to get a taste before Monday. (Also useful for lab and definitely useful for later phases in the x86 assignment.)
- Reading 2
Lecture
Slides: ➊ x86-procedures.pdf ➍ x86-procedures-4up.pdf
Videos: ☰ yt playlist x86 Procedures, Call Stack
- ▸ mp4 yt The Call Stack Stores Procedure Context
-
▸ mp4
yt
Procedure Control Flow Instructions (
call
/ret
), Data Flow Conventions, Puzzle Setup - ▸ mp4 yt Procedure Puzzle Review
- ▸ mp4 yt Procedure and Stack Frame Example
- ▸ mp4 yt Register Saving Conventions, Callee-Save Example
- ▸ mp4 yt Recursion Example
- ▸ mp4 yt Stack Storage Example, Procedure Summary
Reading
Representing Data Structures
Preparation Before Class
For Tuesday:
Mix and match videos and readings to review arrays at the x86 level and learn the basics of C structs.
- Video 1 (review arrays at the x86 level)
- Videos 5-6 (basics of C structs)
- Readings 1, 2, 4.
Lecture
Slides: ➊ data-structures.pdf ➍ data-structures-4up.pdf
Exercises:
Videos: ☰ yt playlist Representing Data Structures
- ▸ mp4 yt Simple Arrays
-
▸ mp4
yt
Multi-Level Arrays (Arrays of Pointers to Arrays of...)
Errors:- In the copyleft example, all occurrences of 4 in the x86 code should be replaced by 8.
- ▸ mp4 yt Row-Major Multidimensional Arrays
- ▸ mp4 yt Row-Major Array Review
- ▸ mp4 yt Structs
- ▸ mp4 yt Struct Alignment
- ▸ mp4 yt Linked List Representation
Reading
Buffer Overflows
Preparation Before Class
No preparation required.
Lecture
Slides: ➊ buffer.pdf ➍ buffer-4up.pdf
Exercises:
Videos: ☰ yt playlist Buffer Overflows
- ▸ mp4 yt Overview
- ▸ mp4 yt Stack Layout and No Bounds Checking in C
- ▸ mp4 yt Example Overview
- ▸ mp4 yt Example 1 - Overwrite Padding (Lucky)
- ▸ mp4 yt Example 2 - Corruption and Segfault
- ▸ mp4 yt Example 3 - Silent Corruption and Arbitrary Code Execution
- ▸ mp4 yt Remote Code Execution and Avoiding Vulnerabilities
Reading
- Read: CSAPP 3.10.3-3.10.4
The Memory Hierarchy, Cache, and Memory Allocation
Memory Hierarchy, Cache
Preparation Before Class
For Thursday:
No preparation.
For Monday:
Mix and match videos or readings as you prefer, to learn about the memory hierarchy, locality, cache mechanics and organization, and direct-mapped caches:
- Videos 1-2 (review of Thursday’s in-class overview).
- Videos 3-4, 6-10.
- Reading 1.
If you missed discussion of 2D nested arrays earlier, you may want to review Video 3 or Reading 2 from the data structures topic.
For Tuesday:
- Try the Cache Practice Exercises up through “Cache Address Field Exercise.”
- No other prep.
Lecture
Slides: ➊ cache.pdf ➍ cache-4up.pdf
Exercises:
Videos: ☰ yt playlist Memory Hierarchy, Cache
- ▸ mp4 yt Motivating Example
- ▸ mp4 yt Cache Overview
- ▸ mp4 yt Cache Mechanics
- ▸ mp4 yt Locality
- ▸ mp4 yt More Locality Examples
- ▸ mp4 yt Cache Performance and the Hierarchical Memory Design
- ▸ mp4 yt Cache Organization
- ▸ mp4 yt Cache Blocks
- ▸ mp4 yt Direct-Mapped Cache Placement Policy and Cache Tags
- ▸ mp4 yt Address Fields
- ▸ mp4 yt Why Not Another Direct Mapping (Aside)
- ▸ mp4 yt Cache Puzzle 1
- ▸ mp4 yt Cache Conflicts and Associative Cache Placement Policies
- ▸ mp4 yt Cache Puzzle 2
- ▸ mp4 yt General Cache Dimensions and Organization
- ▸ mp4 yt General Cache Read Mechanics
- Cache Analysis Example 1: Spatial Locality in Direct-Mapped Caches
- Cache Analysis Example 2: Cache Conflicts in Direct-Mapped Caches
- Cache Analysis Example 3: Cache Conflicts Resolved by Associativity
- Types of Cache Misses
- Cache Write Policies
- Cache-Friendly Code and Summary
Reading
Memory Allocation
Preparation Before Class
For Wednesday:
- Video 1
- Reading 1.
For Thursday (including Lab):
- Videos 2-6 (review implicit free lists)
- Video 11 (block format for the Malloc assignment)
For the Malloc assignment:
- Videos 7-10
Lecture
Slides: ➊ malloc.pdf ➍ malloc-4up.pdf
Videos: ☰ yt playlist Memory Allocation
- ▸ mp4 yt Allocator Basics
- ▸ mp4 yt Determining Block Size
- ▸ mp4 yt Block Format and Heap Layout
- ▸ mp4 yt Implicit Free List Search
- ▸ mp4 yt Implicit Free List Allocation and Splitting
- ▸ mp4 yt Implicit Free List Freeing and Coalescing
- ▸ mp4 yt Explicit Free Lists
- ▸ mp4 yt Explicit Free List Search, Allocation, and Splitting
- ▸ mp4 yt Explicit Free List Freeing and Coalescing
- ▸ mp4 yt Seglists and Allocation Summary
-
▸ mp4
yt
Malloc Assignment - Block Format
Errors:- Note that this video was recorded in Spring 2020 before the "Remembrallocator" title for the Malloc assignment was retired along with the past course assignment theme.
Reading
The Process Model and Virtual Memory
Exceptional Control Flow
Process Model
+Shells, Signals (optional topic)
+Optional: This topic is an optional opportunity for further depth or exploration.
Lecture
Slides: ➊ shell.pdf ➍ shell-4up.pdf