| Module Code | CSU23016 |
| Module Name | Concurrent Systems and Operating Systems |
| ECTS Weighting [1] | 5 ECTS |
| Semester Taught | Semester 2 |
| Module Coordinator/s | Alessio Ferrari |
Module Learning Outcomes
On successful completion of this module, students will be able to:
- Explain the role and structure of operating systems, including kernel architectures, user and kernel modes, interrupts and system calls;
- Analyse process and thread management, context switching and processor scheduling, including basic considerations for multicore systems;
- Develop C programs that use operating system interfaces for process creation, execution and inter-process communication;
- Identify race conditions and deadlocks, and apply appropriate synchronisation techniques to concurrent programs;
- Explain virtual memory mechanisms and analyse address translation, page tables and page replacement policies;
- Describe and compare mechanisms used for device I/O, persistent storage, file system organisation and crash recovery;
- Explain operating system protection and isolation mechanisms, and distinguish virtual machines from containers.
Module Content
This module introduces the principles and implementation of operating systems. It examines how operating systems manage processors, memory and persistent storage, and how they provide applications with controlled access to shared resources. Students explore the relationship between operating system abstractions, hardware support and implementation mechanisms, with particular attention to correctness, performance and isolation.
The module combines the study of operating system algorithms and policies with practical use of system calls and concurrency facilities in C. Selected examples from a teaching operating system illustrate how core mechanisms are implemented. The module also introduces protection, security, virtual machines and containers.
Operating system foundations: operating system services and architectures; user and kernel modes; system calls; traps and interrupts; protection boundaries.
Processes and processor management: process abstractions and states; process creation and execution; threads; context switching; scheduling policies and performance metrics; basic multicore scheduling and processor affinity; inter-process communication using pipes and shared memory.
Memory management: address spaces; memory allocation; address translation; segmentation; paging; page tables; translation lookaside buffers; demand paging; page replacement.
Concurrency and synchronisation: shared state; race conditions; critical sections; locks and atomic operations; condition variables; semaphores; producer–consumer coordination; deadlock conditions, prevention and avoidance principles.
I/O and persistence: device interfaces; interrupts and direct memory access; storage devices; file descriptors and file operations; directories and inodes; file system layout and allocation; caching; crash consistency and journaling.
Security and virtualisation: access control and least privilege; process and memory isolation; virtual machines and hypervisors; containers, namespaces and resource control; basic security implications of shared resources.
Teaching and Learning Methods
The module is delivered through lectures and three practical assignments. Lectures introduce operating system abstractions, algorithms and implementation mechanisms, using worked examples and selected C and teaching-kernel code.
Assignments reinforce understanding through scheduling exercises, address translation and page replacement problems, concurrency analysis and practical programming support. The assignments cover process programming and inter-process communication, virtual memory, and synchronisation. Assignments provide opportunities for formative feedback and preparation for the final examination.
Assessment Details
This module is assessed through three practical assignments, each worth 10%, and a final examination worth 70%.
| Assessment Component | Brief Description | Learning Outcomes Addressed | % of Total | Week Set | Week Due |
| Assignment 1 | Process creation, execution, waiting and pipes, and system call behaviour | LO1, LO3 | 10% | Week 2 | Week 4 |
| Assignment 2 | Virtual memory exercises, address translation and page replacement | LO5 | 10% | Week 5 | Week 8 |
| Assignment 3 | Thread programming using synchronisation primitives, with analysis of race conditions and deadlock risks | LO4 | 10% | Week 9 | Week 11 |
| Final Examination | Problems, code analysis, and questions covering the module content | LO1–LO7 | 70% | Examination period | Examination period |
Re-assessment by examination (100%).
Contact Hours and Indicative Student Workload
| Contact Hours (scheduled hours per student over full module), broken down by: | 33 hours |
| Lecture | 22 hours |
| Laboratory | 11 hours |
| Independent Study (outside scheduled contact hours), broken down by: | 72 hours |
| Preparation for classes and review of material, including preparation for examination | 36 hours |
| Completion of assessments, including examination | 36 hours |
| Total Hours | 105 hours |
Recommended Reading List
- Arpaci-Dusseau, R. H. and Arpaci-Dusseau, A. C. Operating Systems: Three Easy Pieces. Selected chapters. https://pages.cs.wisc.edu/~remzi/OSTEP/
- Cox, R., Kaashoek, M. F. and Morris, R. xv6: A Simple, Unix-like Teaching Operating System. Selected sections from the RISC-V edition. https://pdos.csail.mit.edu/6.828/2025/xv6.html
- Silberschatz, A., Galvin, P. B. and Gagne, G. Operating System Concepts. 10th edition. Wiley. https://www.os-book.com/OS10/
These are complementary resources: OSTEP supplies the conceptual framework, xv6 provides a teaching implementation, and Operating System Concepts offers broader reference material.
Module Pre-requisites
Prerequisite modules:
- SF Computer Science: either CSU22014 (Systems Programming, Semester 1) or CSU22061 (Intermediate Programming, Semester 1)
- JS Engineering: CSU11E03 (Computer Engineering I, Semester 2) and CSU22E03 (Computer Engineering, Semester 1)
Other/alternative non-module prerequisites:
Memory managementFamiliarity and experience with C programming, including pointers, structures and dynamic memory allocation, is required. Basic knowledge of computer architecture, including registers, memory and instruction execution, is assumed.
Module Co-requisites
N/A