Assembly language

Machine organization

String (computer science)

Vector (C++)

System Programming

Memory allocation

Array (data structure)

Pointer (computer programming)

struct (C programming language)

Data structure alignment

Collection Summary

Signed number representations

Calling Conventions

Stack (abstract data type)

Caching

Operating system

Privilege separation

Memory protection

Virtual memory

Page table

Process Control

Process (computing)

Inter-Process Communication (IPC)

Thread (computing)

Race condition

Synchronization (computer science)

Synchronization Patterns

Deadlock

Networking

Scalability

Distributed Scalability

Failures

Consistency (database systems)

Real-world Distributed Systems

CS 131: Fundamentals of Computer Systems Brown University Spring 2020 This course delves deep into the foundational principles behind computer systems, ranging from hardware intricacies to the vast global internet. Students gain insights into systems programming, the architecture of computer systems, concurrency, and the dynamics of distributed systems. Notably, the curriculum includes projects that offer hands-on experience, like building library functions, creating a toy OS, and designing a scalable key-value storage service. It's a stepping stone to advanced courses like Distributed Systems, Databases, and Computer Systems Security. The goal of **CS 131/CSCI 1310** is to teach the fundamentals behind the "magic" of computer systems from the hardware level to the global internet. We'll cover the ideas, principles and abstractions that unify computer systems design – from how your laptop runs multiple programs at the same time, to how companies like Instagram, AirBnB, and Google operate large websites, to how easy it is to exploit security vulnerabilities on badly designed systems. This is a great class for students who are interested in learning **what** systems programming is, **how** systems work, and **why** these systems are so critical to modern technology. We will look at topics arranged in four main blocks during the course, building up your understanding across the whole systems stack:

1. **Computer Systems Basics**: programming in systems programming languages (C and C++); memory; how code executes; and why machine and memory organization mean that some code runs much faster than other code that implements the same algorithm.
    *Project*: you will build your own versions of standard library functions and a vector data structure (strvec), and you will develop your own debugging memory allocator, helping you understand common memory bugs in systems programming languages (DMalloc).
1. **Fundamentals of Operating Systems**: how your computer runs even buggy or incorrect programs without crashing; how it keeps your secrets in one program safe from others; and how an operating system like Windows, Mac OS X, or Linux works.
    *Project*: you will implement memory isolation via virtual memory in your own toy operating system (WeensyOS)!
1. **Concurrency and Parallel Programming**: how your computer can run multiple programs at the same time; how you can share memory even if running programs on multiple processors; why programming with concurrency is very difficult; and how concurrency is behind almost all major web services today.
    *Project*: you will implement the server-side component of a peer payment application called "Vunmo", and make it handle requests from many users.
1. **Distributed Systems**: what happens when you use more than one computer and have computers communicate over networks like the Internet; how hundreds of computer can work together to solve problems far too big for one computer; and how programs running distributedly can survive the failure of participating computers.
    *Project*: you will implement a sharded key-value storage service that can (in principle) scale over hundreds or thousands of machines.

The first block, Computer Systems Basics, begins today. It's about how we represent data and code in terms the computer can understand. But today's lecture is also a teaser lecture, so we'll see the material raise questions that you cannot yet answer (but you will, hopefully, at the end of the course!). CS 131/CSCI 1310 is open to anyone who has completed the introductory sequence (i.e., CS 16, 18, or 19). For students who don't satisfy the registration restrictions on CAB, please request an override code on CAB and include an explanation of your course experience, and we'll review your request. **What does CS 131 count for?** CS 131/CSCI 1310 is a 1000-level course that can count as a related course in the systems pathway of the CS concentration and masters. In addition, CS 131 will satisfy the prerequisites for CSCI 1380 (Distributed Systems), CSCI 1270 (Databases), CSCI 1650 (Software Security and Exploitation), CSCI 1660 (Computer Systems Security), CSCI 1730 (Programming Languages), CSCI 1951-A (Data Science), CSCI 1680 (Computer Networks), and CSCI 2390 (Privacy-Conscious Computer Systems).

CS 131: Fundamentals of Computer Systems

Computer Systems

C Programming

Memory representation

Control flow

Call stack

Buffer overflow

Address translation

Inter-process communication

Pipeline (Unix)

Multiprocessing

Atomic instructions

Mutexes (Mutual exclusion)

Bounded-buffer problem

Condition variables

CSCI 0300: Fundamentals of Computer Systems Brown University Spring 2023 Introductory course covering computer system fundamentals including machine organization, systems programming in C/C++, operating systems concepts, isolation, security, virtualization, concurrency, and distributed systems. Projects involve implementing core OS functionality. CSCI 0300 covers fundamental concepts, principles, and abstractions that underlie the design and engineering of computer systems. You will learn how a computer works, how to write safe and performant systems software, and what systems abstractions support today's complex, high-performance systems developed in industry. Specific topics include machine organization, systems programming and performance, key concepts of operating systems, isolation, security, virtualization, concurrent programming, and the basics of distributed systems.

The course format is a combination of lectures, labs, and several hands-on projects involving programming exercises in C/C++. The goal of CSCI 0300/CS 300 is to teach the fundamentals behind the "magic" of computer systems from the hardware level to the global internet. We'll cover the ideas, principles and abstractions that unify computer systems design – from how your laptop runs multiple programs at the same time, to how companies like Instagram, Airbnb, and Google operate large websites, to how easy it is to exploit security vulnerabilities on badly designed systems. This is a great class for students who are interested in learning what systems programming is, how systems work, and why these systems are so critical to modern technology. This is an introductory computer systems course, designed to expose students to a broad set of fundamental concepts in computer systems and their practical applications. It is best suited for students who have completed the intro sequence, and to those who may want to deepen their understanding of systems concepts. Programming languages used in assignments include C and C++. ## CSCI 0300 highlights

- *Learn how a computer really works:* we'll look into what happens when a program runs, from the basics to high-level concepts!
- *Use industry-strength tools:* CSCI 0300 teaches you modern C/C++ programming with the tools that professional software engineers use!
- *Two programming languages for the price of one:* learn C and C++, two widely-used systems programming languages for high-performance software!
- *Real-world inspired projects:* in CSCI 0300's projects, you'll implement the core of your own operating system, and learn to build scalable infrastructure such as a distributed data store and a multi-threaded server similar to those companies use to run web services you use every day!

CSCI 0300: Fundamentals of Computer Systems

Floating Point

RISC-V Procedures

Loader

RISC-V Single-Cycle Datapath

Caches - Multilevel

Parallelism

Translation Lookaside Buffer (TLB)

Amdahl's law

RAID (Redundant Array of Inexpensive Disks)

RISC-V Instruction Formats

Combinational Logic

RISC-V Single-Cycle Control

Caches - Set-associative

Thread-level Parallelism

Page faults

Virtual memory performance

Data-level parallelism

Data center

Number Representation

RISC-V

Compiler

Synchronous Digital Systems (SDS) State

RISC-V 5-Stage Pipeline

Performance with Caches

OpenMP

Multilevel

Dependability

Warehouse-scale Computing

Input/output

C (programming language)

RISC-V Data Transfer

Assembler

Finite State Machine (FSM)

Hazards

Flynn taxonomy

Cache coherence

Interrupts

MapReduce

Parity

C Memory (Mis)Management

RISC-V Decision Making Logical Ops

Linker

Combinational Logic Blocks

Caches - Direct Mapped

Single instruction, multiple data (SIMD)

Performance

Exception handling

Apache Spark

Error-correcting Codes (ECC)

CS 61C Great Ideas in Computer Architecture (Machine Structures) UC Berkeley Fall 2022 This course deepens students' understanding of computer architecture and the translation of high-level programs into machine language. Emphasis is on C and assembly language programming, computer organization, parallelism, CPU design, and warehouse-scale computing. Prerequisites include CS61A and CS61B or equivalent C-based programming experience. [Official Academic Guide course description](https://classes.berkeley.edu/content/2022-fall-compsci-61c-001-lec-001)

The subjects covered in this course include C and assembly language programming, translation of high-level programs into machine language, computer organization, caches, performance measurement, parallelism, CPU design, warehouse-scale computing, and related topics.  CS61A and CS61B (or equivalents) or experience with a C-based programming language (e.g. Java, C++). There is no official textbook for this class. However, there are three optional textbooks as additional references:

- **P&H**: Second edition of Patterson and Hennessy's *Computer Organization and Design RISC-V Edition* book ("P&H"), ISBN 0128122757.
- **K&R**: *The C Programming Language, Second Edition* by Kernighan and Ritchie. Other C programming books are also suitable if you are already comfortable with them, but our lectures will be based on K&R.
- **WSC**: *The Datacenter as a Computer: An Introduction to the Design of Warehouse-Scale Machines*, which is freely available [on our website](https://inst.eecs.berkeley.edu/~cs61c/resources/WSCBarrosoHolzle.pdf).

Please contact staff on Ed if you have trouble finding or paying for these textbooks.

CS 61C Great Ideas in Computer Architecture (Machine Structures)

Assembly language

3 courses cover this concept

CS 131: Fundamentals of Computer Systems

CSCI 0300: Fundamentals of Computer Systems

CS 61C Great Ideas in Computer Architecture (Machine Structures)