CS4310: Operating Systems - Semester Summary #

Course Overview #

This semester, we’ve explored the fundamental concepts of operating systems, focusing on how programs interact with hardware and how the OS manages system resources. We’ve examined both theoretical concepts and practical implementations, with a strong emphasis on systems programming in C and assembly language.

Key Topics Covered #

Assembly Language and Low-Level Programming #

• AMD64 Assembly: Registers, instructions, calling conventions
• Memory Layout: Stack, heap, code, data segments
• System Calls: Direct hardware interaction through syscall instruction
• C to Assembly Translation: Understanding how high-level code maps to machine instructions

Assembly Demo #

# gcc -no-pie -o hello hello.s

.section .text
.global main

main:
    # Save registers
    addi sp, sp, -16
    sd ra, 8(sp)
    sd s0, 0(sp)

    # Check if argc >= 2
    li t0, 2
    blt a0, t0, exit   # Exit if not enough arguments

    # Get argv[1] (name)
    addi a1, a1, 8     # Skip argv[0]
    ld a0, 0(a1)       # Load name pointer

    # Call hello function
    jal ra, hello

exit:
    # Restore registers and return
    ld ra, 8(sp)
    ld s0, 0(sp)
    addi sp, sp, 16
    li a0, 0           # Return 0
    ret

hello:
    # Save registers
    addi sp, sp, -16
    sd ra, 8(sp)
    sd s0, 0(sp)

    # Save name pointer
    mv s0, a0

    # Write "Hello, "
    li a7, 64          # Syscall: write
    li a0, 1           # File descriptor: stdout
    la a1, hello_msg   # Message pointer
    li a2, 7           # Message length
    ecall

    # Get name length using strlen
    mv a0, s0          # Name pointer
    jal ra, strlen     # Call strlen
    mv a2, a0          # Length in a2

    # Write name
    li a7, 64          # Syscall: write
    li a0, 1           # File descriptor: stdout
    mv a1, s0          # Name pointer
    ecall

    # Write newline
    li a7, 64          # Syscall: write
    li a0, 1           # File descriptor: stdout
    la a1, newline     # Newline pointer
    li a2, 1           # Newline length
    ecall

    # Restore registers
    ld ra, 8(sp)
    ld s0, 0(sp)
    addi sp, sp, 16
    ret

.section .data
hello_msg: .string "Hello, "
newline: .string "\n"

# Declare external libc function
.extern strlen

Memory Management #

• Virtual Memory: Address translation, page tables, TLB
• Memory Allocation: Implementation of malloc/free
  • Free list management
  • Fragmentation handling
  • Optimization techniques (buddy system, segregated lists)
• Garbage Collection: Mark-and-sweep, reference counting
• Memory Mapping: Using mmap for file I/O and memory allocation

Process Management #

• Process Creation: fork/exec pattern
• Process Communication: Pipes, shared memory
• Threads: POSIX threads, thread creation and synchronization
• Concurrency Issues: Data races, deadlocks
• Synchronization Primitives: Mutexes, semaphores, condition variables

File Systems #

• File System Basics: Inodes, directories, links
• File System Implementations: FAT, ext2/3/4, modern CoW systems
• FUSE: Implementing custom filesystems in userspace
• I/O: System calls for file operations (open, read, write, close)

Advanced Topics #

• Virtual Machines: Hypervisors, containers
• Security: Authentication, access control, exploit prevention
• Concurrency Models: Message passing, immutability, transactional memory
• Modern Storage Systems: SSDs, RAID, ZFS, BTRFS

Major Projects and Assignments #

Throughout the semester, we implemented several significant components:

1. Assembly Programming: Writing and understanding low-level code
2. Memory Allocator: Building an efficient malloc/free implementation
3. Shell Interpreter: Process creation and management
4. FUSE Filesystem: Implementing a custom filesystem in userspace

Key Takeaways #

The Role of the Operating System #

• Providing abstractions for hardware resources
• Managing shared resources between multiple processes
• Ensuring security and isolation between processes
• Providing services through system calls

Systems Programming Principles #

• Understanding the tradeoffs between efficiency and abstraction
• Managing resources explicitly (memory, file handles)
• Dealing with concurrency and synchronization
• Defensive programming to handle edge cases

Hardware-Software Interface #

• How the CPU interacts with memory and devices
• The role of interrupts and system calls
• Virtual memory translation and caching
• Storage device characteristics and their impact on system design

Looking Forward #

The concepts you’ve learned in this course provide a foundation for:

• Systems programming and development
• Performance optimization
• Embedded systems
• Distributed systems
• Cloud infrastructure
• Security analysis and implementation

Final Thoughts #

Operating systems represent the critical layer between hardware and applications. Understanding how they work gives you powerful insights into computing systems as a whole. The principles we’ve covered—resource management, concurrency, abstraction, and efficiency—apply broadly across computer science.

As computing continues to evolve with new hardware architectures, distributed systems, and security challenges, the fundamental concepts of operating systems remain relevant. Whether you’re developing applications, working on systems software, or designing new computing platforms, the knowledge from this course will serve as an essential foundation.

Thank you for your participation and hard work this semester!