CS 261
CS 261
C and Unix/Linux
Terminal interface
Shells (bash and scp)
Basic file utilities (cd, ls, cat, cp, etc.)
Command line parameters
Text editors (nano, vim, emacs)
Build systems (make)
Compilation
Preprocessing
Compiling
Assembling
Linking
Debugging
Breakpoints
Watchpoints
Step into
Step over
Backtracing
Memory model
Static code
Static data
Stack
Heap
C language
Pointers
Strings
File I/O
Getopt
Structs
Typedefs
Bitwise operations
Architecture
von Neumann architecture
System stack
Logic gates
Relays
Transitors
Digital signals
Universal gates
Combinational circuits
Boolean formulas
HDL
Circuit equivalency
Basic
Equality checkers
Multiplexors
Half adders
Full adders
Advanced
Ripple-carry adders
Adder/subtractors
Sequential circuits
Circuit "memory" via feedback
Time sensitivity
Edge-triggers vs. master-slave
Clocks
Basic
SR latch
D latch
Flip-flops
Advanced
Registers
Register files
Memory
Shift registers
Counters
CPU design
Stages
Fetch
Decode
Execute
Memory
Write back
PC update
Components
Clocked PC register
ALU / register file / memory
Control logic
Wires & buses
"No reading back" principle
Throughput and latency
Pipelining
Instruction-level parallelism
Tradeoff: throughput vs. latency
Issue: non-uniform partitioning
Issue: data and control dependencies
Stalling and forwarding
Branch prediction
Memory design
Memory hierarchy
Technologies
SRAM
DRAM
HDD / SSD
Tape
I/O architecture
DMA
Historical trends
Caching
Locality
Temporal
Spatial
Strides
Latency
Prefetching
Cache memory
Cache miss
Cache hit
Cache write
Cache architecture
Memory mountain
Binary representations
Base conversions
Binary
Octal
Decimal
Hexadecimal
Endianness
Big
Little
Integers
Unsigned
Sign magnitude
Ones' complement
Two's complement
Bitwise operations
AND
OR
XOR
Left shift
Right shift
Logical
Arithmetic
Floating point
Normalized
Denormalized
Infinity (+/-)
Not-a-Number (NaN)
Text
ASCII
Unicode
UTF-8 vs. UTF-16/32
Code
Machine code
RISC vs. CISC
Opcodes
Registers
Assembly code
Assembly/machine code
Movement & arithmetic
Addressing modes
Immediate
Register
Indirect
Base + displacement
Indexed
Scaled indexed
Stack management
Integer arithmetic
Bitwise logical & shifts
Floating-point arithmetic
Vector (SIMD) instructions
SSE instruction sets
XMM/YMM registers
Stupid Floating-Point Hacks (TM)
Control flow
Condition flags
CF
OF
SF
ZF
Comparisons and tests
C goto code
Labels
Unconditional jumps
Conditional jumps
Conditional moves
Loop
Do-while
Jump-to-middle
Guarded-do
Jump tables
Procedures
Application Binary Interface (ABI)
Calling conventions
Stack frames
Return address
Call and return
Parameters
Registers
Caller-saved
Callee-saved
Local variables
Data structures
Homogeneous vs. heterogeneous
Arrays
Pointer arithmetic
Indexing
Nested / multidimensional
Structs / records
Alignment
Unions
Buffer overruns
Shellcode
Stack randomization
Canary values
Read-only code regions
Operating systems
Kernel
User vs. kernel mode
Monolithic vs. microkernel
Virtual memory
Virtual vs. physical memory
Address spaces
Memory pages
Page faults / swapping
MMU and TLB
Allocation
Explicit
Implicit
Exceptions
Async vs. sync
Recovery options
Types
Interrupt
Trap
Fault
Abort
Exception table
System calls
SysV
POSIX
Signals
Common signals
SIGALRM
SIGINT
SIGSEGV
SIGKILL
SIGTERM
Signal handlers
signal() / raise()
Debuggers
Processes
Logical flows
Concurrency
Multitasking / time-sharing
Parallelism
Context switching
C language
fork
wait
execve
Shell
Jobs
Foreground vs. background
Threads
Processes vs. threads
Shared memory
POSIX threads (pthreads)
Data races
History of parallelism
Uniprogramming
Multiprogramming
Multiprocessing
Distributed computing
Files
Types
Regular
Directory
Socket
File systems
File hierarchy
Absolute vs. relative file name
Mount points
Metadata (stat)
Implementation
Low-level syscalls
File sharing
High-level libc functions
Standard I/O
Input
Output
Error
Redirects
Pipes
Permissions
Unix permissions
ACLS
