哈佛大学【中英⚡计算机科学导论(2026)|CS50x Introduction to Computer Science】

p0 Introduction to data structures

p1 Data Structures： List as abstract data type

p2 Introduction to linked list

p3 Data Structures： Arrays vs Linked Lists

p4 Linked List - Implementation in C⧸C++

p5 Linked List in C⧸C++ - Inserting a node at beginning

p6 Linked List in C⧸C++ - Insert a node at nth position

p7 Linked List in C⧸C++ - Delete a node at nth position

p8 Reverse a linked list - Iterative method

p9 Print elements of a linked list in forward and reverse order using recursion

p10 Reverse a linked list using recursion

p11 Data structures： Introduction to Doubly Linked List

p12 Doubly Linked List - Implementation in C⧸C++

p13 Data structures： Introduction to stack

p14 Data structures： Array implementation of stacks

p15 Data Structures： Linked List implementation of stacks

p16 Reverse a string or linked list using stack.

p17 Check for balanced parentheses using stack

p18 Infix, Prefix and Postfix

p19 Evaluation of Prefix and Postfix expressions using stack

p20 Infix to Postfix using stack

p21 Data structures： Introduction to Queues

p22 Data structures： Array implementation of Queue

p23 Data structures： Linked List implementation of Queue

p24 Data structures： Introduction to Trees

p25 Data structures： Binary Tree

p26 Data structures： Binary Search Tree

p27 Binary search tree - Implementation in C⧸C++

p28 BST implementation - memory allocation in stack and heap

p29 Find min and max element in a binary search tree

p30 Find height of a binary tree

p31 Binary tree traversal - breadth-first and depth-first strategies

p32 Binary tree： Level Order Traversal

p33 Binary tree traversal： Preorder, Inorder, Postorder

p34 Check if a binary tree is binary search tree or not

p35 Delete a node from Binary Search Tree

p36 Inorder Successor in a binary search tree

p37 Data structures： Introduction to graphs

p38 Data structures： Properties of Graphs

p39 Graph Representation part 01 - Edge List

p40 Graph Representation part 02 - Adjacency Matrix

p41 Graph Representation part 03 - Adjacency List

p0 1_Intro, Hello World Java

p1 2_Defining and Using Classes

p2 3_Testing

p3 4_References, Recursion, and Lists

p4 5_SLLists, Nested Classes, Sentinel Nodes

p5 6_DLLists, Arrays

p6 7_ALists, Resizing, vs. SLists

p7 8_Inheritance, Implements

p8 9_Extends, Casting, Higher Order Functions

p9 10_Subtype Polymorphism vs. HoFs

p10 11_Exceptions, Iterators, Object Methods

p11 12_Command Line Programming, Git, Project 2 Preview

p12 13_Asymptotics I

p13 14_Disjoint Sets

p14 15_Asymptotics II

p15 16_ADTs, Sets, Maps, BSTs

p16 17_B-Trees (2-3, 2-3-4 Trees)

p17 18_Red Black Trees

p18 19_Hashing

p19 20_Heaps and PQs

p20 21_Tree and Graph Traversals

p21 22_Graph Traversals and Implementations

p22 23_Shortest Paths

p23 24_Minimum Spanning Trees

p24 25_Range Searching and Multi-Dimensional Data

p25 26_Prefix Operations and Tries

p26 27_Software Engineering I

p27 28_Reductions and Decomposition

p28 29_Basic Sorts

p29 30_Quick Sort

p30 31_Software Engineering II

p31 32_More Quick Sort, Sorting Summary

p32 33_Software Engineering III

p33 34_Sorting and Algorithmic Bounds

p34 35_Radix Sorts

p35 36_Sorting and Data Structures Conclusion

p36 37_Software Engineering IV

p37 38_Compression

p38 39_Compression, Complexity, and P=NP

p39 40_Summary, Fun

p0 Lecture 1 Course Overview

p1 Lecture 2 Using Objects

p2 Lecture 3 Defining Classes

p3 Lecture 4 Types and Conditionals

p4 Lecture 5 Iteration and Arrays I

p5 Lecture 6 Iteration and Arrays II

p6 Lecture 7 Linked Lists I

p7 Lecture 8 Linked Lists II

p8 Lecture 9 Stack Frames

p9 Lecture 10 Testing

p10 Lecture 11 Inheritances

p11 Lecture 12 Abstract Classes

p12 Lecture 13 Java Packages

p13 Lecture 14 Exceptions

p14 Lecture 15 More Java

p15 Lecture 16 Game Trees

p16 Lecture 17 Encapsulation

p17 Lecture 18 Encapsulated Lists

p18 Lecture 19 Asymptotic Analysis

p19 Lecture 20 Algorithm Analysis

p20 Lecture 21 Hash Tables

p21 Lecture 22 Stacks and Queues

p22 Lecture 23 Trees and Traversals

p23 Lecture 24 Priority Queues

p24 Lecture 25 Binary Search Trees

p25 Lecture 26 Balanced Search Trees

p26 Lecture 27 Graphs

p27 Lecture 28 Weighted Graphs

p28 Lecture 29 Sorting I

p29 Lecture 30 Sorting II

p30 Lecture 31 Disjoint Sets

p31 Lecture 32 Sorting III

p32 Lecture 33 Sorting V

p33 Lecture 34 Splay Trees

p34 Lecture 35 Amortized Analysis

p35 Lecture 36 Randomized Analysis

p36 Lecture 37 Expression Parsing

p37 Lecture 38 Garbage Collection

p38 Lecture 39 Augmenting Data Structures

p0 A&DS S01E01. Algorithms. Time complexity. Merge sort.

p1 A&DS S01E02. Data structures. Binary Heap. Heap sort

p2 A&DS S01E03. Quick sort. Order statistics

p3 A&DS S01E04. Lower bounds for sorting. Radix sort. Sorting networks

p4 A&DS S01E05. Binary Search

p5 A&DS S01E06. Stacks. Queues. Amortized cost

p6 A&DS S01E07. Linked Lists. Pointer Machine

p7 A&DS S01E08. Disjoint Sets

p8 A&DS S01E09. Fibonacci Heap

p9 A&DS S01E10. Dynamic programming

p10 A&DS S01E11. Dynamic programming. Part 2

p11 A&DS S01E12. Knapsack Problem

p12 A&DS S01E13. DP on subsets, DP on profiles

p13 A&DS S01E14. Hash tables

p14 A&DS S01E15. Perfect hashing, cuckoo hashing, Bloom filter

p15 A&DS. Time Complexity of Union-Find (inverse Ackermann function)

p16 A&DS. Eval-Link-Update

p17 A&DS S02E01. Segment Tree

p18 A&DS S02E02. Segment Trees, Lazy Propagation

p19 A&DS S02E03. Fenwick Tree, Sparse Table

p20 A&DS S02E04. 2D Segment Tree Problems

p21 A&DS S02E05. Binary Search Tree, AVL tree

p22 A&DS S02E06. Treaps, implicit keys

p23 A&DS S02E07. Splay Tree

p24 A&DS S02E08. Scapegoat Tree, List Order Maintenance

p25 A&DS S02E09. Binary Lifting. LCA. Farach-Colton and Bender Algorithm

p26 A&DS S02E09. Heavy-Light Decomposition

p27 A&DS S02E11. Link-Cut Tree

p28 A&DS S02E12. Euler Tour Tree, Tarjan's Algorithm

p29 A&DS S02E13. Centroid Decomposition

p30 A&DS S02E14. External Memory Algorithms

p31 A&DS S02E15. Complexity Classes

p32 A&DS S03E01. Graphs. Depth First Search. Topological sorting

p33 A&DS S03E02. Strongly Connected Components, 2-SAT

p34 A&DS S03E03. Bridges, Articulation Points, Euler Cycle

p35 A&DS S03E04. Dominator Tree

p36 A&DS S03E05. Minimum Spanning Tree

p37 A&DS S03E06. Breadth-First Search, Dijkstra's Algorithm

p38 A&DS S03E07. Bellman-Ford and Floyd-Warshall Algorithms

p39 A&DS S03E08. Graph Games

p40 A&DS S03E09. Strings. Hashing. KMP. Z Algorithm

p41 A&DS S03E10. Finite State Automata

p42 A&DS S03E11. Aho Corasick Algorithm

p43 A&DS S03E12. Suffix Array

p44 A&DS S03E13. Suffix Tree. Ukkonen's Algorithm

p45 A&DS S03E14. Y-Fast Trie

p46 A&DS S03E15. Fusion Tree

p47 A&DS S04E01. Maximum Matchings in Bipartite Graphs

p48 A&DS S04E02. Maximum Matchings in Non-Bipartite Graphs

p49 A&DS S04E03. Flows, cuts. Ford-Fulkerson algorithm

p50 A&DS S04E04. Flows. Dinic's algorithm

p51 A&DS S04E05. Hopcroft-Karp algorithm, Push-Relabel

p52 A&DS S04E06. Assignment Problem. Hungarian Algorithm

p53 A&DS S04E07. Minimum Cost Flows

p54 A&DS S04E08. Global Minimum Cuts

p55 A&DS S04E09. Linear Programming

p56 A&DS S04E10. Number Theory Algorithms

p57 A&DS S04E11. Basic Cryptography Algorithms

p58 A&DS S04E12. Fast Fourier Transform

p59 A&DS S04E13. Approximation Algorithms

p60 A&DS S04E14. Parallel Algorithms

p0 08⧸25 Lecture 1

p1 08⧸30 Lecture 2

p2 09⧸01 Lecture 3

p3 09⧸06 Lecture 4

p4 09⧸08 Lecture 5

p5 09⧸13 Lecture 6

p6 09⧸15 Lecture 7

p7 09⧸20 Lecture 8

p8 09⧸22 Lecture 9

p9 09⧸27 Lecture 10

p10 09⧸29 Lecture 11

p11 10⧸06 Lecture 12

p12 10⧸11 Lecture 13

p13 10⧸13 Lecture 14

p14 10⧸18 Lecture 15

p15 10⧸20 Lecture 16

p16 10⧸25 Lecture 17

p17 10⧸27 Lecture 18

p18 11⧸03 Lecture 19

p19 11⧸08 Lecture 20

p20 11⧸10 Lecture 21

p21 11⧸15 Lecture 22

p22 11⧸17 Lecture 23

p23 11⧸22 Lecture 24

p24 11⧸29 Lecture 25

p25 12⧸01 Lecture 26

p0 [Intro Video 1] Welcome to 61B 2019

p1 [Intro Video 2] Course Logistics (Verbose Version)

p2 [Intro1, Video 2A] Hello World

p3 [Intro1, Video 2B] Static Typing

p4 [Intro1, Video 2C] Declaring Functions

p5 [Intro, Video 2D] Reflections on Java

p6 [Intro1, Video 3a] Compilation

p7 [Classes, Video 2a] Defining and Instantiating Classes

p8 [Classes, Video 2b] Defining and Instantianing Classes

p9 [Classes, Video 2c] Terminology

p10 [Classes, Video 2d] Arrays of Objects

p11 [Classes, Video 3a] Static vs Instance Methods

p12 [Classes, Video 3b] Exercise

p13 [Classes, Video 3c] Exercise Solution

p14 [Classes, Video 4] public static void main

p15 [Classes, Video 5] Using Libraries

p16 [Lists1, Video 1] The Mystery of the Walrus

p17 [Lists1, Video 2] Primitive Types

p18 [Lists1, Video 3] Reference Types

p19 [Lists1, Video 4] Parameter Passing

p20 [Lists1, Video 5] Test Your Understanding of the GRoE

p21 [Lists1, Video 6] Instantiating Arrays

p22 [Lists1, Video 7] Introducing IntLists

p23 [Lists1, Video 8] IntList size

p24 [Lists1, Video 9] IntList iterativeSize

p25 [Lists1, Video 10] More IntList Exercises

p26 [Lists2, Video 1A] Introducing the SLList

p27 [Lists2, Video 1B] Introducing the SLList Bureaucracy

p28 [Lists2, Video 1C] Introducing the SLList - SLList Methods

p29 [Lists2, Video 2] Access Control and Nested Classes

p30 [Lists2, Video 3] addLast and size

p31 [Lists2, Video 4] Caching

p32 [Lists2, Video 5] The Empty List

p33 [Lists2, Video 6] Sentinel Nodes

p34 [Lists2, Video 7] Invariants

p35 [Lists3, Video 1] Summary of SLLists So Far

p36 [Lists3, Video 2] Why a Last Pointer Isn't Enough

p37 [Lists3, Video 3] Doubly Linked Lists

p38 [Lists3, Video 4] Generic Lists

p39 [Lists3, Video 5] Array Overview

p40 [Lists3, Video 6] Basic Array Syntax

p41 [Lists3, Video 7] 2D Arrays

p42 [Lists4, Video 1] Why Array Lists

p43 [Lists4, Video 2] The Naive AList

p44 [Lists4, Video 3] The Allegory of the Cave

p45 [Lists4, Video 4] removeLast

p46 [Lists4, Video 5] Resizing Arrays

p47 [Lists4, Video 6] Resizing Implementation

p48 [Lists4, Video 7] Basic Resizing Analysis

p49 [Lists4, Video 8] Harder Resizing Analysis

p50 [Lists4, Video 9] Making AList Fast

p51 [Testing, Video 1] A New Way

p52 [Testing, Video 2] Ad Hoc Testing is Not Fun

p53 [Testing, Video 3] A Simple JUnit Test

p54 [Testing, Video 4] How Selection Sort Works

p55 [Testing, Video 5] Find Smallest and the Glory of Stack Overflow

p56 [Testing, Video 6] Swap

p57 [Testing, Video 7] Revising Find Smallest, Overview So Far

p58 [Testing, Video 8] Recursive Array Helper Methods

p59 [Testing, Video 9] Debugging and Testing, BFFs

p60 [Testing, Video 10] Reflections on the Process

p61 [Testing, Video 11] Better JUnit

p62 [Testing, Video 12] Testing Philosophy

p63 [Inheritance1, Video 1] The Desire for Generality

p64 [Inheritance1, Video 2] Hypernyms and Hyponyms

p65 [Inheritance1, Video 3] The Interface and Implements Keywords

p66 Inheritance1, Video 4 Overriding vs Overloading

p67 Inheritance1, Video 5 Interface Inheritance

p68 [Inheritance1, Video 6] Implementation Inheritance and Default Methods

p69 [Inheritance1, Video 7] Overriding Default Methods

p70 [Inheritance1, Video 8] Dynamic Method Selection

p71 [Inheritance1, Video 9] Dynamic Method Selection and Overloaded Methods

p72 [Inheritance1, Conclusion] Is a vs Has a, Interface vs Implementation Inheri

p73 [Inheritance2, Video 1] Basic Use of Extends

p74 [Inheritance2, Video 2] Extends with Overriding

p75 [Inheritance2, Video 3] A Boring Constructor Gotcha

p76 [Inheritance2, Video 4] The Object Class

p77 [Inheritance2, Video 5] Encapsulation

p78 [Inheritance2, Video 6] How Inheritance Breaks Encapsulation

p79 [Inheritance2, Video 7] Type Checking and Casting

p80 [Inheritance2, Video 8] Higher Order Functions in Java

p81 [Inheritance3, Video 0] Dynamic Method Selection Puzzle optional

p82 [Inheritance3, Video 1] Subtype Polymorphism

p83 [Inheritance3, Video 2] The Max Function

p84 [Inheritance3, Video 3] OurComparable Example

p85 [Inheritance3, Video 4] Compilation Quiz

p86 [Inheritance3, Video 5] Comparables

p87 [Inheritance3, Video 6] Comparator

p88 Part 1 Lists and Sets in Java

p89 Part 2 Basic Arrayset

p90 Part 3 - exceptions

p91 Part 4 Iterable

p92 Part 5 toString

p93 Part 6 equals

p94 Part 7 Summary

p95 Part 8 EXTRA fancier to String and the of static method

p96 [Asymptotics1, Video 1] Welcome to the Second Half of 61B

p97 [Asymptotics1, Video 2] Characterization 1 Clock Time

p98 [Asymptotics1, Video 3] Technique 2 Operation Counting

p99 [Asymptotics1, Video 4] Technique 2 Operation Counting Exercise

p100 [Asymptotics1, Video 5] Why Scaling Matters

p101 [Asymptotics1, Video 6] Worst Case Orders of Growth

p102 [Asymptotics1, Video 7] Simplified Analysis

p103 [Asymptotics1, Video 8] Big Theta

p104 [Asymptotics1, Video 9] Big O

p105 [Disjoint Sets, Video 1] - Intro to Disjoint Sets

p106 [Disjoint Sets, Video 2] - Quick Find

p107 [Disjoint Sets, Video 3] - Quick Union

p108 [Disjoint Sets, Video 4] - Weighted Quick Union

p109 [Disjoint Sets, Video 5] - Weighted Quick Union with Path Compression and S

p110 [Asymptotics2, Video 1] Simple Nested Loops in Big Theta

p111 [Asymptotics2, Video 3] There is No Magic Shortcut for these Problems

p112 [Asymptotics2, Video 4] Tree Recursion

p113 [Asymptotics2, Video 5] Binary Search Intuitive

p114 [Asymptotics2, Video 6] Binary Search Exact

p115 [Asymptotics2, Video 7] Merge Sort Prelude

p116 [Asymptotics2, Video 8] Merge Sort

p117 [Asymptotics2, Video 9] Summary

p118 [ADTs, Sets, Maps, BSTs, Video 1] - ADTs and Maps

p119 [ADTs, Sets, Maps, BSTs, Video 2] - Inventing the BST

p120 [ADTs, Sets, Maps, BSTs, Video 3] - BST Definitions

p121 [ADTs, Sets, Maps, BSTs, Video 4] - BST Search

p122 [ADTs, Sets, Maps, BSTs, Video 5] - BST Insert

p123 [ADTs, Sets, Maps, BSTs, Video 6] - BST Deletion

p124 [ADTs, Sets, Maps, BSTs, Video 7] - Sets vs Maps, Summary, Tips for Lab

p125 [ADTs, Sets, Maps, BSTs, Video 7] - Sets vs Maps, Summary, Tips for Lab

Part1 1-03_course-introduction

Part1 2-03_dynamic-connectivity

Part1 2-04_quick-find

Part1 2-05_quick-union

Part1 2-06_quick-union-improvements

Part1 2-07_union-find-applications

Part1 3-02_analysis-of-algorithms-introduction

Part1 3-03_observations

Part1 3-04_mathematical-models

Part1 3-05_order-of-growth-classifications

Part1 3-06_theory-of-algorithms

Part1 3-07_memory

Part1 4-03_stacks

Part1 4-04_resizing-arrays

Part1 4-05_queues

Part1 4-06_generics

Part1 4-07_iterators

Part1 4-08_stack-and-queue-applications-optional

Part1 5-02_sorting-introduction

Part1 5-03_selection-sort

Part1 5-04_insertion-sort

Part1 5-05_shellsort

Part1 5-06_shuffling

Part1 5-07_convex-hull

Part1 6-03_mergesort

Part1 6-04_bottom-up-mergesort

Part1 6-05_sorting-complexity

Part1 6-06_comparators

Part1 6-07_stability

Part1 7-02_quicksort

Part1 7-03_selection

Part1 7-04_duplicate-keys

Part1 7-05_system-sorts

Part1 8-03_apis-and-elementary-implementations

Part1 8-04_binary-heaps

Part1 8-05_heapsort

Part1 8-06_event-driven-simulation-optional

Part1 9-02_symbol-table-api

Part1 9-03_elementary-implementations

Part1 9-04_ordered-operations

Part1 9-05_binary-search-trees

Part1 9-06_ordered-operations-in-bsts

Part1 9-07_deletion-in-bsts

Part1 10-03_2-3-search-trees

Part1 10-04_red-black-bsts

Part1 10-05_b-trees-optional

Part1 11-02_1d-range-search

Part1 11-03_line-segment-intersection

Part1 11-04_kd-trees

Part1 11-05_interval-search-trees

Part1 11-06_rectangle-intersection

Part1 12-03_hash-tables

Part1 12-04_separate-chaining

Part1 12-05_linear-probing

Part1 12-06_hash-table-context

Part1 13-02_symbol-table-applications-sets-optional

Part1 13-03_symbol-table-applications-dictionary-clients-optional

Part1 13-04_symbol-table-applications-indexing-clients-optional

Part1 13-05_symbol-table-applications-sparse-vectors-optional

Part2 1-03_course-introduction

Part2 2-03_introduction-to-graphs

Part2 2-04_graph-api

Part2 2-05_depth-first-search

Part2 2-06_breadth-first-search

Part2 2-07_connected-components

Part2 2-08_graph-challenges

Part2 3-02_introduction-to-digraphs

Part2 3-03_digraph-api

Part2 3-04_digraph-search

Part2 3-05_topological-sort

Part2 3-06_strong-components

Part2 4-03_introduction-to-msts

Part2 4-04_greedy-algorithm

Part2 4-05_edge-weighted-graph-api

Part2 4-06_kruskals-algorithm

Part2 4-07_prims-algorithm

Part2 4-08_mst-context

Part2 5-02_shortest-paths-apis

Part2 5-03_shortest-path-properties

Part2 5-04_dijkstras-algorithm

Part2 5-05_edge-weighted-dags

Part2 5-06_negative-weights

Part2 6-03_introduction-to-maxflow

Part2 6-04_ford-fulkerson-algorithm

Part2 6-05_maxflow-mincut-theorem

Part2 6-06_running-time-analysis

Part2 6-07_java-implementation

Part2 6-08_maxflow-applications

Part2 7-02_strings-in-java

Part2 7-03_key-indexed-counting

Part2 7-04_lsd-radix-sort

Part2 7-05_msd-radix-sort

Part2 7-06_3-way-radix-quicksort

Part2 7-07_suffix-arrays

Part2 8-03_r-way-tries

Part2 8-04_ternary-search-tries

Part2 8-05_character-based-operations

Part2 9-02_introduction-to-substring-search

Part2 9-03_brute-force-substring-search

Part2 9-04_knuth-morris-pratt

Part2 9-05_boyer-moore

Part2 9-06_rabin-karp

Part2 10-03_regular-expressions

Part2 10-04_res-and-nfas

Part2 10-05_nfa-simulation

Part2 10-06_nfa-construction

Part2 10-07_regular-expression-applications

Part2 11-02_introduction-to-data-compression

Part2 11-03_run-length-coding

Part2 11-04_huffman-compression

Part2 11-05_lzw-compression

Part2 12-03_introduction-to-reductions

Part2 12-04_designing-algorithms

Part2 12-05_establishing-lower-bounds

Part2 12-06_classifying-problems

Part2 13-02_brewers-problem

Part2 13-03_simplex-algorithm

Part2 13-04_simplex-implementations

Part2 13-05_linear-programming-reductions

Part2 14-02_introduction-to-intractability

Part2 14-03_search-problems

Part2 14-04_p-vs-np

Part2 14-05_classifying-problems

Part2 14-06_np-completeness

Part2 14-07_coping-with-intractability

Problem Session 1

Problem Session 2

Problem Session 3

Problem Session 4

Quiz 1 review

Problem Session 5

Problem Session 7

Quiz 2 Review

Problem Session 8

Problem Session 9

Quiz 3 Review

1. Algorithms and Computation

2. Data Structures and Dynamic Arrays

3. Sets and Sorting

4. Hashing

5. Linear Sorting

6. Binary Trees, Part 1

7. Binary Trees, Part 2： AVL

8. Binary Heaps

9. Breadth-First Search

10. Depth-First Search

11. Weighted Shortest Paths

12. Bellman-Ford

13. Dijkstra

14. APSP and Johnson

15. Dynamic Programming, Part 1： SRTBOT, Fib, DAGs, Bowling

16. Dynamic Programming, Part 2： LCS, LIS, Coins

17. Dynamic Programming, Part 3： APSP, Parens, Piano

18. Dynamic Programming, Part 4： Rods, Subset Sum, Pseudopolynomial

19. Complexity

20. Course Review

21. Algorithms—Next Steps

p0 Lecture 1： Intro, Number Representation

p1 Lecture 2： C Intro

p2 Lecture 3： C Arrays, Pointers, Strings

p3 Lecture 4： C Memory Management, Usage

p4 Lecture 5： Floating Point

p5 Lecture 6： Assembly, RISC-V Intro

p6 Lecture 7： RISC-V, RISC-V Functions

p7 Lecture 8： RISC-V Instruction Formats

p8 Lecture 9： Compiler, Assembler, Linker, Loader(CALL)

p9 Lecture 10： Synchronous Digital Systems(SDS)

p10 Lecture 11： Functional Units, FSMs

p11 Lecture 12： RISC-V Datapath, Single-Cycle Control Into

p12 Lecture 13： RISC-V Single-Cycle Control

p13 Lecture 14： RISC-V 5-Stage Pipeline⧸Hazards

p14 Lecture 15： Memory Hierarchy, Fully Associative Caches

p15 Lecture 16： Direct-Mapped & Set-Associative Caches, Cache Performance

p16 Lecture 17： Multi-Level Caches, Cache Questions

p17 Lecture 18： Operating Systems

p18 Lecture 19： Virtual Memory

p19 Lecture 20： I⧸O

p20 Lecture 21： Flynn's Taxonomy, Data-Level Parallelism

p21 Lecture 22： Amdahl's Law, Thread-Level Parallelism, OpenMP Introduction

p22 Lecture 23： Cache Coherence, OpenMP Sharing Issues, Performance

p23 Lecture 24： Dependability, Parity, ECC, RAID

p24 Lecture 25： Warehouse-Scale Computing

p25 Lecture 27： Summary, What's Next？

p0 Lecture 1： Intro

p1 Lecture 2： Number Representation

p2 Lecture 3 C Intro - Basics

p3 Discussion 1： Number Representation

p4 Lecture 4： C Intro - Pointers, Arrays,Strings

p5 Lecture 5： Memory(Mis)Management

p6 Discussion 2： C

p7 Lecture 6： Floating Point

p8 Lecture 7： Intro to Assembly Language RISC-V

p9 Lecture 8： RISC-V DataTransfer

p10 Discussion 3： Floating Point

p11 Lecture 9： RISC-V Decision Making Logic Ops

p12 Lecture 10： RISC-V Procedures

p13 Lecture 11： RISC-V Instruction Formats I

p14 Discussion 4： RISC-V Intro, Control Flow

p15 Lecture 12： RISC-V Instruction Formats II

p16 Lecture 13： Compiler,Assembler,Linker,Loader

p17 Lecture 14 Intro to Synchronous Digital Systems

p18 Discussion 5： RISC-V Procedures, ISA, CALL

p19 Lecture 15 Combinational Logic

p20 Lecture 16 SDS State,FSMs

p21 Lecture 17： Combinational Logic Blocks

p22 Discussion 6： SDS, Logic FSM

p23 Lecture 18： RISC-V Single Cycle Datapath I

p24 Lecture 19： RISC-V Single Cycle Datapath II

p25 Lecture 20： RISC-V Single-Cycle Control

p26 Discussion 7： Single-Cycle Datapath

p27 Lecture 21： RISC-V 5-Stage Pipeline I

p28 Lecture 22： RISC-V 5-Stage Pipeline II,Hazards

p29 Lecture 23： RISC-V 5-Stage Pipeline III,Hazards

p30 Discussion 8： Pipelining, Hazards

p31 Lecture 24： Caches - Direct Mapped I

p32 Lecture 25： Caches-Direct Mapped II

p33 Lecture 26： Caches - MultiLevel

p34 Discussion 9： Caches

p35 Lecture27： Caches - Set - associative,Performance with Caches

p36 Lecture 28： Flynn Taxonomy, SIMD

p37 Lecture 29： Parallelism I： Thread-leve Parallelism

p38 Discussion 10： Multi-Level Caches, AMAT

p39 Lecture 30： Parallelism II： OpenMP,Sharing lssues

p40 Lecture 31： Parallelism III： Cache Conherence, Performance

p41 Lecture 32： VM I： Intro

p42 Discussion 11： Parallelism, Coherency, and Atomic

p43 Lecture 33： VM II： Page Faults,Multileve,Interrupts⧸Exceptions

p44 Lecture 34： VM III： TLB

p45 Lecture 35： VM Performance, I⧸O

p46 Lecture 36： MapReduce, Spark, Amdahl's Law,Date-level Parallelism

p47 Lecture 37： Dependability,Parity,ECC,RAID

p48 Lecture 38： Data centers,Warehouse Scale computing

p49 Lecture 39： Guest Lecture with James Percy from Apple

p50 Lecture 40： Summary, What's Next？

p0 Digital Design and Computer Architecture - Lecture 1： Introduction and Basics

p1 Digital Design & Comp Arch - Lecture 2： Tradeoffs, Metrics & Combinational Lo

p2 Digital Design & Comp Arch - Lecture 3： Combinational Logic II (Spring 2023)

p3 Digital Design & Comp Arch - Lecture 4： Sequential Logic Design

p4 Digital Design & Computer Architecture - Labs： Introduction to the Labs and F

p5 Digital Design & Comp Arch - Lecture 5： Sequential Logic Design II & Hardware

p6 Digital Design & Comp Arch - Lecture 6： Timing and Verification

p7 Digital Design & Comp Arch - Lecture 6c： Verification & Testing (Spring 2023)

p8 Digital Design & Comp Arch - Lecture 7： Von Neumann Model & Instruction Set A

p9 Digital Design & Comp Arch - Lecture 8： Instruction Set Architectures II

p10 Digital Design & Comp Arch - Lecture 9： ISA and Microarchitecture (Tradeoffs

p11 Digital Design & Comp Arch - Lecture 9b： Assembly Programming (Spring 2023)

p12 Digital Design & Comp Arch - Lecture 10： Microarchitecture Fundamentals and

p13 Digital Design & Comp Arch - Lecture 11： Multi-Cycle Microarchitecture Desig

p14 Digital Design & Comp Arch - Lecture 12： Pipelining (Spring 2023)

p15 Digital Design & Comp Arch - Lec. 13： Pipelined Processor Design： Data & Con

p16 Digital Design and Comp Arch - Lecture 14： Precise Exceptions & Register Ren

p17 Digital Design and Computer Architecture - Lecture 15： Out-of-Order Executio

p18 Digital Design & Comp. Arch - Lecture 15b： Load-Store Handling in Out-of-Ord

p19 Digital Design and Comp. Arch. - Lecture 16： Superscalar Execution & Branch

p20 Digital Design and Computer Architecture - Lecture 17： Advanced Branch Predi

p21 Digital Design and Comp. Arch. - Lecture 18： VLIW and Systolic Array Archite

p22 Digital Design & Computer Architecture - Lecture 18c： Decoupled Access-Execu

p23 Digital Design and Comp. Arch. - Lecture 19： SIMD Architectures (Vector and

p24 Digital Design and Comp. Arch. - Lecture 20： GPU Architectures (Graphics Pro

p25 Digital Design and Comp. Arch. - Lecture 21： Memory Organization & Technolog

p26 Digital Design and Computer Architecture - Lecture 22： Memory Hierarchy and

p27 Digital Design and Computer Architecture - Lecture 23： Cache Design and Mana

p28 Digital Design and Computer Architecture - Lecture 24： Prefetching (Spring 2

p29 Digital Design and Comp. Arch. - Lecture 25： Advanced Prefetching & Virtual

p30 Digital Design & Computer Arch - Lecture 26： Virtual Memory & Future Computi

p31 Digital Design & Computer Arch. - Lecture 26c： Virtual Memory： Issues and Ex

p32 Digital Design & Computer Architecture - Problem Solving I (Spring 2023)

p33 Digital Design & Computer Architecture - Problem Solving II (Spring 2023)

p34 Digital Design & Computer Architecture - Problem Solving III (Spring 2023)

p35 Digital Design & Computer Architecture - Problem Solving IV (Spring 2023)

p36 Digital Design and Comp. Arch. - Lecture 31： Problem Solving V (Spring 2023)

p37 Digital Design & Computer Architecture - Preparing for the Final Exam (Sprin

p0 Weekly Lecture 01.LIVE - Great Ideas in Computer Architecture, Intro

p1 Lecture 02.1 - Number Representation： Intro, Bits can be anything

p2 Lecture 02.2 - Number Representation： Conversions

p3 Lecture 02.3 - Number Representation： Overflow, Sign and Magnitude, One's Com

p4 Lecture 02.4 - Number Representation： Two's Complement, Bias, and Summary

p5 Lecture 03.1 - C Intro： Basics： Intro and Background

p6 Lecture 03.2 - C Intro： Basics： Compile v. Interpret

p7 Lecture 03.3 - C Intro： C v. Java and C Syntax

p8 Lecture 03.4 - C Intro： Basics： C Syntax

p9 Lecture 04.1 - C Intro： Pointers, Arrays, Strings： Pointers and Bugs

p10 Lecture 04.2 - C Intro： Pointers, Arrays, Strings： Using Pointers Effectivel

p11 Lecture 04.3 - C Intro： Pointers, Arrays, Strings： Arrays

p12 Lecture 04.4 - C Intro： Pointers, Arrays, Strings： Function Pointer Example

p13 Lecture 05.1 - C Memory Management： Dynamic Memory Allocation

p14 Binky Pointer Fun Video C (High Quality 640x560)

p15 Lecture 05.2 - C Memory Management： Linked List Example

p16 Lecture 05.3 - C Memory Management： Memory Locations

p17 Lecture 05.4 - C Memory Management： Memory Management

p18 Lecture 05.5 - C Memory Management： When Memory Goes Bad

p19 Weekly Lecture 03.LIVE - Floating Point & RISC-V

p20 [CS61C FA20] Lecture 06.1 - Floating Point： Basics & Fixed Point

p20 Lecture 06.1 - Floating Point： Basics & Fixed Point

p21 Lecture 06.2 - Floating Point： Floating Point

p22 Lecture 06.3 - Floating Point： Special Numbers

p23 Lecture 06.4 - Floating Point： Examples, Discussion

p24 Lecture 06.5 - Floating Point： Floating Point Discussion

p25 Lecture 06.6 - Floating Point： Other Floating Point Representations

p26 Lecture 07.1 - RISC-V Intro： RISC-V Assembly Language

p27 Lecture 07.2 - RISC-V Intro： Elements of Architecture： Registers

p28 Lecture 07.3 - RISC-V Intro： RISC-V add⧸sub Instructions

p29 Lecture 07.4 - RISC-V Intro： RISC-V Immediates

p30 Weekly Lecture 04.LIVE - RISC-V

p31 Lecture 08.1 - RISC-V lw, sw, Decisions I： Storing in Memory

p32 Lecture 08.2 - RISC-V lw, sw, Decisions I： Data Transfer Instructions

p33 Lecture 08.3 - RISC-V lw, sw, Decisions I： Decision Making

p34 Lecture 09.1 - RISC-V Decisions II： Logical Instructions

p35 Lecture 09.2 - RISC-V Decisions II： A Bit About Machine Program

p36 Lecture 09.3 - RISC-V Decisions II： RISC-V Function Calls

p37 Lecture 10.1 - RISC-V Procedures： Function Call Example

p38 Lecture 10.2 - RISC-V Procedures： Register Conventions

p39 Lecture 10.3 - RISC-V Procedures： Memory Allocation

p40 Lecture 10.4 - RISC-V Procedures： Summary

p41 Weekly Lecture 05.LIVE - RISC-V & CALL

p42 Lecture 11.1 - RISC-V Instruction Formats I： Intro

p43 Lecture 11.2 - RISC-V Instruction Formats I： R-Format Layout

p44 Lecture 11.3 - RISC-V Instruction Formats I： I-Format Layout

p45 Lecture 11.4 - RISC-V Instruction Formats I： Loads

p46 Lecture 11.5 - RISC-V Instruction Formats I： S-Format

p47 Lecture 12.1 - RISC-V Instruction Formats II： B-Format

p48 Lecture 12.2 - RISC-V Instruction Formats II： Upper Immediates

p49 Lecture 12.3 - RISC-V Instruction Formats II： J-Format

p50 Lecture 12.4 - RISC-V Instruction Formats II： Summary

p51 Lecture 13.1 - Compilation, Assembly, Linking, Loading： Interpretation vs Tr

p52 Lecture 13.2 - Compilation, Assembly, Linking, Loading： Compiler

p53 Lecture 13.3 - Compilation, Assembly, Linking, Loading： Assembler

p54 Lecture 13.4 - Compilation, Assembly, Linking, Loading： Linker

p55 Lecture 13.5 - Compilation, Assembly, Linking, Loading： Loader

p56 Lecture 13.6 - Compilation, Assembly, Linking, Loading： Example

p57 Weekly Lecture 06.LIVE - SDS & CL

p58 Lecture 14.1 - Intro to Synchronous Digital Systems： Switches

p59 Lecture 14.2 - Intro to Synchronous Digital Systems： Transistors

p60 Lecture 14.3 - Intro to Synchronous Digital Systems： Signals and Waveforms

p61 Lecture 15.1 - State, State Machines： Accumulator

p62 Lecture 15.2 - State, State Machines： Register Details Flip-flops

p63 Lecture 15.3 - State, State Machines： Accumulator revisited

p64 Lecture 15.4 - State, State Machines： Pipelining for Performance

p65 Lecture 15.5 - State, State Machines： Finite State Machines

p66 Lecture 16.1 - Combinational Logic： Truth Tables

p67 Lecture 16.2 - Combinational Logic： Logic Gates

p68 Lecture 16.3 - Combinational Logic： Boolean Algebra

p69 Lecture 16.4 - Combinational Logic： Laws of Boolean Algebra

p70 Lecture 16.5 - Combinational Logic： Canonical Forms

p71 Weekly Lecture 07.LIVE - RISC-V Datapath

p72 Lecture 17.1 - Combinational Logic Blocks： Data Multiplexors

p73 Lecture 17.2 - Combinational Logic Blocks： ALU

p74 Lecture 17.3 - Combinational Logic Blocks： Adder⧸Subtractor

p75 Lecture 17.4 - Combinational Logic Blocks： Subtractor Design

p76 Lecture 18.1 - Single-Cycle CPU Datapath I： RISC-V Processor Design

p77 Lecture 18.2 - Single-Cycle CPU Datapath I： Building a RISC-V Processor

p78 Lecture 18.3 - Single-Cycle CPU Datapath I： R-Type Add Datapath

p79 Lecture 18.4 - Single-Cycle CPU Datapath I： Sub Datapath

p80 Lecture 18.5 - Single-Cycle CPU Datapath I： Datapath with Immediates

p81 Lecture 19.1 - Single-Cycle CPU Datapath II： Supporting Loads

p82 Lecture 19.2 - Single-Cycle CPU Datapath II： Datapath for Stores

p83 Lecture 19.3 - Single-Cycle CPU Datapath II： Implementing Branches

p84 Lecture 19.4 - Single-Cycle CPU Datapath II： Adding JALR to Datapath

p85 Lecture 19.5 - Single-Cycle CPU Datapath II： Adding JAL

p86 Lecture 19.6 - Single-Cycle CPU Datapath II： Adding U-Types

p87 Lecture 19.7 - Single-Cycle CPU Datapath II： Summary

p88 Weekly Lecture 08.LIVE - RISC-V Datapath

p89 Lecture 20.1 - Single-Cycle CPU Control： Control and Status Registers

p90 Lecture 20.2 - Single-Cycle CPU Control： Datapath Control

p91 Lecture 20.3 - Single-Cycle CPU Control： Instruction Timing

p92 Lecture 20.4 - Single-Cycle CPU Control： Control Logic Design

p93 Lecture 20.5 - Single-Cycle CPU Control： Summary

p94 Lecture 21.1 - Pipelining I： Pipelining

p95 Lecture 21.2 - Pipelining I： Processor Performance Iron Law

p96 Lecture 21.3 - Pipelining I： Energy Efficiency

p97 Lecture 21.4 - Pipelining I： Introduction to Pipelining

p98 Lecture 22.1 - Pipelining II： Pipelining RISC-V

p99 Lecture 22.2 - Pipelining II： Pipeline Hazards

p100 Lecture 22.3 - Pipelining II： Pipelining Datapath

p101 Lecture 22.4 - Pipelining II： Data Hazards

p102 Weekly Lecture 09.LIVE - Cache

p103 Lecture 23.1 - Pipelining III： Load Data Hazard

p104 Lecture 23.2 - Pipelining III： Control Hazards

p105 Lecture 23.3 - Pipelining III： Superscalar

p106 Lecture 24.1 - Caches I： Binary Prefix

p107 Lecture 24.2 - Caches I： Library Analogy

p108 Lecture 24.3 - Caches I： Memory Hierarchy

p109 Lecture 24.4 - Caches I： Locality, Design, Management

p110 Lecture 25.1 - Caches II： Direct Mapped Caches

p111 Lecture 25.2 - Caches II： Direct Mapped Example

p112 Lecture 25.3 - Caches II： Cache Terminology

p113 Weekly Lecture 10.LIVE - Cache

p114 Lecture 26.1 - Caches III： Direct Mapped Example

p115 Lecture 26.2 - Caches III： Writes, Block Sizes, Misses

p116 Lecture 26.3 - Caches III： Fully Associative Caches

p117 Lecture 26.3 - Caches III： Fully Associative Caches

p118 Lecture 27.1 - Caches IV： Set-Associative Caches

p119 Lecture 27.2 - Caches IV： Block Replacement with Example

p120 Lecture 27.3 - Caches IV： Average Memory Access Time (AMAT)

p121 Lecture 27.4 - Caches IV： Actual CPUs

p122 Lecture 28.1 - OS & Virtual Memory Intro： Intro

p123 Lecture 28.2 - OS & Virtual Memory Intro： Operating System Basics

p124 Lecture 28.3 - OS & Virtual Memory Intro： Operating System Functions

p125 Weekly Lecture 11.LIVE - OS, VM, & I⧸O

p126 Lecture 29.1 - Virtual Memory I： Virtual Memory Concepts

p127 Lecture 29.2 - Virtual Memory I： Physical Memory and Storage

p128 Lecture 29.3 - Virtual Memory I： Memory Manager

p129 Lecture 29.4 - Virtual Memory I： Paged Memory

p130 Lecture 29.5 - Virtual Memory I： Page Faults

p131 Lecture 30.1 - Virtual Memory II： Hierarchical Page Tables

p132 Lecture 30.2 - Virtual Memory II： Translation Lookaside Buffers (TLB)

p133 Lecture 30.3 - Virtual Memory II： TLBs in Datapath

p134 Lecture 30.4 - Virtual Memory II： VM Performance

p135 Lecture 31.1 - I⧸O： I⧸O Devices

p136 Lecture 31.2 - I⧸O： I⧸O Polling

p137 Lecture 31.3 - I⧸O： I⧸O Interrupts

p138 Lecture 31.4 - I⧸O： DMA

p139 Lecture 31.5 - I⧸O： Networking

p140 Weekly Lecture 12.LIVE - SIMD

p141 Lecture 32.1 - Flynn Taxonomy, SIMD Instructions： Parallelism

p142 Lecture 32.2 - Flynn Taxonomy, SIMD Instructions： Matrix Multiplication

p143 Lecture 32.3 - Flynn Taxonomy, SIMD Instructions： Flynn's Taxonomy

p144 Lecture 32.4 - Flynn Taxonomy, SIMD Instructions： SIMD Architectures

p145 Lecture 32.5 - Flynn Taxonomy, SIMD Instructions： SIMD Array Processing

p146 Lecture 32.6 - Flynn Taxonomy, SIMD Instructions： Matrix Multiply Example

p147 Lecture 33.1 - Thread-Level Parallelism I： Parallel Computer Architectures

p148 Lecture 33.2 - Thread-Level Parallelism I： Multicore

p149 Lecture 33.3 - Thread-Level Parallelism I： Threads

p150 Lecture 33.4 - Thread-Level Parallelism I： Multithreading

p151 Weekly Lecture 13.LIVE - TLP

p152 Lecture 34.1 - Thread-Level Parallelism II： Parallel Programming Languages

p153 Lecture 34.2 - Thread-Level Parallelism II： OpenMP

p154 Lecture 34.3 - Thread-Level Parallelism II： Computing Pi

p155 Lecture 34.4 - Thread-Level Parallelism II： Synchronization

p156 Lecture 35.1 - Thread-Level Parallelism III： Hardware Synchronization

p157 Lecture 35.2 - Thread-Level Parallelism III： Shared Memory and Caches

p158 Lecture 35.3 - Thread-Level Parallelism III： Cache Coherency

p159 Lecture 36.1 - MapReduce, Spark： Amdahl's Law

p160 Lecture 36.2 - MapReduce, Spark： Request-Level and Data-Level Parallelism

p161 Lecture 36.3 - MapReduce, Spark： MapReduce

p162 Lecture 36.4 - MapReduce, Spark： Spark

p163 Weekly Lecture 14.LIVE - WSC

p164 Lecture 37.1 - Data Centers, Cloud Computing (WSC)： Eras of Computing Hardw

p165 Lecture 37.2 - Data Centers, Cloud Computing (WSC)： Warehouse Scale Compute

p166 Lecture 37.3 - Data Centers, Cloud Computing (WSC)： Power Usage Effectivene

p167 Weekly Lecture 15.LIVE - Dependability

p169 Lecture 38.2 - Dependability- Parity, ECC, RAID： Dependability Metrics

p170 Lecture 38.3 - Dependability- Parity, ECC, RAID： Error Detection

p171 Lecture 38.4 - Dependability- Parity, ECC, RAID： Error Detection and Correc

p172 Lecture 38.5 - Dependability- Parity, ECC, RAID： ECC Example

p173 Lecture 38.6 - Dependability- Parity, ECC, RAID： Redundancy with RAID

p174 Lecture 39.LIVE - GPU Guest Lecture with James Percy 

p175 Lecture 40.LIVE - Summary

p0 Introduction to DDCA： RISC-V Edition

p1 DDCA Ch1 - Part 0 Introduction to Digital Design

p2 DDCA Ch1 - Part 1 Managing Complexity

p3 DDCA Ch1 - Part 2 Unsigned Binary Numbers

p4 DDCA Ch1 - Part 3 Hexadecimal Numbers

p5 DDCA Ch1 - Part 4 Bytes, Nibbles & All That Jazz

p6 DDCA Ch1 - Part 5 Binary Addition

p7 DDCA Ch1 - Part 6 Signed Binary Numbers

p8 DDCA Ch1 - Part 7 Extension

p9 DDCA Ch1 - Part 8 Logic Gates

p10 DDCA Ch1 - Part 9 Transistors

p11 DDCA Ch1 - Part 10 Gates FromTransistors

p12 DDCA Ch1 - Part 11 Power Consumption of Digital Circuits

p13 DDCA Ch2 - Part 1 Combinational Logic Introduction

p14 DDCA Ch2 - Part 2 Combinational Circuits

p15 DDCA Ch2 - Part 3 Boolean Equations

p16 DDCA Ch2 - Part 4 Boolean Axioms

p17 DDCA Ch2 - Part 5 Boolean Theorems of One Variable

p18 DDCA Ch2 - Part 6 Boolean Theorems of Several Variables

p19 DDCA Ch2 - Part 7 Simplifying Boolean Equations

p20 DDCA Ch2 - Part 8 From Logic to Gates

p21 DDCA Ch2 - Part 9 Bubble Pushing

p22 DDCA Ch2 - Part 10 X's and Z's, Oh My

p23 DDCA Ch2 - Part 11 Karnaugh Maps (K-Maps)

p24 DDCA Ch2 - Part 12 K-Maps with Don't Cares

p25 DDCA Ch2 - Part 13 Multiplexers

p26 DDCA Ch2 - Part 14 Decoders

p27 DDCA Ch2 - Part 15 Timing of Combinational Logic

p28 DDCA Ch3 - Part 1 Intro to Sequential Logic

p29 DDCA Ch3 - Part 2 Bistable Circuit

p30 DDCA Ch3 - Part 3 - SR Latch

p31 DDCA Ch3 - Part 4 D Latch

p32 DDCA Ch3 - Part 5 D Flip-Flop

p33 DDCA Ch3 - Part 6 Flop Variations

p34 DDCA Ch3 - Part 7 Synchronous Sequential Logic

p35 DDCA Ch3 - Part 8 Finite State Machines (FSMs)

p36 DDCA Ch3 - Part 9 Moore FSM Example 1

p37 DDCA Ch3 - Part 10 Moore FSM Example 2

p38 DDCA Ch3 - Part 11 Mealy FSM Example

p39 DDCA Ch3 - Part 12 Factored FSMs

p40 DDCA Ch3 - Part 13 Timing

p41 DDCA Ch3 - Part 14 ClockSkew

p42 DDCA Ch3 - Part 15 Metastability

p43 DDCA Ch3 - Part 16 Synchronizers

p44 DDCA Ch3 - Part 17 Parallelism

p45 DDCA Ch4 - Part 1 - SystemVerilog Introduction-sVy31HJj4lA

p46 DDCA Ch4 - Part 2 Combinational logic in SystemVerilog

p47 DDCA Ch4 - Part 3 Delays in SystemVerilog simulations

p48 DDCA Ch4 - Part 4 Sequential Logic in SystemVerilog

p49 DDCA Ch4 - Part 5 Combinational logic using always blocks

p50 DDCA Ch4 - Part 6 SystemVerilog Assignments

p51 DDCA Ch4 - Part 7 FSMs

p52 DDCA Ch4 - Part 8 Parameterized Modules

p53 DDCA Ch4 - Part 9 Testbenches

p54 DDCA Ch5 - Part 1 Digital Building Blocks Introduction

p55 DDCA Ch5 - Part 2 Adders Introduction

p56 DDCA Ch5 - Part 3 Ripple Carry Adders

p57 DDCA Ch5 - Part 4 Carry Lookahead Adders

p58 DDCA Ch5 - Part 5 Prefix Adders

p59 DDCA Ch5 - Part 6 Subtractors & Comparators

p60 DDCA Ch5 - Part 7 ALUs

p61 DDCA Ch5 - Part 8 Shifters, Multipliers, & Dividers

p62 DDCA Ch5 - Part 9 Fixed Point Numbers

p63 DDCA Ch5 - Part 10 Floating Point Numbers

p64 DDCA Ch5 - Part 11 Floating Point Addition

p65 DDCA Ch5 - Part 12 Counters & Shift Registers

p66 DDCA Ch5 - Part 13 Memory Introduction

p67 DDCA Ch5 - Part 14 RAM

p68 DDCA Ch5 - Part 15 ROM

p69 DDCA Ch5 - Part 16 SystemVerilog Memories

p70 DDCA Ch5 - Part 17 Logic Arrays

p71 DDCA Ch6 - Part 1 Architecture Introduction

p72 DDCA Ch6 - Part 1 RISC-V Architecture Introduction

p73 DDCA Ch6 - Part 2 RISC-V Instructions

p74 DDCA Ch6 - Part 3 RISC-V Operands

p75 DDCA Ch6 - Part 4 RISC-V Memory Instructions

p76 DDCA Ch6 - Part 5 RISC-V Immediates (Constants)

p77 DDCA Ch6 - Part 6 Logical Instructions

p78 DDCA Ch6 - Part 7 RISC-V Multiplication & Division Instructions

p79 DDCA Ch6 - Part 8 Branches

p80 DDCA Ch6 - Part 9 RISC-V Conditional Statements

p81 DDCA Ch6 - Part 10 Arrays

p82 DDCA Ch6 - Part 11 RISC-V Functions

p83 DDCA Ch6 - Part 12 The Stack

p84 DDCA Ch6 - Part 13 Recursive Functions

p85 DDCA Ch6 - Part 14 Jumps & Pseudoinstructions

p86 DDCA Ch6 - Part 15 RISC-V Machine Instructions R-Type

p87 DDCA Ch6 - Part 16 More Machine Language Formats

p88 DDCA Ch6 - Part 17 RISC-V Immediate Encodings

p89 DDCA Ch6 - Part 18 Decoding Machine Language & Addressing Operands

p90 DDCA Ch6 - Part 19 Compiling, Assembling, and Loading Programs

p91 DDCA Ch6 - Part 20 Big-Endian and Little-Endian Memory

p92 DDCA Ch6 - Part 21 Signed and Unsigned RISC-V Instructions

p93 DDCA Ch6 - Part 22 RISC-V Compressed Instructions

p94 DDCA Ch6 - Part 23 RISC-V Floating-Point Instructions

p95 DDCA Ch7 - Part 1 Microarchitecture Introduction

p96 DDCA Ch7 - Part 2 RISC-V Single-Cycle Processor Datapath lw

p97 DDCA Ch7 - Part 3 RISC-V Single-Cycle Processor Datapath Extending Instructi

p98 DDCA Ch7 - Part 4 RISC-V Single-Cycle Processor Control

p99 DDCA Ch7 - Part 5 RISC-V Single-Cycle Processor Adding Instructions

p100 DDCA Ch7 - Part 6 RISC-V Single-Cycle Performance

p101 DDCA Ch7 - Part 6a RISC-V Processor Test Program & Testbench

p102 DDCA Ch7 - Part 6b RISC-V Single-Cycle Processor Verilog

p103 DDCA Ch7 - Part 6c Processor Tie Celebration

p104 DDCA Ch7 - Part 7 Multicycle Processor Datapath for lw

p105 DDCA Ch7 - part 8 RISC-V Multicycle Processor - Other Instructions

p106 DDCA Ch7 - Part 9 RISC-V Multicycle Processor Control lw

p107 DDCA Ch7 - Part 10 RISC-V Multicycle Processor Control Other Instructions

p108 DDCA Ch7 - Part 11 Extending the RISC-V Multicycle Processor

p109 DDCA Ch7 - Part 12 Multicycle Processor Performance

p110 DDCA Ch7 - Part 13 Pipelined Processor

p111 DDCA Ch7 - Part 14 Pipelined Processor Data Hazards

p112 DDCA Ch7 - Part 15 Pipelined Processor Control Hazards

p113 DDCA Ch7 - Part 16 Pipelined Processor Performance

p114 DDCA Ch7 - Part 17 Advanced Microarchitecture

p115 DDCA Ch7 - Part 18 Superscalar & Out of Order Processors

p116 DDCA Ch7 - Part 19 Multithreading & Multiprocessors

p117 DDCA Ch9 - Part 1 Embedded Systems Introduction

p118 DDCA Ch9 - Part 2 RISC-V Microcontrollers

p119 DDCA Ch9 - Part 3 Memory-Mapped IO

p120 DDCA Ch9 - Part 4 General-Purpose IO (GPIO)

p121 DDCA Ch9 - Part 5 RISC-V Device Driver

p122 DDCA Ch9 - Part 6 Timers

p123 DDCA Ch9 - Part 7 Morse Code Example

p124 DDCA Ch9 - Part 8 Interfacing

p125 DDCA Ch9 - Part 9 SPI

p126 DDCA Ch9 - Part 10 SPI Accelerometer Example

0_01_course-introduction

1_02_course-overview

2_03_motivation

3_04_course-content

4_05_architecture-and-microarchitecture

5_06_machine-models

6_07_isa-characteristics

7_08_recap

8_02_microcoded-microarchitecture

9_03_pipeline-basics

10_04_structural-hazard

11_05_data-hazards

12_02_control-hazards-jumps

13_03_control-hazards-branch

14_04_control-hazards-others

15_05_memory-technologies

16_06_motivation-for-caches

17_02_classifying-caches

18_03_cache-performance

19_04_superscalar-1

20_05_basic-two-way-in-order-superscalar

21_06_fetch-logic-and-alignment

22_02_baseline-superscalar-and-alignment

23_03_interrupts-and-bypassing

24_04_interrupts-and-exceptions

25_05_introduction-to-out-of-order-processors

26_01_review-of-out-of-order-processors

27_02_i2o2-processors

28_03_i2o1-processors

29_04_io3-processors

30_05_io2i-processors

31_01_speculation-and-branch

32_02_register-renaming-introduction

33_03_register-renaming-with-pointers-to-iq-and-rob

34_04_register-renaming-with-values-in-iq-and-rob

35_05_memory-disambiguation

36_02_limits-of-out-of-order-design-complexity

37_03_introduction-to-vliw

38_04_vliw-compiler-optimizations

39_05_classic-vliw-challenges

40_06_introduction-to-predication

41_02_scheduling-model-review

42_03_review-of-predication

43_04_predication-implementation

44_05_speculation-execution

45_06_dynamic-events-and-clustered-vliws

46_07_case-study-ia-64-itanium

47_02_branch-cost-motivation

48_03_branch-prediction-introduction

49_04_static-outcome-prediction

50_05_dynamic-outcome-prediction

51_06_target-address-prediction

52_02_basic-cache-optimizations

53_03_cache-pipelining

54_04_write-buffers

55_05_multilevel-caches

56_06_victim-caches

57_07_prefetching

58_02_multiporting-and-banking

59_03_software-memory-optimizations

60_04_non-blocking-caches

61_05_critical-word-first-and-early-restart

62_02_memory-management-introduction

63_03_base-and-bound-registers

64_04_page-based-memory-systems

65_05_translation-and-protection

66_06_tlb-processing

67_02_address-translation-review

68_03_cache-and-memory-protection-interaction

69_04_vector-processor-introduction

70_05_vector-parallelism

71_06_vector-hardware-optimizations

72_07_vector-software-and-compiler-optimizations

73_02_reduction-scatter-gather-and-the-cray-1

74_03_simd

75_04_gpus

76_05_multithreading-motivation

77_06_coarse-grain-multithreading

78_07_simultaneous-multithreading

79_02_smt-implementation

80_03_introduction-to-parallelism

81_04_sequential-consistency

82_05_introduction-to-locks

83_01_sequential-consistency-review

84_02_locks-and-semaphores

85_03_atomic-operations

86_04_memory-fences

87_05_dekkers-algorithm

88_02_locking-review

89_03_bus-implementation

90_04_cache-coherence

91_05_bus-based-multiprocessors

92_06_cache-coherence-protocols

93_02_more-cache-coherence-protocols

94_03_introduction-to-interconnection-networks

95_04_message-passing

96_05_interconnect-design

97_02_networking-review

98_03_topology

99_04_topology-parameters

100_05_network-performance

101_06_routing-and-flow-control

102_02_credit-based-flow-control

103_03_deadlock

104_04_false-sharing

105_05_introduction-to-directory-coherence

106_06_implementation

107_07_scalability-of-directory-coherence

p0 1. Introduction to Algorithms

p1 1.1 Priori Analysis and Posteriori Testing

p2 1.2 Characteristics of Algorithm

p3 1.3 How Write and Analyze Algorithm

p4 1.4 Frequency Count Method

p5 1.5.1 Time Complexity #1

p6 1.5.2 Time Complexity Example #2

p7 1.5.3 Time Complexity of While and if #3

p8 1.6 Classes of functions

p9 1.7 Compare Class of Functions

p10 1.8.1 Asymptotic Notations Big Oh - Omega - Theta #1

p11 1.8.2 Asymptotic Notations - Big Oh - Omega - Theta #2

p12 1.9 Properties of Asymptotic Notations

p13 1.10.1 Comparison of Functions #1

p14 1.10.2 Comparison of Functions #2

p15 1.11 Best Worst and Average Case Analysis

p16 1.12 Disjoint Sets Data Structure - Weighted Union and Collapsing Find

p17 2 Divide And Conquer

p18 2.1.1 Recurrence Relation (T(n)= T(n-1) + 1) #1

p19 2.1.2 Recurrence Relation (T(n)= T(n-1) + n) #2

p20 2.1.3 Recurrence Relation (T(n)= T(n-1) + log n) #3

p21 2.1.4 Recurrence Relation T(n)=2 T(n-1)+1 #4

p22 2.2 Masters Theorem Decreasing Function

p23 2.3.1 Recurrence Relation Dividing Function T(n)=T(n⧸2)+1 #1

p24 2.3.2 Recurrence Relation Dividing [ T(n)=T(n⧸2)+ n]. #2

p25 2.3.3 Recurrence Relation [ T(n)= 2T(n⧸2) +n] #3

p26 2.4.1 Masters Theorem in Algorithms for Dividing Function #1

p27 2.4.2 Examples for Master Theorem #2

p28 2.5 Root function (Recurrence Relation)

p29 2.6.1 Binary Search Iterative Method

p30 2.6.2 Binary Search Recursive Method

p31 2.6.3 Heap - Heap Sort - Heapify - Priority Queues

p32 2.7.1 Two Way MergeSort - Iterative method

p33 2.7.2. Merge Sort Algorithm

p34 2.7.3 MergeSort in-depth Analysis

p35 2.8.1 QuickSort Algorithm

p36 2.8.2 QuickSort Analysis

p37 2.9 Strassens Matrix Multiplication

p38 3. Greedy Method - Introduction

p39 3.1 Knapsack Problem - Greedy Method

p40 3.2 Job Sequencing with Deadlines - Greedy Method

p41 3.3 Optimal Merge Pattern - Greedy Method

p42 3.4 Huffman Coding - Greedy Method

p43 3.5 Prims and Kruskals Algorithms - Greedy Method

p44 3.6 Dijkstra Algorithm - Single Source Shortest Path - Greedy Method

p45 4 Principle of Optimality - Dynamic Programming introduction

p46 4.1 MultiStage Graph - Dynamic Programming

p47 4.1.1 MultiStage Graph (Program) - Dynamic Programming

p48 4.2 All Pairs Shortest Path (Floyd-Warshall) - Dynamic Programming

p49 4.3 Matrix Chain Multiplication - Dynamic Programming

p50 [New] Matrix Chain Multiplication using Dynamic Programming Formula

p51 4.3.1 Matrix Chain Multiplication (Program) - Dynamic Programming

p52 4.4 Bellman Ford Algorithm - Single Source Shortest Path - Dynamic Programmi

p53 4.5 0⧸1 Knapsack - Two Methods - Dynamic Programming

p54 4.5.1 0⧸1 Knapsack Problem (Program) - Dynamic Programming

p55 4.6 Optimal Binary Search Tree (Successful Search Only) - Dynamic Programmin

p56 4.6.2 [New] Optimal Binary Search Tree Successful and Unsuccessful Probabili

p57 4.7 [New] Traveling Salesman Problem - Dynamic Programming using Formula

p58 4.8 Reliability Design - Dynamic Programming

p59 4.9 Longest Common Subsequence (LCS) - Recursion and Dynamic Programming

p60 5.1 Graph Traversals - BFS & DFS -Breadth First Search and Depth First Searc

p61 5.2 Articulation Point and Biconnected Components

p62 6 Introduction to Backtracking - Brute Force Approach

p63 6.1 N Queens Problem using Backtracking

p64 6.2 Sum Of Subsets Problem - Backtracking

p65 6.3 Graph Coloring Problem - Backtracking

p66 6.4 Hamiltonian Cycle - Backtracking

p67 7 Branch and Bound Introduction

p68 7.1 Job Sequencing with Deadline - Branch and Bound

p69 7.2 0⧸1 Knapsack using Branch and Bound

p70 7.3 Traveling Salesman Problem - Branch and Bound

p71 8. NP-Hard and NP-Complete Problems

p72 8.1 NP-Hard Graph Problem - Clique Decision Problem

p73 9.1 Knuth-Morris-Pratt KMP String Matching Algorithm

p74 9.2 Rabin-Karp String Matching Algorithm

p75 10.1 AVL Tree - Insertion and Rotations

p76 10.2 B Trees and B+ Trees. How they are useful in Databases

p77 Asymptotic Notations - Simplified

p78 Hashing Technique - Simplified

p79 Shortest Path Algorithms (Dijkstra and Bellman-Ford) - Simplified

p80 BFS DFS - Simplified

p81 Tower of Hanoi Problem - Made Easy

p82 Row-Major and Column-Major Mapping

p83 Merge Sort Algorithm - Hindi

P1

P2

P3

P4

P5

P6

P7

P8

P9

P10

P11

P12

P13

P14

P15

P16

P17

P18

P19

P20

P21

P22

P23

P24

P25

P1 - Intro 1： Layers of the Internet

P2 - Intro 2： Design Principles

P3 - Links

P4 - Routing Principles

P5 Routing 2： Distance-Vector

P6 - Distance-Vector Protocols (continued)

P7 - Routing 3： Link-State, Addressing

P8 - Routing 4： Routers

P9 - Routing 5： BGP I

P10 - Transport 2： TCP II

P11 - Transport 3： Congestion Control I

P12 - Transport 4： Congestion Control II

P13 - Transport 5： Congestion Control II (continued)

P14 - Applications 1： DNS

P14 - Applications 2： HTTP

P15 - End-to-End 1： Ethernet, STP

P16 - End-to-End 2： ARP, DHCP, NAT, TLS

P17 - Datacenter Topology

P18 - Datacenters 1： Topology

P19 - Datacenters 2： Routing

P20 Datacenters 3-4： SDN and Host Networking

P21 - Beyond Client-Server 1： Multicast

P22 - Multicast (continued) and Collectives

P23 - Collectives (continued) and Wireless Links

P24 - Cellular

P1 BGP II 的内容 Combining Intra- and Inter-Domain Routing

P2 eBGP, iBGP, and IGP

P3 Learning Internal and External Routes

P4 Forwarding to Internal and External Destinations

P5 Implementing iBGP Sessions

P6 Multiple Links Between ASes

P7 Hot Potato Routing

P8 MED

P9 Summary of Tiebreaking Policies

P10 Hot Potato Routing and MED are Contradictory

P11 Implementing BGP： Message Types

P12 Implementing BGP： Route Attributes

P13 BGP Issues

P14 IPv4 Header： Basics, Checksum

P15 IPv4 Header： Fragmentation

P16 IPv4 Header： Options, Type of Service

P17 IPv6 Header： Removed Fields

P18 IPv6 Header： Added Fields

P19 IP Security

P1 TCP1的内容，Transport Layer Demultiplexing

P2 Transport Layer Abstractions

P3 Defining Reliability

P4 Dropped Packets

P5 Corrupted, Delayed, Duplicated Packets

P6 Window-Based Algorithms

P7 Setting W： Filling the Pipe

P8 Setting W： Flow Control

P9 Setting W： Congestion Control

P10 Ack Strategies： Individual, Full-Information

P11 Ack Strategies： Cumulative

P12 Ack-Based Loss Detection

P13 Responding to Loss： Individual Acks

P14 Responding to Loss： Cumulative Acks

P15 Alternate Designs

P1 What are OSes Logistics

P2 Exceptions Context Switching

P3 The Unix API 1

P4 The Unix API 2

P5 The Unix API 3 Scheduling 1

P6 Scheduling 2

P7 Scheduling 3

P8 Threads Synchronization 1- Locks 1

P9 Synchronization 2- Locks 2, Mutexes

P10 Synchronization 3- Monitors and Semaphores

P11 Synchronization 4- Semaphores and Monitors con't Reader+Writer Locks

P12 Synchronization 5- Reader+Writer con't Deadlock

P13 Virtual Memory 1

P14 Virtual Memory 2

P15 Midterm Review screencapture

P16 Virtual Memory 3- mmap, page cache (intro)

P17 Virtual 4

P18 Virtual 5 I-O 1

P19 I-O 2 Filesystems 1

P20 Filesystems 2

P21 Filesystems 4

P22 Sockets ⧸ Distributed Systems 1

P23 Distributed Systems 2： RPC ⧸ Failure

P24 Distributed Systems 3： Failure

P25 Distributed Systesm 4： NFS ⧸ Access Control 1

P26 Virtual Machines

P27 Final Exam Review screencapture

P1 Course Introduction

P2 Assembly 1

P3 Assembly 2

P4 Compilation Pipeline ⧸ selected C topics

P5 Bitwise

P6 Bitwise (finish) - ISAs

P7 Y86

P8 SEQ part 1

P9 SEQ part 2

P10 SEQ part 3

P11 SEQ part 4 - Pipelining 0

P12 Pipelining 1

P13 Pipelining 2

P14 Pipelining 3

P15 Pipelining 4 - Cache 1

P16 Cache 2

P17 Cache 3

P18 Cache performance 1

P19 Cache performance 2

P20 Optimization and Out-of-order 1

P21 Optimization and Out-of-order 2

P22 Optimizations 3

P23 Exceptions

P24 Exceptions (finish) - Virtual memory 1

P25 Virtual memory 2

P26 Virtual memory 3

P27 Final review

P1 Lecture 1 Algorithmic Thinking, Peak Finding

P2 Lecture 2 Models of Computation, Document Distance

P3 Lecture 3 Insertion Sort, Merge Sort

P4 Lecture 4 Heaps and Heap Sort

P5 Lecture 5 Binary Search Trees, BST Sort

P6 Lecture 6 AVL Trees, AVL Sort

P7 Lecture 7 Counting Sort, Radix Sort, Lower Bounds for Sorting

P8 Lecture 8 Hashing with Chaining

P9 Lecture 9 Table Doubling, Karp-Rabin

P10 Lecture 10 Open Addressing, Cryptographic Hashing

P11 Lecture 11 Integer Arithmetic, Karatsuba Multiplication

P12 Lecture 12 Square Roots, Newton's Method

P13 Lecture 13 Breadth-First Search (BFS)

P14 Lecture 14 Depth-First Search (DFS), Topological Sort

P15 Lecture 15 Single-Source Shortest Paths Problem

P16 Lecture 16 Dijkstra

P17 Lecture 17 Bellman-Ford

P18 Lecture 18 Speeding up Dijkstra

P19 Lecture 19 Dynamic Programming I Fibonacci, Shortest Paths

P20 Lecture 20 Dynamic Programming II Text Justification, Blackjack

P21 Lecture 21 Dynamic Programming III Parenthesization, Edit Distance, Knapsack

P22 Lecture 22 Dynamic Programming IV Guitar Fingering, Tetris, Super Mario Bros

P23 Lecture 23 Computational Complexity

P24 Lecture 24 Topics in Algorithms Research

P25 Recitation 1 Asymptotic Complexity, Peak Finding

P26 Recitation 2 Python Cost Model, Document Distance