SubjectsSubjects(version: 996)
Course, academic year 2026/2027
   
Operating Systems - NSWI200
Title: Operační systémy
Form of teaching: lecture+practicals
Guaranteed by: Department of Distributed and Dependable Systems (32-KDSS)
Faculty: Faculty of Mathematics and Physics
Actual: from 2026
Duration in semesters: 1
Semester: winter
E-Credits: 5
Hours per week, examination: winter s.:2/2, MC [HT]
Capacity: unlimited
Maximum number of enrolled students: unlimited
Min. number of students: unlimited
4EU+: no
Virtual mobility / capacity: no
State of the course: taught
Language: Czech, English
Teaching methods: full-time
Additional information: https://d3s.mff.cuni.cz/t/nswi200
Repeated enrollment: 2 / 2 / 2 / 2
Guarantor: prof. Ing. Petr Tůma, Dr.
Teacher(s): doc. Ing. Lubomír Bulej, Ph.D.
PhDr. Viktor Fuglík, Ph.D.
Mgr. Vojtěch Horký, Ph.D.
prof. Ing. Petr Tůma, Dr.
Class: Informatika Mgr. - Softwarové systémy
Classification: Informatics > Software Engineering
Incompatibility : NSWI004, NSWX004
Interchangeability : NSWI004, NSWX004
Is co-requisite for: NSWI199
Is incompatible with: NSWI004
Is interchangeable with: NSWI004
Annotation -
The course provides information on the operating system architecture and the features of process management, memory management, device drivers, file systems, networking, security. All features are shown on contemporary operating systems, implementation of selected features is practiced while creating an educational operating system. Note for combined study programs: the course requires activity during semester.
Last update: Hnětynka Petr, doc. RNDr., Ph.D. (04.01.2023)
Aim of the course -
  • Introduce operating system abstractions, architectures and mechanisms for resource management and protection.
  • Explain processes, threads, context switching and scheduling mechanics.
  • Explain heap organization and garbage collection, analyze the associated overheads.
  • Connect binary program representation and in memory data structure organization to process execution.
  • Apply techniques for concurrent programming using atomics and synchronization primitives, with awareness of memory ordering.
  • Explain virtual memory mechanisms, paging applications and replacement policies across the memory hierarchy.
  • Connect interrupt processing, hardware and system interfaces to device driver organization and device operation.
  • Explain storage layout techniques used to implement file system abstractions.
  • Develop practical skills in inspecting, implementing and debugging system code.
Last update: Tůma Petr, prof. Ing., Dr. (30.10.2026)
Course completion requirements -

The course includes tests and practical assignments, graded on a point scale. The grading reflects activity and for practical assignments correctness and additional evaluation criteria (documentation, design, style). Course credit requires solving the basic variant of all practical assignments and presenting the solution, the overall grade is determined from the point total. All practical assignments may be revised an unlimited number of times after the initial submission, up until the final assignment assessment deadline.

Last update: Tůma Petr, prof. Ing., Dr. (31.08.2026)
Literature -

Materials and Main Textbook

  • Operating Systems Self-Study Modules. https://d3s.mff.cuni.cz/teaching/operating-systems
  • Arpaci-Dusseau et al.: Operating Systems: Three Easy Pieces. http://www.ostep.org

Additional Textbooks

  • Anderson et al.: Operating Systems Principles and Practice
  • Silberschatz et al.: Operating System Concepts
  • Tanenbaum et al.: Modern Operating Systems

References

  • RISC-V Instruction Set Manual Volume I: Unprivileged ISA
  • RISC-V Instruction Set Manual Volume II: Privileged Architecture
  • Intel 64 and IA-32 Architectures Software Developer's Manual

Last update: Tůma Petr, prof. Ing., Dr. (30.10.2026)
Syllabus -

1. Operating system architecture - resource management, abstractions, architectures, privileged operations. Machine program representation.

2. Process code and stack - process memory layout, linking, relocation, addressing, stack frames.

3. Explicit heap management - interfaces, metadata, allocation strategies, fragmentation and allocation overheads.

4. Garbage collected heaps - reachability, roots, reference counting and tracing, generations, concurrency and overheads.

5. Processes and threads - process and thread context, context switching, scheduling goals and strategies.

6. Synchronization principles - races with interleaving semantics, critical sections, atomicity, locks.

7. Synchronization tools - lock construction, semaphores and condition variables.

8. Memory models - memory access optimizations, cache coherence, ordering.

9. Paging principles - address space isolation, virtual and physical addresses, page tables, address translation, handling faults.

10. Paging algorithms and applications - demand paging, file mappings, shared memory, copy on write, evaluation of replacement policies.

11. System calls and interrupts - kernel entry, conventions, device controller registers, interrupt handling and direct memory access.

12. Device interfaces and drivers - driver architecture, request queues, deferred interrupt service, hardware and kernel facing interfaces.

13. File systems - interfaces, metadata and open file state, FAT and UNIX style storage layouts, access costs and consistency risks.

Last update: Tůma Petr, prof. Ing., Dr. (30.10.2026)
Learning outcomes -

On successful completion of the course, students will be able to:

  • Explain operating system abstractions, describe common system architectures and identify privileged operations.
  • Inspect system code, explain process memory layout, linking and relocation.
  • Describe stack frames and explain stack variable addressing.
  • Implement a free-list heap allocator, compare allocation strategies and estimate fragmentation and allocation overheads.
  • Determine reachability, explain tracing garbage collection techniques and estimate garbage collection overheads.
  • Distinguish process and thread state, explain context switch code, and assess and choose scheduling strategies.
  • Construct execution interleavings exposing races, protect shared state with locks and implement locks.
  • Use condition variables and semaphores for thread coordination and resource access.
  • Identify data races and repair them using synchronization tools.
  • Explain address translations using hierarchical page tables.
  • Describe page fault handling and explain protection and translation caching.
  • Explain demand paging and copy on write, and compare replacement policies across the memory hierarchy.
  • Trace system call and interrupt handling, and implement a simple interrupt driven driver with a request queue.
  • Use file system interfaces, explain basic file system layouts, estimate access costs and illustrate consistency risks.
Last update: Tůma Petr, prof. Ing., Dr. (30.10.2026)
 
Charles University | Information system of Charles University | http://www.cuni.cz/UKEN-329.html