MIT · Computer Science

6.004 Computation Structures

Chris Terman · 2017 · 170 free video lectures

This course introduces architecture of digital systems, emphasizing structural principles common to a wide range of technologies. It covers the topics including multilevel implementation strategies, definition of new primitives (e.g., gates, instructions, procedures, processes) and their…

▶ Play on Open Lecture HallCourse page ↗

Lectures

  1. What is information? (2:16)
  2. Concrete Encoding of Information (4:16)
  3. MOSFET: Physical View (7:59)
  4. Sum of Products (9:38)
  5. Digital State (10:05)
  6. Finite State Machines (5:56)
  7. Latency and Throughput (6:17)
  8. Power Dissipation (11:48)
  9. Datapaths and FSMs (5:17)
  10. Intro to Assembly Language (8:13)
  11. Intepretation and Compilation (9:36)
  12. Procedures (10:04)
  13. Building Blocks (10:13)
  14. Memory Technologies (4:16)
  15. Improving Beta Performance
  16. Associative Caches (9:32)
  17. CMOS Timing (10:03)
  18. Compiling Expressions (8:34)
  19. Compiling a Procedure (4:45)
  20. D Register Timing (5:46)
  21. Deadlock
  22. Example: Match Handler with OS (5:23)
  23. Exceptions (6:04)
  24. Handling Illegal Instructions
  25. Instruction-level Parallelism
  26. Jumps and Branches (7:46)
  27. Karnaugh Maps (10:57)
  28. Load and Store (4:34)
  29. MMU Improvements
  30. Page Faults
  31. Processes
  32. Synchronization and Metastability (9:52)
  33. System-level Interconnect
  34. The von Neumann Model (10:29)
  35. VTC Example (2:18)
  36. Wires
  37. Worked Example: A Better Beta
  38. Worked Example: Caches
  39. Worked Example: Combinational Logic Timing
  40. Worked Example: Compilers
  41. Worked Example: FSM Implementation
  42. Worked Example: Karnaugh Maps
  43. Worked Example: Latch Implementation
  44. Worked Example: Operating Systems
  45. Worked Example: Pipelining
  46. Worked Example: Procedures and Stacks
  47. Worked Example: Programmable Architectures
  48. Worked Example: Semaphores
  49. Worked Example: Sequential Logic Timing
  50. Worked Example: The Static Discipline
  51. Worked Example: Two's Complement Representation
  52. ALU Instructions (7:00)
  53. Activation Records and Stacks (8:41)
  54. Atomic Transactions
  55. Basics of Virtual Memory
  56. Carry-lookahead Adders (5:19)
  57. Computability, Universality (6:01)
  58. Data Hazards
  59. Models of Computation (6:12)
  60. Optimization and Code Generation (8:23)
  61. Pipelining Methodology (5:59)
  62. Point-to-point Communication
  63. Semaphore Implementation (4:16)
  64. Sequential Circuit Timing (6:52)
  65. Stack Frame Organization (5:49)
  66. Storage (6:37)
  67. The Locality Principle (7:12)
  68. Timesharing
  69. Worked Example: CMOS Functions
  70. Worked Example: Cache Benefits
  71. Worked Example: Error Correction
  72. Worked Example: FSM States and Transitions
  73. Worked Example: Two's Complement Addition
  74. Write Strategies (4:16)
  75. Building the MMU
  76. CMOS Gates (3:40)
  77. Caches (5:54)
  78. Carry-select Adders (5:40)
  79. Constant Operands (5:29)
  80. Control Hazards
  81. Control Structures (2:16)
  82. Direct-mapped Caches (7:09)
  83. Encoding (3:49)
  84. Error Detection (5:09)
  85. Instruction Macros (7:39)
  86. Lenient Gates (4:21)
  87. Multiplier Tradeoffs (5:13)
  88. OS Device Handlers
  89. Stack Detective (5:57)
  90. Symbols and Labels (4:24)
  91. System-level Interfaces
  92. Thread-level Parallelism
  93. Worked Example: CMOS Logic Gates
  94. Worked Example: Truth Tables
  95. ALU Instructions (6:57)
  96. Analog Signaling (7:20)
  97. Assembly Wrap-up (4:44)
  98. Basic 5-Stage Pipeline
  99. Beta Junkyard
  100. Branches (6:19)
  101. Compiler Frontend (4:32)
  102. Compiling Statements (3.53)
  103. Contexts
  104. D Register (5:06)
  105. Exceptions and Interrupts
  106. Fixed-length Encodings (5:51)
  107. Inverting Logic (7:26)
  108. MOSFET: Electrical View (8:10)
  109. Pipelining Summary
  110. Programmable Datapaths (4:50)
  111. Read-only Memories (5:38)
  112. Real Time (5:47)
  113. Recap: Virtual Memory
  114. SRAM (6:58)
  115. Variable-length Encoding (3:40)
  116. Worked Example: Gates and Boolean Logic
  117. Worked Example: Huffman Encoding
  118. 6.004 Wrap-up
  119. Buses
  120. Cache Coherence
  121. D Latch (6:12)
  122. Data-level Parallelism
  123. Equivalent States; Implementation (6:03)
  124. Example: Priorities in Action!
  125. Logic Simplification (5:00)
  126. Pipelined Circuits (6:11)
  127. Roboant Example (5:33)
  128. Self-timed Circuits (6:21)
  129. Shared Memory & Caches
  130. Strong Priorities (7:56)
  131. Supervisor Calls
  132. Voltage Transfer Characteristic (5:06)
  133. Worked Example: Devices and Interrupts
  134. Worked Example: Pipelining 2
  135. Beyond Inverters (5:29)
  136. CMOS Recipe (5:15)
  137. Combinational Devices (6:06)
  138. Communication Topologies (6:28)
  139. Huffman Code (1:20)
  140. Interprocess Communication
  141. Jumps (3:24)
  142. Memory Access (2:56)
  143. Multiplexers (3:14)
  144. Part 1 Wrap-up (3:02)
  145. Pipelined Beta
  146. Semaphores (7:31)
  147. Summary (3:42)
  148. Useful Logic Gates (5:56)
  149. Weak Priorities (5:10)
  150. Circuit Interleaving (7:08)
  151. Dealing with Noise (4:20)
  152. Even More Memory Hierarchy
  153. Huffman's Algorithm (2:09)
  154. Quantifying Information (5:22)
  155. Signed Integers: 2's complement (4:34)
  156. Timing Example (3:28)
  157. Uncomputable Functions (2:57)
  158. Binary Multiplication (6:03)
  159. Block Size; Cache Conflicts (6:04)
  160. Entropy (2:49)
  161. Error Correction (1:34)
  162. FSM States (3:45)
  163. SVCs for Input/Output (8:52)
  164. DRAM (5:10)
  165. Using Voltages Digitally (4:28)
  166. Worked Example: Virtual Memory
  167. Non-volatile Storage; Using the Hierarchy (8:43)
  168. State Transition Diagrams (11:18)
  169. Worked Example: Beta Assembly
  170. Worked Example: Beta Control Signals

From MIT OpenCourseWare · CC BY-NC-SA 4.0. More from MIT.

Open Lecture Hall is free, with no ads and no sign-up. It is not run by or connected to any university; the lectures are the universities' own free recordings, played from where they host them. About & rights