Skip to content

1. SENG475/ECE596C — Video-Lecture Schedule — 2025-05

Note

Please be sure to use the "refresh" button in your web browser to ensure that you are viewing the most recent version of this web document.

1.1 Preamble

The vast majority of the instructional content for the course is provided in the form of prerecorded video lectures. This document identifies all of the video lectures that a student must watch and provides a schedule indicating the minimum pace at which the material in these video lectures can be covered. It is important to understand that the provided schedule corresponds to the slowest pace at which a student could watch the video lectures and still have a reasonable expectation of a favorable outcome in the course. It is absolutely critical that students not fall behind the minimum-pace schedule presented. Furthermore, each student is encouraged, to whatever extent is possible, to cover the course material at a faster pace than that indicated in the provided schedule in order to give the student more breathing room for handling unanticipated events that could cause unexpected delays on the work in this course (such as illness or Internet/power outages). It is critically important that the student watch the video lectures far enough in advance that they have sufficient time to ask questions about the lecture material and gain a reasonable understanding of it before the time at which they need to use their knowledge of the material for an assignment or exam.

In order to maximize the chances of a positive outcome in the course, students are strongly recommended to heed the following advice with respect to video-lecture viewing:

  • Work ahead. The student is encouraged to work ahead to the greatest extent that is practical. By working ahead, the student will maximize their protection against the many (unexpected) factors that can cause a student to fall behind. Due to the nature of the material covered in the course, falling behind can often have disastrous consequences for a student (i.e., failing the course).

  • Plan for the unexpected. When a student is establishing their viewing schedule for the video lectures, it is extremely important to leave some margin for error to account for unanticipated events. That is, it is inevitable that, from time to time during the term, unexpected circumstances will arise that slow a student's progress (e.g., illness, computer problems, Internet-connectivity problems, and so on). Therefore, it is extremely important that some extra margin for error be included in the planned viewing schedule to account for these types of circumstances.

  • Avoid binge watching. The student should avoid binge watching video lectures at all costs. It is impossible to develop a good understanding of material covered in binge watched video lectures.

1.2 Video-Lecture Schedule

The minimum-pace lecture schedule is as given below. The names of videos and slides referenced below correspond to the ones used in the video-lecture catalog document (available from the Video Lectures section of the course website).

Again, the schedule provided corresponds to the absolute slowest pace at which students might reasonably expect to consume lecture content in the course. Therefore, students are strongly encouraged to work ahead of this schedule. Also, although the various milestones in this schedule are specified with respect to the days on which the scheduled lecture time slots for the course fall, this is not meant to imply that students should only watch video lectures on these days. Spreading the video-lecture workload over all days of the week is likely to be highly beneficial.

Danger

Please be aware that a significant amount of manual data entry is required in the preparation of the information in this schedule. Manual data entry is always somewhat error prone. Although the instructor has done his best to try to ensure the correctness of this information, some errors are likely inevitable. If you notice any errors in this information, please inform the instructor so that he can correct them.

The indication of due dates for assignments is only intended to be approximate. Please consult the course website for the exact submission deadlines for assignments.

Warning

This schedule information will be updated throughout the term in order to make improvements and/or corrections. Therefore, you are advised to refer directly to this online document (whenever you have a working Internet connection) instead of relying on your own separate copy (e.g., made by printing this web page to a PDF document using your web browser). The date/time of the last revision of the schedule information is given in a note below.

Note

The following schedule was last revised: 2025-05-04 at 09:17:49.

1.2.1 Week 1: May 05—09, 2025

1.2.1.1 Lecture 1: Wed May 07, 2025

1.2.1.2 Lecture 2: Fri May 09, 2025

  • Lecture 2 (2019-05-08) — Algorithms and Data Structures
    • 00:00—01:07: [algorithms] Algorithms [title slide]
    • 01:07—02:16: [algorithms] Software Performance
    • 02:16—04:17: [algorithms] Random-Access Machine (RAM) Model
    • 04:17—08:21: [algorithms] Worst-Case, Average, and Amortized Complexity
    • 08:21—09:55: [algorithms] Asymptotic Analysis of Algorithms
    • 09:55—???: [algorithms] Big Theta (\Theta) Notation
    • ???—12:12: [algorithms] Big Theta (\Theta) Notation (Continued)
    • 12:12—???: [algorithms] Big Oh (O) Notation
    • ???—13:01: [algorithms] Big Oh (O) Notation (Continued)
    • 13:01—???: [algorithms] Big Omega (\Omega) Notation
    • ???—15:32: [algorithms] Big Omega (\Omega) Notation (Continued)
    • 15:32—17:06: [algorithms] Asymptotic Notation in Equations and Inequalities
    • 17:06—18:30: [algorithms] Properties of \Theta, O, and \Omega
    • 18:30—18:49: [algorithms] Additional Remarks
    • 18:49—22:30: [algorithms] Remarks on Asymptotic Complexity
    • 22:30—23:32: [algorithms] Some Common Complexities
    • 23:32—25:12: [algorithms] Recurrence Relations
    • 25:12—26:24: [algorithms] Solving Recurrence Relations
    • 26:24—27:39: [algorithms] Solutions for Some Common Recurrence Relations
    • 27:39—30:10: [algorithms] Iterative Fibonacci Algorithm: Time Complexity
    • 30:10—31:04: [algorithms] Iterative Fibonacci Algorithm: Space Complexity
    • 31:04—32:47: [algorithms] Recursive Fibonacci Algorithm: Time Complexity
    • 32:47—34:34: [algorithms] Recursive Fibonacci Algorithm: Space Complexity
    • 34:34—38:02: [algorithms] Amdahl's Law
    • 38:02—41:14: [data_structures] Abstract Data Types (ADTs)
    • 41:14—43:17: [data_structures] Container ADTs
    • 43:17—45:35: [data_structures] Container ADTs (Continued)
    • 45:35—49:41: [data_structures] Iterator ADTs

1.2.2 Week 2: May 12—16, 2025

1.2.2.1 Lecture 3: Tue May 13, 2025

  • Lecture 3 (2019-05-10) — Data Structures
    • 00:00—03:26: [data_structures] Container and Iterator Considerations
    • 03:26—08:23: [data_structures] Container and Iterator Considerations (Continued)
    • 08:23—10:43: [data_structures] List ADT
    • 10:43—???: [data_structures] Array-Based Lists
    • ???—14:38: [data_structures] Array-Based Lists: Diagram
    • 14:38—19:15: [data_structures] Remarks on Array-Based Lists
    • 19:15—???: [data_structures] Singly-Linked Lists
    • ???—???: [data_structures] Singly-Linked Lists: Code
    • ???—29:52: [data_structures] Singly-Linked Lists: Diagram
    • 29:52—33:19: [data_structures] Remarks on Singly-Linked Lists
    • 33:19—???: [data_structures] Singly-Linked List With Header Node
    • ???—???: [data_structures] Singly-Linked List With Header Node: Code
    • ???—40:52: [data_structures] Singly-Linked List With Header Node: Diagram
    • 40:52—41:49: [data_structures] Remarks on Singly-Linked List With Header Node
    • 41:49—???: [data_structures] Doubly-Linked Lists
    • ???—???: [data_structures] Doubly-Linked Lists: Code
    • ???—45:55: [data_structures] Doubly-Linked Lists: Diagram
    • 45:55—46:22: [data_structures] Remarks on Doubly-Linked Lists [starting from end of preceding slide]

1.2.2.2 Lecture 4: Wed May 14, 2025

  • Lecture 4 (2019-05-14) — Data Structures, Some C++ Review (Const and Other Stuff)
    • 00:00—???: [data_structures] Doubly-Linked List With Sentinel Node
    • ???—???: [data_structures] Doubly-Linked List With Sentinel Node: Code
    • ???—05:46: [data_structures] Doubly-Linked List With Sentinel Node: Diagram
    • 05:46—07:23: [data_structures] Remarks on Doubly-Linked Lists With Sentinel Node
    • 07:23—08:25: [data_structures] Stack ADT
    • 08:25—???: [data_structures] Array Implementation of Stack
    • ???—09:13: [data_structures] Array Implementation of Stack: Diagram
    • 09:13—10:52: [data_structures] Remarks on Array Implementation of Stack
    • 10:52—???: [data_structures] Node-Based Implementation of Stack
    • ???—11:29: [data_structures] Node-Based Implementation of Stack: Diagram
    • 11:29—13:28: [data_structures] Remarks on Node-Based Implementation of Stack
    • 13:28—14:43: [data_structures] Queue ADT
    • 14:43—16:32: [data_structures] Array Implementation of Queue
    • 16:32—17:40: [data_structures] Remarks on Array Implementation of Queue
    • 17:40—???: [data_structures] Array of Arrays Implementation of Queue
    • ???—22:03: [data_structures] Array of Arrays Implementation of Queue: Diagram
    • 22:03—22:22: [data_structures] Remarks on Array of Arrays Implementation of Queue
    • 22:22—???: [data_structures] Node-Based Implementation of Queue
    • ???—22:51: [data_structures] Node-Based Implementation of Queue: Diagram
    • 22:51—23:02: [data_structures] Remarks on Node-Based Implementation of Queue
    • 23:02—24:11: [data_structures] Trees
    • 24:11—24:42: [data_structures] Tree Terminology (Continued 1)
    • 24:42—25:20: [data_structures] Tree Terminology (Continued 2)
    • 25:20—25:58: [data_structures] Binary Trees
    • 25:58—26:24: [data_structures] Perfect and Complete Trees
    • 26:24—27:25: [data_structures] Balanced Binary Trees
    • 27:25—???: [data_structures] Node-Based Binary Tree
    • ???—???: [data_structures] Node-Based Binary Tree: Diagram
    • ???—29:11: [data_structures] Remarks on Node-Based Binary Tree
    • 29:11—29:49: [data_structures] Array-Based Binary Tree
    • 29:49—???: [data_structures] Array-Based Binary Tree: Diagram
    • ???—31:19: [data_structures] Remarks on Array-Based Binary Tree
    • 31:19—33:33: [data_structures] Binary Search Trees
    • 33:33—34:34: [data_structures] Heaps
    • 34:34—36:20: [data_structures] Set and Multiset ADTs
    • 36:20—???: [data_structures] Map and Multimap ADTs
    • ???—38:04: [data_structures] Remarks on Implementation of Sets and Maps
    • 38:04—41:01: [data_structures] Priority Queue ADT
    • 41:01—41:40: [data_structures] Remarks on Priorty Queue Implementations
    • 41:40—45:15: [basics] References Versus Pointers
    • 45:15—45:34: [basics] The const Qualifier
    • 45:34—49:37: [basics] The const Qualifier and Non-Pointer/Non-Reference Types

1.2.2.3 Lecture 5: Fri May 16, 2025

  • Lecture 5 (2019-05-15) — Some C++ Review (Const and Other Stuff)
    • 00:00—01:27: [basics] The const Qualifier and Non-Pointer/Non-Reference Types
    • 01:27—05:07: [basics] The const Qualifier and Pointer Types
    • 05:07—09:39: [basics] The const Qualifier and Reference Types
    • 09:39—16:08: [basics] The constexpr Qualifier for Variables
    • 16:08—20:43: [basics] The const Qualifier and Functions
    • 20:43—20:53: [basics] String Length Example: Not Const Correct
    • 20:53—???: [basics] Square Example: Not Const Correct
    • ???—25:51: [basics] Square Example: Const Correct
    • 25:51—27:29: [basics] Square Example: Const Correct
    • 27:29—32:30: [basics] Function Types and the const Qualifier
    • 32:30—???: [exercises] [Q.1] What is Wrong With This Code?
    • ???—50:12: [exercises] [Q.1] Solution: Use Const Qualifier Correctly
  • NOTE : Assignment 0 (cpp_tools): Due approximately on the day of today's lecture. Consult the course website for the precise submission deadline.

1.2.3 Week 3: May 19—23, 2025

1.2.3.1 Holiday: Mon May 19, 2025

1.2.3.2 Lecture 6: Tue May 20, 2025

  • Lecture 6 (2019-05-17) — Some C++ Review (Const and Other Stuff), Compile-Time Computation
    • 00:00—???: [exercises] [Q.2] What is Wrong With This Code?
    • ???—08:10: [exercises] [Q.2] Solution: Use Const Qualifier Correctly
    • 08:10—???: [exercises] [Q.3] What is Wrong With This Code?
    • ???—16:17: [exercises] [Q.3] Solution: Functions Should Be Inline
    • 16:17—???: [exercises] [Q.4] What is Wrong With This Code?
    • ???—19:22: [exercises] [Q.4] Solution: Place Inline Function Definitions in Header File
    • 19:22—???: [exercises] [Q.5] What is Wrong With This Code?
    • ???—???: [exercises] [Q.5] Solution 1: Explicit Template Instantiation
    • ???—27:07: [exercises] [Q.5] Solution 2: Define Function Template in Header File
    • 27:07—32:33: [exercises] Remarks on Header Files and Function Declarations
    • 32:33—???: [exercises] [Q.6] What is Wrong With This Code?
    • ???—41:02: [exercises] [Q.6] Solution: Place Default Arguments in Header File
      • NOTE : This video completes the coverage of material for Assignment 1 (cpp_basics).
    • 41:02—51:14: [basics] The constexpr Qualifier for Functions

1.2.3.3 Lecture 7: Wed May 21, 2025

  • Lecture 7 (2019-05-21) — Compile-Time Computation
    • 00:30—15:55: [basics] Constexpr Function Example: power_int (Iterative)
    • 15:55—21:01: [basics] Compile-Time Versus Run-Time Computation
    • 21:01—23:19: [classes] constexpr Member Functions
    • 23:19—24:49: [classes] constexpr Constructors
    • 24:49—31:51: [classes] Example: Constexpr Constructors and Member Functions
    • 31:51—37:27: [classes] Why Constexpr Member Functions Are Not Implicitly Const
    • 37:27—44:26: [classes] Literal Types
    • 44:26—46:48: [classes] Example: Literal Types
    • 46:48—48:49: [classes] Constexpr Variable Requirements

1.2.3.4 Lecture 8: Fri May 23, 2025

  • Lecture 8 (2019-05-22) — Compile-Time Computation, Temporary Objects
    • 00:00—02:03: [classes] Example: Constexpr Variable Requirement Violations
    • 02:03—06:22: [classes] Constexpr Function Requirements
    • 06:22—10:50: [classes] Example: Constexpr Function Requirement Violations
    • 10:50—12:42: [classes] Constexpr Constructor Requirements
    • 12:42—15:16: [classes] Example: Constexpr Constructor Requirement Violations
    • 15:16—18:15: [classes] Example: Constexpr and Accessing External State
    • 18:15—21:55: [classes] Example: Constexpr and Immediate Initialization
    • 21:55—28:50: [classes] Debugging Constexpr Functions
    • 28:50—30:55: [classes] Example: Debugging Strategies for Constexpr Functions
    • 30:55—???: [exercises] [Q.7] What is Wrong With This Code?
    • ???—33:25: [exercises] [Q.7] Solution: Define Constexpr Function in Header
    • 33:25—???: [exercises] [Q.8] What is Wrong With This Code?
    • ???—36:05: [exercises] [Q.8] Answer: Invalid Constexpr Function
    • 36:05—???: [exercises] [Q.9] What is Wrong With This Code?
    • ???—40:48: [exercises] [Q.9] Solution: Initialize Constexpr Function Variables
    • 40:48—???: [exercises] [Q.10] What is Wrong With This Code?
    • ???—42:16: [exercises] [Q.10] Solution: Constexpr Requires Literal Types
      • NOTE : This video completes the coverage of material for Assignment 2 (cpp_compile_time).
    • 42:16—49:28: [temporaries] Temporary Objects
  • NOTE : Assignment 1 (cpp_basics): Due approximately on the day of today's lecture. Consult the course website for the precise submission deadline.

1.2.4 Week 4: May 26—30, 2025

1.2.4.1 Lecture 9: Tue May 27, 2025

  • Lecture 9 (2019-05-24) — Temporary Objects, Moving/Copying, Value Categories
    • 00:00—02:51: [temporaries] Temporary Objects
    • 02:51—06:51: [temporaries] Temporary Objects (Continued)
    • 06:51—07:54: [temporaries] Temporary Objects Example
    • 07:54—09:06: [temporaries] Temporary Objects Example (Continued)
    • 09:06—18:24: [temporaries] Prefix Versus Postfix Increment/Decrement
    • 18:24—22:04: [rval_refs] Propagating Values: Copying and Moving
    • 22:04—23:50: [rval_refs] Copying and Moving
    • 23:50—25:09: [rval_refs] Buffer Example: Moving Versus Copying
    • 25:09—27:49: [rval_refs] Buffer Example: Copying
    • 27:49—30:55: [rval_refs] Buffer Example: Moving
    • 30:55—33:35: [rval_refs] Moving Versus Copying
    • 33:35—36:39: [lrvalues] Value Categories of Expressions
    • 36:39—40:36: [lrvalues] Value Categories of Expressions (Continued)
    • 40:36—43:39: [lrvalues] Lvalues
    • 43:39—48:29: [lrvalues] Lvalues (Continued 1)

1.2.4.2 Lecture 10: Wed May 28, 2025

  • Lecture 10 (2019-05-28) — Value Categories, Moving/Copying
    • 00:00—03:14: [lrvalues] Lvalues (Continued 2)
    • 03:14—07:17: [lrvalues] Moving and Lvalues
    • 07:17—11:33: [lrvalues] Rvalues
    • 11:33—14:11: [lrvalues] Prvalues
    • 14:11—19:38: [lrvalues] Prvalues (Continued)
    • 19:38—23:55: [lrvalues] Xvalues
    • 23:55—34:43: [lrvalues] Moving and Rvalues
    • 34:43—40:20: [lrvalues] Moving and Lvalues/Rvalues
    • 40:20—48:35: [lrvalues] Moving/Copying and Lvalues/Rvalues

1.2.4.3 Lecture 11: Fri May 30, 2025

  • Lecture 11 (2019-05-29) — Copy Elision
    • 00:00—00:36: [copy_elision] Copy Elision and Implicit Moving [title slide]
    • 00:36—06:55: [copy_elision] Copy Elision
    • 06:55—31:11: [copy_elision] Copy Elision and Returning by Value
    • 31:11—35:32: [copy_elision] Return-By-Value Example 1: Summary
    • 35:32—38:54: [copy_elision] Return-By-Value Example 2: Summary
    • 38:54—44:09: [copy_elision] Example Where Copy Elision Allowed But Likely Impossible
    • 44:09—48:30: [copy_elision] Copy Elision and Passing by Value

1.2.5 Week 5: Jun 02—06, 2025

1.2.5.1 Lecture 12: Tue Jun 03, 2025

  • Lecture 12 (2019-05-31) — Copy Elision, Implicit Move
    • 00:00—04:11: [copy_elision] Pass-By-Value Example: Summary
    • 04:11—21:27: [copy_elision] Copy Elision and Initialization
    • 21:27—25:02: [copy_elision] Mandatory Copy Elision Example: Factory Function
    • 25:02—36:36: [copy_elision] Return Statements and Moving/Copying
    • 36:36—40:38: [copy_elision] Example: Return Statements and Moving/Copying
    • 40:38—43:03: [copy_elision] Use of std::move in Return Statements
    • 43:03—50:31: [copy_elision] Example: Moving/Copying, Copy Elision, and Implicit Move a.k.a. [exercises] [Q.MC1] Copy, Move, or Copy Elision?

1.2.5.2 Lecture 13: Wed Jun 04, 2025

  • Lecture 13 (2019-06-04) — Copy Elision, Implicit Move, Exceptions
    • 00:00—09:44: [exericses] [Q.MC1] Answer
    • 09:44—10:49: [rval_refs] Allowing Move Semantics in Other Contexts via std::move
    • 10:49—12:20: [rval_refs] Old-Style Swap
    • 12:20—14:27: [rval_refs] Improved Swap
    • 14:27—17:34: [rval_refs] Implication of Rvalue-Reference Type Function Parameters
      • NOTE : This ends the coverage of material related to move semantics.
    • 17:34—18:52: [exceptions] Exceptions
    • 18:52—20:35: [exceptions] The Problem
    • 20:35—23:24: [exceptions] Traditional Error Handling
    • 23:24—25:09: [exceptions] Example: Traditional Error Handling
    • 25:09—27:55: [exceptions] Error Handling With Exceptions
    • 27:55—29:55: [exceptions] Example: Exceptions
    • 29:55—30:37: [exceptions] safe_divide Example: Traditional Error Handling
    • 30:37—31:29: [exceptions] safe_divide Example: Exceptions
    • 31:29—34:28: [exceptions] Exceptions Versus Traditional Error Handling
    • 34:28—36:58: [exceptions] Exceptions
    • 36:58—???: [exceptions] Standard Exception Classes
    • ???—???: [exceptions] Standard Exception Classes (Continued 1)
    • ???—37:42: [exceptions] Standard Exception Classes (Continued 2)
    • 37:42—38:39: [exceptions] Throwing Exceptions
    • 38:39—40:45: [exceptions] Throwing Exceptions (Continued)
    • 40:45—41:41: [exceptions] Catching Exceptions
    • 41:41—43:29: [exceptions] Catching Exceptions (Continued)
    • 43:29—44:23: [exceptions] Rethrowing Exceptions
    • 44:23—50:22: [exceptions] Transfer of Control from Throw Site to Handler
    • 50:22—52:24: [exceptions] Stack Unwinding Example

1.2.5.3 Lecture 14: Fri Jun 06, 2025

  • Lecture 14 (2019-06-05) — Exceptions
    • 00:00—08:38: [exceptions] Stack Unwinding Example
    • 08:38—09:49: [exceptions] Function Try Blocks
    • 09:49—14:06: [exceptions] Exceptions and Construction/Destruction
    • 14:06—18:09: [exceptions] Construction/Destruction Example
    • 18:09—24:53: [exceptions] Function Try Block Example
    • 24:53—29:13: [exceptions] The noexcept Specifier
    • 29:13—???: [exceptions] The noexcept Specifier (Continued 1)
    • ???—30:34: [exceptions] The noexcept Specifier (Continued 2)
    • 30:34—37:33: [exceptions] The noexcept Specifier (Continued 3)
    • 37:33—42:06: [exceptions] Exceptions and Function Calls
    • 42:06—47:00: [exceptions] Avoiding Exceptions Due to Function Calls
  • NOTE : Assignment 2 (cpp_compile_time): Due approximately on the day of today's lecture. Consult the course website for the precise submission deadline.

1.2.6 Week 6: Jun 09—13, 2025

1.2.6.1 Lecture 15: Tue Jun 10, 2025

  • Lecture 15 (2019-06-07) — Exceptions, Interval Arithmetic
    • 00:00—08:34: [exceptions] noexcept Operator
    • 08:34—17:00: [exceptions] noexcept Operator (Continued)
    • 17:00—21:21: [arithmetic] Interval Arithmetic
    • 21:21—24:11: [arithmetic] Applications of Interval Arithmetic
    • 24:11—26:22: [arithmetic] Real Interval Arithmetic
    • 26:22—27:54: [arithmetic] Addition and Subtraction
    • 27:54—28:46: [arithmetic] Multiplication and Division
    • 28:46—31:52: [arithmetic] Floating-Point Interval Arithmetic
    • 31:52—34:12: [arithmetic] Floating-Point Interval Arithmetic (Continued)
    • 34:12—35:35: [arithmetic] Floating-Point Interval Arithmetic Operations
    • 35:35—44:18: [arithmetic] Comparisons
    • 44:18—48:55: [arithmetic] Setting and Querying Rounding Mode

1.2.6.2 Lecture 16: Wed Jun 11, 2025

  • Lecture 16 (2019-06-11) — Interval Arithmetic, Geometric Predicates and Applications
    • 00:00—03:55: [arithmetic] Impact of Current Rounding Mode
    • 03:55—04:53: [arithmetic] Rounding Mode Example
    • 04:53—07:18: [arithmetic] Geometric Predicates
    • 07:18—11:44: [arithmetic] Filtered Geometric Predicates
    • 11:44—13:50: [arithmetic] Two-Dimensional Orientation Test
    • 13:50—14:16: [arithmetic] Example: Two-Dimensional Orientation Test
    • 14:16—17:08: [arithmetic] Convex Polygons
    • 17:08—20:42: [arithmetic] Polygon Convexity Test
    • 20:42—25:58: [arithmetic] Three-Dimensional Orientation Test
    • 25:58—28:37: [arithmetic] Side-of-Oriented-Circle Test
    • 28:37—30:32: [arithmetic] Preferred-Direction Test
    • 30:32—33:40: [arithmetic] Triangulations
    • 33:40—35:37: [arithmetic] Delaunay Triangulations
    • 35:37—???: [arithmetic] Nonuniqueness of Delaunay Triangulations
    • ???—39:37: [arithmetic] Comments on Delaunay Triangulations
    • 39:37—42:21: [arithmetic] Edge Flips
    • 42:21—45:49: [arithmetic] Locally-Delaunay Test
    • 45:49—46:41: [arithmetic] Locally Preferred-Directions Delaunay Test

1.2.6.3 Lecture 17: Fri Jun 13, 2025

  • Lecture 17 (2019-06-12) — Geometric Predicates and Applications, Memory Management

    • 00:00—08:08: [arithmetic] Locally Preferred-Directions Delaunay Test [plus related slides]
    • 08:08—11:32: [arithmetic] Lawson Local Optimization Procedure
    • 11:32—13:43: [arithmetic] Finding Delaunay Triangulations with Lawson LOP
    • 13:43—16:04: [data_structures] Naive Triangle-Mesh Data Structure
    • 16:04—20:11: [data_structures] Naive Triangle-Mesh Data Structure Example
    • 20:11—20:46: [data_structures] Half-Edge Data Structure
    • 20:46—30:05: [data_structures] Half-Edge Data Structure (Continued)
    • 30:05—30:40: [data_structures] Object File Format (OFF)

    • 30:40—34:01: [data_structures] OFF Example (Triangle Mesh)

    • 34:01—36:18: [memory_management] Memory Management

    • 36:18—38:42: [memory_management] Potential Problems Arising in Memory Management
    • 38:42—39:06: [memory_management] Alignment
    • 39:06—41:33: [memory_management] The alignof Operator

1.2.7 Week 7: Jun 16—20, 2025

1.2.7.1 Lecture 18: Tue Jun 17, 2025

  • Lecture 18 (2019-06-14) — Memory Management
    • 00:09—02:04: [memory_management] The alignas Specifier
    • 02:04—03:07: [memory_management] New Expressions
    • 03:07—05:49: [memory_management] New Expressions (Continued)
    • 05:49—07:22: [memory_management] Delete Expressions
    • 07:22—10:13: [memory_management] Delete Expressions (Continued 1)
    • 10:13—11:58: [memory_management] Delete Expressions (Continued 2)
    • 11:58—19:21: [memory_management] Typical Strategy for Determining Array Size in Array Delete
    • 19:21—22:54: [memory_management] New Expressions and Allocation
    • 22:54—26:11: [memory_management] Allocation Function Overload Resolution
    • 26:11—29:03: [memory_management] Allocation Function Overload Resolution (Continued)
    • 29:03—30:37: [memory_management] New Expressions and Deallocation
    • 30:37—31:04: [memory_management] Delete Expressions and Deallocation
    • 31:04—34:03: [memory_management] Single-Object Operator New (i.e., operator new)
    • 34:03—36:34: [memory_management] Single-Object Operator New Overloads
    • 36:34—37:28: [memory_management] Single-Object Operator New Overloads (Continued)
    • 37:28—41:56: [memory_management] Single-Object Operator New Examples

1.2.7.2 Lecture 19: Wed Jun 18, 2025

  • Lecture 19 (2019-06-18) — Memory Management
    • 00:00—01:50: [memory_management] Array Operator New (i.e., operator new[])
    • 01:50—02:57: [memory_management] Array Operator New Overloads
    • 02:57—03:31: [memory_management] Array Operator New Overloads (Continued)
    • 03:31—11:54: [memory_management] Array Operator New Examples
    • 11:54—13:44: [memory_management] Single-Object Operator Delete (i.e., operator delete)
    • 13:44—14:16: [memory_management] Single-Object Operator Delete Overloads
    • 14:16—20:57: [memory_management] Single-Object Operator Delete Examples
    • 20:57—21:36: [memory_management] Array Operator Delete (i.e., operator delete[])
    • 21:36—21:42: [memory_management] Array Operator Delete Overloads
    • 21:42—22:14: [memory_management] Array Operator Delete Examples
    • 22:14—???: [memory_management] Motivation for Placement New
    • ???—31:00: [memory_management] Motivation for Placement New: Diagram
    • 31:00—36:59: [memory_management] Placement New
    • 36:59—43:24: [memory_management] Placement New Examples
    • 43:24—46:15: [memory_management] Direct Destructor Invocation
    • 46:15—48:04: [memory_management] Pseudodestructors

1.2.7.3 Lecture 20: Fri Jun 20, 2025

  • Lecture 20 (2019-06-19) — Memory Management
    • 00:00—02:29: [memory_management] std::addressof Function Template
    • 02:29—04:25: [memory_management] std::addressof Example
    • 04:25—05:48: [memory_management] The std::aligned_storage Class Template
    • 05:48—07:17: [memory_management] Optional Value Example
    • 07:17—08:12: [memory_management] Optional Value Example: Diagram
    • 08:12—19:57: [memory_management] Optional Value Example: optval.hpp
    • 19:57—22:10: [memory_management] Optional Value Example: User Code
    • 22:10—22:55: [memory_management] Handling Uninitialized Storage
    • 22:55—26:37: [memory_management] Functions for Uninitialized Storage
    • 26:37—27:47: [memory_management] Functions for Uninitialized Storage (Continued)
    • 27:47—31:04: [memory_management] Some Example Implementations
    • 31:04—31:19: [memory_management] Bounded Array Example
    • 31:19—32:46: [memory_management] Bounded Array Example: Diagram
    • 32:46—34:44: [memory_management] Bounded Array Example: aligned_buffer.hpp
    • 34:44—39:00: [memory_management] Bounded Array Example: array.hpp (1)
    • 39:00—44:22: [memory_management] Bounded Array Example: array.hpp (2)
    • 44:22—48:40: [memory_management] Bounded Array Example: array.hpp (3)
    • 48:40—49:07: [memory_management] Bounded Array Example: array.hpp (4)

1.2.8 Week 8: Jun 23—27, 2025

1.2.8.1 Lecture 21: Tue Jun 24, 2025

  • Lecture 21 (2019-06-21) — Memory Management, Intrusive Containers, Pointers to Members
    • 00:00—01:48: [memory_management] Vector Example
    • 01:48—02:43: [memory_management] Vector Example: Diagram
    • 02:43—06:55: [memory_management] Vector Example: vec.hpp (1)
    • 06:55—12:48: [memory_management] Vector Example: vec.hpp (2)
    • 12:48—17:01: [memory_management] Vector Example: vec.hpp (3)
    • 17:01—20:49: [memory_management] Vector Example: vec.hpp (4)
    • 20:49—24:02: [memory_management] Vector Example: vec.hpp (5)
    • 24:02—27:38: [memory_management] Vector Example: vec.hpp (6)
    • 27:38—33:25: [data_structures] Intrusive Containers
    • 33:25—35:28: [data_structures] Shortcomings of Non-Intrusive Containers
    • 35:28—38:27: [data_structures] Advantages of Intrusive Containers
    • 38:27—42:40: [data_structures] Disadvantages of Intrusive Containers
    • 42:40—45:21: [data_structures] Disadvantages of Intrusive Containers (Continued)
    • 45:21—47:58: [classes] Pointers to Members
    • 47:58—49:10: [classes] Pointers to Members (Continued)

1.2.8.2 Lecture 22: Wed Jun 25, 2025

  • Lecture 22 (2019-06-25) — Pointers to Members, Intrusive Containers, Caches
    • 00:00—06:05: [classes] Pointers to Members for Data Members
    • 06:05—14:53: [classes] Pointers to Members Example: Accumulate
    • 14:53—???: [data_structures] Intrusive Doubly-Linked List With Sentinel Node
    • ???—???: [data_structures] Intrusive Doubly-Linked List With Sentinel Node: Code (Continued)
    • ???—???: [data_structures] Intrusive Doubly-Linked List With Sentinel Node: Code
    • ???—25:39: [data_structures] Intrusive Doubly-Linked List With Sentinel Node: Diagram
    • 25:39—25:52: [data_structures] Remarks on Intrusive Doubly-Linked List With Sentinel Node
    • 25:52—27:03: [data_structures] Examples of Intrusive Containers
      • NOTE : This video completes the coverage of material for Assignment 4 (cpp_containers).
    • 27:03—28:32: [cache] The Memory Latency Problem
    • 28:32—31:05: [cache] Principle of Locality
    • 31:05—32:48: [cache] Memory Hierarchy
    • 32:48—35:57: [cache] Caches
    • 35:57—37:38: [cache] Memory and Cache
    • 37:38—40:04: [cache] Block Placement
    • 40:04—42:35: [cache] Block Placement (Continued)
    • 42:35—43:31: [cache] Direct-Mapped Cache Example
    • 43:31—44:28: [cache] K-Way Set-Associative Cache Example
    • 44:28—45:03: [cache] Fully Associative Cache
    • 45:03—46:43: [cache] Block Identificiation
    • 46:43—48:53: [cache] Decomposition of Memory Address
    • 48:53—50:26: [cache] Block Replacement
    • 50:26—52:43: [cache] Write Policy
  • NOTE : Assignment 3 (cpp_arithmetic): Due approximately on the day of today's lecture. Consult the course website for the precise submission deadline.

1.2.8.3 Lecture 23: Fri Jun 27, 2025

  • Lecture 23 (2019-06-26) — Caches, Cache-Efficient Algorithms
    • 00:00—02:14: [cache] Cache Misses
    • 02:14—03:20: [cache] Virtual Memory
    • 03:20—05:38: [cache] Virtual Address Space
    • 05:38—07:21: [cache] Address Translation
    • 07:21—08:39: [supplemental] [Q.C2] Virtual Memory Exercise
    • 08:39—14:03: [supplemental] [Q.C2] Virtual Memory Exercise (Continued)
    • 14:03—15:59: [cache] Translation Lookaside Buffer (TLB)
    • 15:59—17:28: [cache] Virtual and Physical Caches
    • 17:28—19:37: [cache] Virtual Versus Physical Caches
    • 19:37—20:15: [cache] Virtually-Indexed Physically-Tagged (VIPT) Caches
    • 20:15—23:06: [cache] VIPT Cache Example
    • 23:06—23:50: [cache] Cache Performance
    • 23:50—24:42: [cache] Intel Core i7
    • 24:42—25:43: [cache] ARM Cortex A8
    • 25:43—26:56: [cache] Cache-Efficient Algorithms
    • 26:56—28:30: [cache] Code Transformations to Improve Cache Efficiency
    • 28:30—29:42: [data_structures] Row-Major Versus Column-Major Order
    • 29:42—31:50: [cache] Array Merging Example
    • 31:50—33:17: [cache] Loop Interchange Example
    • 33:17—35:25: [cache] Loop Fusion Example
    • 35:25—37:20: [cache] Blocking Example
    • 37:20—40:54: [cache] Blocking Example (Continued 0.5)
    • 40:54—42:11: [cache] Blocking Example (Continued 1)
    • 42:11—44:48: [cache] Blocking Example (Continued 2)
    • 44:48—47:24: [cache] Cache-Aware Versus Cache-Oblivious Algorithms
    • 47:24—50:24: [cache] Tall Caches

1.2.9 Week 9: Jun 30 — Jul 04, 2025

1.2.9.1 Reading Break: Mon Jun 30, 2025

1.2.9.2 Holiday: Tue Jul 01, 2025

1.2.9.3 Lecture 24: Wed Jul 02, 2025

  • Lecture 24 (2019-06-28) — Cache-Efficient Algorithms
    • 00:00—02:20: [cache] Idealized Cache Model
    • 02:20—03:45: [cache] Remarks on Assumption of Optimal-Replacement Policy
    • 03:45—04:32: [cache] Cache-Oblivious Algorithms
    • 04:32—09:44: [cache] Scanning
    • 09:44—14:48: [cache] Array Reversal
    • 14:48—16:29: [cache] Naive Matrix Transposition
    • 16:29—21:31: [cache] Naive Matrix Transposition: Performance
    • 21:31—22:50: [cache] Cache-Oblivious Matrix Transposition
    • 22:50—24:47: [cache] Cache-Oblivious Matrix Transposition (Continued)
    • 24:47—26:52: [cache] Cache-Oblivious Matrix Transposition Example 1A [Part 1]
    • 26:52—29:38: [handout] Transpose Algorithm Pseudocode
    • 29:38—30:57: [handout] Matrix Subblock Characterization
    • 30:57—32:48: [cache] Cache-Oblivious Matrix Transposition Example 1A [Part 2]
    • 32:48—34:47: [cache] Cache-Oblivious Matrix Transposition Example 2
    • 34:47—36:40: [cache] Cache-Oblivious Matrix Transposition: Performance
    • 36:40—39:07: [cache] Naive Matrix Multiplication
    • 39:07—44:45: [cache] Naive Matrix Multiplication: Performance

1.2.9.4 Lecture 25: Fri Jul 04, 2025

  • Lecture 25 (2019-07-03) — Cache-Efficient Algorithms, Concurrency
    • 00:00—02:16: [cache] Cache-Oblivious Matrix Multiplication
    • 02:16—05:55: [cache] Cache-Oblivious Matrix Multiplication (Continued 1)
    • 05:55—06:44: [cache] Cache-Oblivious Matrix Multiplication (Continued 2)
    • 06:44—13:02: [cache] Cache-Oblivious Matrix Multiplication Example 1
    • 13:02—15:14: [cache] Cache-Oblivious Matrix Multiplication: Performance
    • 15:14—17:52: [cache] Cache-Oblivious Matrix Multiplication Revisited
    • 17:52—20:48: [cache] Cache-Oblivious Matrix Multiplication Revisited Example 2
    • 20:48—24:03: [cache] Discrete Fourier Transform (DFT)
    • 24:03—29:41: [cache] Cache-Oblivious Fast Fourier Transform (FFT)
    • 29:41—32:15: [cache] Example: Four-Point DFT
    • 32:15—33:41: [cache] Example: Four-Point DFT (Continued 1)
    • 33:41—34:01: [cache] Example: Four-Point DFT (Continued 2)
    • 34:01—37:40: [cache] Cache-Oblivious FFT: Performance
      • NOTE : This video completes the coverage of material for Assignment 5 (cpp_cache).
    • 37:40—39:38: [concurrency] Processors
    • 39:38—41:29: [concurrency] Processors (Continued)
    • 41:29—44:35: [concurrency] Why Multicore Processors?
    • 44:35—46:39: [concurrency] Concurrency

1.2.10 Week 10: Jul 07—11, 2025

1.2.10.1 Lecture 26: Tue Jul 08, 2025

  • Lecture 26 (2019-07-05) — Concurrency
    • 00:00—03:51: [concurrency] Why Multithreading?
    • 03:51—06:47: [concurrency] Memory Model
    • 06:47—09:36: [concurrency] Sequential Consistency (SC)
    • 09:36—12:34: [concurrency] Sequential-Consistency (SC) Memory Model
    • 12:34—15:20: [concurrency] Load/Store Reordering Example: Single Thread
    • 15:20—20:00: [concurrency] Load/Store Reordering Example: Multiple Threads
    • 20:00—21:46: [concurrency] Atomicity of Memory Operations
    • 21:46—25:34: [concurrency] Data Races
    • 25:34—28:57: [concurrency] Torn Reads
    • 28:57—31:11: [concurrency] Torn Writes
    • 31:11—34:36: [concurrency] SC Data-Race Free (SC-DRF) Memory Model
    • 34:36—39:53: [concurrency] C++ Memory Model
    • 39:53—43:03: [concurrency] The std::thread Class
    • 43:03—47:06: [concurrency] The std::thread Class (Continued)

1.2.10.2 Lecture 27: Wed Jul 09, 2025

  • Lecture 27 (2019-07-09) — Concurrency
    • 00:00—01:49: [concurrency] std::thread Members
    • 01:49—03:06: [concurrency] std::thread Members (Continued)
    • 03:06—05:15: [concurrency] Example: Hello World With Threads [First Half]
    • 05:15—09:22: [lambdas] Hello World Program Revisited
    • 09:22—21:27: [lambdas] Linear-Function Functor Example
    • 21:27—23:00: [concurrency] Example: Hello World With Threads [Second Hal]
    • 23:00—25:23: [concurrency] Example: Thread-Function Argument Passing (Copy/Move Semantics)
    • 25:23—30:32: [concurrency] Example: Thread-Function Argument Passing (Reference Semantics)
    • 30:32—33:16: [concurrency] Example: Moving Threads
    • 33:16—36:38: [concurrency] Example: Lifetime Bug
    • 36:38—38:21: [concurrency] The std::thread Class and Exception Safety
    • 38:21—45:55: [concurrency] The std::thread Class and Exception Safety (Continued)
  • NOTE : Assignment 4 (cpp_containers): Due approximately on the day of today's lecture. Consult the course website for the precise submission deadline.

1.2.10.3 Lecture 28: Fri Jul 11, 2025

  • Lecture 28 (2019-07-10) — Concurrency
    • 00:00—03:12: [concurrency] Happens-Before Relationships
    • 03:12—09:02: [concurrency] "Earlier in Time" Versus Happens Before
    • 09:02—10:21: [concurrency] Sequenced-Before Relationships
    • 10:21—11:14: [concurrency] Sequenced-Before Relationships (Continued)
    • 11:14—12:37: [concurrency] Inter-Thread Happens-Before Relationships
    • 12:37—13:15: [concurrency] Summary of Happens-Before Relationships
    • 13:15—17:01: [concurrency] Synchronizes-With Relationships
    • 17:01—17:50: [concurrency] Examples of Synchronizes-With Relationships
    • 17:50—23:19: [concurrency] Synchronizes-With Relationship: Thread Create and Join
    • 23:19—24:50: [concurrency] Shared Data
    • 24:50—28:42: [concurrency] Race Conditions
    • 28:42—30:43: [concurrency] Critical Sections
    • 30:43—32:33: [concurrency] Data-Race Example
    • 32:33—34:46: [concurrency] Example: Data Race (Counter)
    • 34:46—43:18: [concurrency] Example: Data Race and/or Race Condition (IntSet)

1.2.11 Week 11: Jul 14—18, 2025

1.2.11.1 Lecture 29: Tue Jul 15, 2025

  • Lecture 29 (2019-07-12) — Concurrency
    • 00:00—03:10: [concurrency] Mutexes
    • 03:10—05:44: [concurrency] The std::mutex Class
    • 05:44—08:02: [concurrency] std::mutex Members
    • 08:02—11:00: [concurrency] Example: Avoiding Data Race Using Mutex (Counter) (mutex)
    • 11:00—18:57: [concurrency] Synchronizes-With Relationships: Mutex Lock/Unlock
    • 18:57—21:22: [concurrency] The std::scoped_lock Template Class
    • 21:22—22:14: [concurrency] std::scoped_lock Members
    • 22:14—24:22: [concurrency] Example: Avoiding Data Race Using Mutex (Counter) (scoped_lock)
    • 24:22—32:44: [concurrency] Example: Avoiding Data Race Using Mutex (IntSet) (scoped_lock)
    • 32:44—35:26: [concurrency] Acquisition of Multiple Locks
    • 35:26—38:56: [concurrency] Example: Acquiring Two Locks for Swap (Incorrect)
    • 38:56—39:20: [concurrency] Example: Acquiring Two Locks for Swap [scoped_lock]
    • 39:20—41:55: [concurrency] The std::unique_lock Template Class
    • 41:55—43:28: [concurrency] std::unique_lock Members
    • 43:28—43:55: [concurrency] std::unique_lock Members (Continued)
    • 43:55—47:20: [concurrency] Example: Avoiding Data Race Using Mutex (Counter) (unique_lock)

1.2.11.2 Lecture 30: Wed Jul 16, 2025

  • Lecture 30 (2019-07-16) — Concurrency
    • 00:00—01:01: [concurrency] The std::lock Template Function
    • 01:01—01:51: [concurrency] Example: Acquiring Two Locks for Swap [unique_lock and lock]
    • 01:51—03:16: [concurrency] Static Local Variable Initialization and Thread Safety
    • 03:16—07:40: [concurrency] Condition Variables
    • 07:40—13:26: [concurrency] The std::condition_variable Class
    • 13:26—14:30: [concurrency] std::condition_variable Members
    • 14:30—15:32: [concurrency] std::condition_variable Members (Continued)
    • 15:32—27:50: [concurrency] Example: Condition Variable (IntStack)
    • 27:50—29:56: [concurrency] Latches
    • 29:56—32:03: [concurrency] Latch Example: User Code
    • 32:03—37:15: [concurrency] Latch Example: latch_1.hpp
    • 37:15—38:44: [concurrency] The std::condition_variable_any Class
    • 38:44—42:07: [concurrency] Thread Pools
    • 42:07—44:37: [concurrency] Simple Thread Pool Interface Example

1.2.11.3 Lecture 31: Fri Jul 18, 2025

  • Lecture 31 (2019-07-17) — Concurrency, More Exceptions
    • 00:00—03:44: [concurrency] Simple Thread Pool Interface Example
      • NOTE : This video completes the coverage of material for Assignment 6 (cpp_concurrency).
    • 03:44—05:31: [exceptions] Resource Management
    • 05:31—07:17: [exceptions] Resource Leak Example
    • 07:17—08:43: [exceptions] Cleanup
    • 08:43—13:13: [exceptions] Exception Safety and Exception Guarantees
    • 13:13—20:24: [exceptions] Exception Guarantees
    • 20:24—21:43: [exceptions] Resource Acquisition Is Initialization (RAII)
    • 21:43—30:25: [exceptions] Resource Leak Example Revisited
    • 30:25—35:15: [exceptions] RAII Example: Stream Formatting Flags
    • 35:15—37:55: [exceptions] Other RAII Examples
    • 37:55—41:40: [exceptions] Appropriateness of Using Exceptions
    • 41:40—45:52: [exceptions] Enforcing Invariants: Exceptions Versus Assertions
  • NOTE : Assignment 5 (cpp_cache): Due approximately on the day of today's lecture. Consult the course website for the precise submission deadline.

1.2.12 Week 12: Jul 21—25, 2025

1.2.12.1 Lecture 32: Tue Jul 22, 2025

  • Lecture 32 (2019-07-19) — Smart Pointers
    • 00:00—02:36: [smart_ptrs] Memory Management, Ownership, and Raw Pointers
    • 02:36—05:15: [smart_ptrs] Smart Pointers
    • 05:15—08:27: [smart_ptrs] The std::unique_ptr Template Class
    • 08:27—10:37: [smart_ptrs] The std::unique_ptr Template Class (Continued)
    • 10:37—13:17: [handout] Move Operation for unique_ptr
    • 13:17—16:16: [handout] Why unique_ptr Is Not Copyable
    • 16:16—17:41: [smart_ptrs] std::unique_ptr Member Functions
    • 17:41—18:13: [smart_ptrs] std::unique_ptr Member Functions (Continued)
    • 18:13—21:48: [smart_ptrs] std::unique_ptr Example 1
    • 21:48—24:07: [smart_ptrs] Temporary Heap-Allocated Objects
    • 24:07—28:19: [smart_ptrs] Decoupled Has-A Relationship
    • 28:19—31:25: [smart_ptrs] The std::shared_ptr Template Class
    • 31:25—39:09: [smart_ptrs] The std::shared_ptr Template Class (Continued)
    • 39:09—???: [smart_ptrs] std::shared_ptr Reference Counting Example
    • ???—???: [smart_ptrs] std::shared_ptr Reference Counting Example (Continued 1)
    • ???—42:42: [smart_ptrs] std::shared_ptr Reference Counting Example (Continued 2)

1.2.12.2 Lecture 33: Wed Jul 23, 2025

  • Lecture 33 (2019-07-23) — Smart Pointers, Vectorization
    • 00:00—00:48: [smart_ptrs] std::shared_ptr Member Functions
    • 00:48—02:23: [smart_ptrs] std::shared_ptr Member Functions (Continued)
    • 02:23—04:08: [smart_ptrs] Prefer Use of std::make_shared
    • 04:08—12:31: [smart_ptrs] std::shared_ptr Example
    • 12:31—13:46: [smart_ptrs] std::shared_ptr and const
    • 13:46—15:17: [smart_ptrs] Factory Function
    • 15:17—18:04: [smart_ptrs] Example: Shared Pointer to Subobject of Managed Object
    • 18:04—20:51: [smart_ptrs] Example: Shared Pointer to Subobject of Managed Object (Continued 1)
    • 20:51—24:35: [smart_ptrs] Example: Shared Pointer to Subobject of Managed Object (Continued 2)
    • 24:35—25:17: [smart_ptrs] Example: Shared Pointer to Subobject of Managed Object (Continued 3)
    • 25:17—27:36: [smart_ptrs] Example: Shared Pointer to Subobject of Managed Object (Continued 4)
    • 27:36—30:00: [smart_ptrs] Example: std::shared_ptr
    • 30:00—32:58: [smart_ptrs] Example: std::shared_ptr (Continued)
    • 32:58—34:33: [vectorization] Vector Processing
    • 34:33—36:10: [vectorization] Scalar Versus Vector Instructions
    • 36:10—38:13: [vectorization] Vector-Memory and Vector-Register Architectures
    • 38:13—40:56: [vectorization] Vector-Register Architectures
    • 40:56—42:53: [vectorization] Vector Extensions
    • 42:53—44:18: [vectorization] Intel x86/x86-64 Streaming SIMD Extensions (SSE)
    • 44:18—46:09: [vectorization] Intel x86/x86-64 Advanced Vector Extensions (AVX)
    • 46:09—48:06: [vectorization] ARM NEON

1.2.12.3 Lecture 34: Fri Jul 25, 2025

  • Lecture 34 (2019-07-24) — Vectorization
    • 00:00—01:06: [vectorization] Checking for Processor Vector Support on Linux
    • 01:06—03:14: [vectorization] Vectorization
    • 03:14—06:56: [vectorization] Conceptualizing Loop Vectorization
    • 06:56—14:17: [vectorization] Approaches to Vectorization
    • 14:17—16:34: [vectorization] Auto-Vectorization
    • 16:34—17:36: [vectorization] GCC Compiler and Vectorization
    • 17:36—18:58: [vectorization] GCC Compiler Options Related to Vectorization
    • 18:58—21:09: [vectorization] GCC Compiler Options Related to Vectorization (Continued)
    • 21:09—21:39: [vectorization] Clang Compiler and Vectorization
    • 21:39—22:58: [vectorization] Clang Compiler Options Related to Vectorization
    • 22:58—24:48: [vectorization] Assessing Quality of Vectorized Code
    • 24:48—27:57: [vectorization] Assessing Quality of Vectorized Code (Continued)
    • 27:57—29:43: [vectorization] Auto-Vectorization with Hints
    • 29:43—34:04: [vectorization] Obstacles to Vectorization
    • 34:04—35:05: [vectorization] Data Dependencies and Vectorization
    • 35:05—37:38: [vectorization] Flow Dependencies
    • 37:38—40:34: [vectorization] Flow Dependence Example 1
    • 40:34—41:54: [vectorization] Flow Dependence Example 1: Sequential Loop
    • 41:54—44:38: [vectorization] Flow Dependence Example 1: Vectorized Loop
    • 44:38—46:55: [vectorization] Flow Dependence Example 2
    • 46:55—47:51: [vectorization] Output Dependencies

1.2.13 Week 13: Jul 28 — Aug 01, 2025

1.2.13.1 Lecture 35: Tue Jul 29, 2025

  • Lecture 35 (2019-07-26) — Vectorization
    • 00:00—02:07: [vectorization] Control-Flow Dependencies and Vectorization
    • 02:07—04:15: [vectorization] Aliasing
    • 04:15—06:18: [vectorization] Aliasing and Optimization: An Example
    • 06:18—12:29: [vectorization] Aliasing and Vectorization: An Example
    • 12:29—19:13: [vectorization] The restrict Keyword
    • 19:13—20:54: [vectorization] Noncontiguous Memory Accesses
    • 20:54—24:57: [vectorization] Data Alignment
    • 24:57—26:54: [vectorization] Handling Misaligned Data
    • 26:54—29:44: [handout] Example: Handling Misaligned Data
    • 29:44—32:07: [vectorization] Controlling Alignment of Data
    • 32:07—35:56: [vectorization] Informing Compiler of Data Alignment
    • 35:56—38:00: [vectorization] Profitability of Vectorization
    • 38:00—40:12: [vectorization] Vectorization Example: Version 1
    • 40:12—41:31: [vectorization] Vectorization Example: Version 2
    • 41:31—45:33: [vectorization] Vectorization Example: Version 3
    • 45:33—47:02: [vectorization] Vectorization Example: Invoking add Function
    • 47:02—49:29: [vectorization] Basic Requirements for Vectorizable Loops

1.2.13.2 Lecture 36: Wed Jul 30, 2025

  • Lecture 36 (2019-07-30) — Vectorization
    • 00:00—02:09: [vectorization] OpenMP SIMD Constructs
    • 02:09—05:28: [vectorization] OpenMP simd Pragma
    • 05:28—07:05: [vectorization] OpenMP declare simd Pragma
    • 07:05—08:29: [vectorization] OpenMP SIMD-Related Pragma Clauses
    • 08:29—08:50: [vectorization] OpenMP SIMD-Related Pragma Clauses (Continued)
    • 08:50—12:34: [vectorization] Example: Vectorized Loop
    • 12:34—14:39: [vectorization] Example: Vectorized Loop and Function
  • NOTE : Assignment 6 (cpp_concurrency): Due approximately on the day of today's lecture. Consult the course website for the precise submission deadline.

1.2.13.3 Lecture 37: Fri Aug 01, 2025

  • NOTE : No video viewing.