Ateneo - UPO

The integrated course presents the principles, mechanisms and main design choices underlying modern operating systems. The first module covers the general architecture of an operating system, process and thread management, synchronization, concurrent programming, deadlocks, memory management and the use of Unix system calls. The second module focuses on the input/output subsystem, storage devices, disk scheduling, RAID systems, device drivers, and file-system design and implementation.

Theoretical topics are complemented by exercises, scenario analysis, programming activities and comparisons between alternative solutions, with particular attention to correctness, performance, reliability, complexity and resource usage.

Main textbook: Andrew S. Tanenbaum, Herbert Bos, Modern Operating Systems: Global Edition, 5th edition, Pearson, 2023, ISBN 9781292459660.
Italian edition: Andrew S. Tanenbaum, Herbert Bos, I moderni sistemi operativi, 5th edition, Pearson, 2023, ISBN 9788891931955.

The textbook supports the systematic study of the principles, architectures, mechanisms and main design solutions covered in both modules.

Additional materials are available on the DIR platform, including slides, examples, code fragments, exercises, laboratory activities and sample examination papers. The textbook and theoretical materials are especially suitable for preparing knowledge and understanding questions, whereas exercises, programming examples and sample examinations are particularly useful for preparing application-oriented questions

The integrated course contributes to the educational objectives of the Degree Programme in Computer Science by providing knowledge and methodological tools for understanding, analysing, using and designing system-software components.

By the end of the course, students will be able to:

1. describe and relate the general architecture of an operating system and the mechanisms used to manage processes, threads, memory, input/output, storage devices and files;
2. use and analyse Unix system calls and library primitives for creating, coordinating and synchronizing processes and threads;
3. analyse the requirements of a realistic scenario and identify suitable mechanisms, policies, algorithms and data structures;
4. apply methods and techniques to solve problems concerning concurrency, synchronization, deadlocks, memory management, disk scheduling, RAID organizations, file allocation and free-space management;
5. compare alternative solutions in terms of correctness, performance, reliability, complexity and resource usage;
6. justify design choices and communicate them using appropriate technical terminology.

The integrated course awards 12 ECTS credits and consists of two 6-credit modules. Learning activities include lectures, interactive teaching, exercises, laboratory work and individual study.

To benefit fully from the course, students are expected to possess the knowledge and skills acquired in Computer Architecture and Programming 1 and 2.

In particular, students should be able to:

- represent data and addresses in binary and hexadecimal form;
- describe the operation of CPUs, main memory, buses, interrupts and direct memory access;
- understand the role of the instruction set, privilege levels and hardware-software interaction;
- develop, read and analyse programs in the languages used in previous programming courses;
- understand fundamental data structures, pointers, dynamic memory management and code modularization;
- read simple code fragments and pseudocode concerning low-level components.

To undertake the second module, students must also possess the knowledge and skills developed in the first module, especially concerning processes, threads, concurrency, synchronization, memory management and system calls.

Any formal prerequisites are those established by the Degree Programme regulation.

The course combines lectures and interactive learning activities over the two semesters.

Lectures present fundamental concepts, architectures, data structures, algorithms and the main design alternatives. Explanations are supported by examples, diagrams, code fragments and comparisons between different implementation solutions.

Interactive activities include:

- quantitative and methodological exercises discussed in class;
- programming exercises based on Unix system calls and library primitives;
- laboratory activities concerning the observation and use of operating-system mechanisms;
- analysis of scenarios requiring students to identify requirements, state assumptions and select design solutions;
- theoretical and application-oriented questions similar to those used in the examinations;
- discussions in which students are encouraged to justify their choices and critically assess alternative solutions.

Materials covering the entire syllabus are available on the DIR platform and can also be used by non-attending students. Activities are designed to develop knowledge and understanding, application skills, independent judgement, communication skills and autonomous learning abilities.

All information required to prepare for the examinations is provided in this syllabus, in the syllabi of the two modules and in the materials available on the DIR platform. Organizational information concerning examination sessions is published through the institutional channels.

Students with disabilities, Specific Learning Disorders or Special Educational Needs may request dedicated services and support by contacting the University Student Services Office and consulting the relevant University webpage:
https://uniupo.it/it/servizi/servizi-studentesse-e-studenti-condizione-di-disabilit%C3%A0-e-dsa

After contacting the relevant University office, students may contact the lecturers responsible for the modules to arrange the practical application of the approved measures concerning teaching activities and examination procedures.

Learning is assessed through two separate examinations, one for each module, conducted according to the procedures described in the respective module syllabi. Both examinations must be passed with a mark of at least 18/30.

The examinations include theoretical, methodological and application-oriented questions. The first-module examination may also include programming exercises based on Unix system calls and library primitives. The second-module examination includes questions and exercises concerning the input/output subsystem, storage devices, device drivers and file systems.

Taken together, the examinations assess:

- knowledge and understanding: defining concepts, describing architectures, structures, algorithms and mechanisms, and relating the different components of an operating system;
- applying knowledge and understanding: using system calls, analysing code, performing calculations, applying algorithms and procedures, and solving design problems;
- making judgements: identifying relevant information, stating assumptions, comparing alternatives and justifying choices;
- communication skills: organizing answers clearly, rigorously and consistently and using technical terminology correctly;
- learning skills: integrating concepts from different parts of the syllabus and applying them to non-routine questions.

Assessment criteria for each module

Each module is graded on a scale of 30 and the assessment considers:

1. correctness of the knowledge used;
2. completeness of the answer in relation to the question;
3. correctness of procedures, calculations, code and application of methods;
4. ability to justify choices and compare alternative solutions;
5. clarity, logical organization and appropriate use of specialist terminology.

Grade bands

- 18-20/30: essential achievement of the expected learning outcomes; generally correct basic knowledge, application of fundamental procedures with no major errors, and sufficient justification and exposition.
- 21-23/30: satisfactory achievement; reasonably complete knowledge, generally correct application, adequate connections and terminology.
- 24-26/30: good achievement; sound knowledge, correct procedures, clear justification and ability to compare the main alternatives.
- 27-29/30: very good achievement; in-depth and integrated knowledge, autonomous analysis, and a high level of methodological and expository accuracy.
- 30/30 and 30 with honours: excellent achievement; complete and critical command of the subject, ability to address complex or non-routine problems autonomously, and rigorous, precise and particularly clear argumentation. Honours are awarded when the examination demonstrates not only full correctness but also an especially high level of depth, autonomy and quality of exposition.

Fragmentary knowledge, inability to apply fundamental procedures or major conceptual errors result in a failing grade.

Calculation of the final grade for the integrated course

The final grade is awarded after both modules have been passed. It is calculated as the arithmetic mean of the grades obtained in the two modules. When the mean is not an integer, it is rounded to the nearest integer according to standard rounding rules: down when the decimal part is below 0.5 and up when it is equal to or above 0.5.

Honours in the final grade are awarded jointly by the lecturers responsible for the two modules when both examinations show an excellent level of achievement and the overall grade is 30/30 after rounding.

For knowledge and understanding questions, students should study the textbook systematically and use the theoretical materials available on the DIR platform. Exercises, programming examples, laboratory activities and (possibly) sample examinations available on the same platform are particularly useful for preparing application-oriented questions.

MODULE 1 – OPERATING SYSTEMS 1

1. Introduction and operating-system architecture
- Role and purposes of an operating system.
- Architecture of an operating system for multi-user computers.
- The operating-system kernel.
- Interaction among applications, the operating system and hardware.

2. Processes and threads
- Process concept and process states.
- Process creation, termination and management.
- Thread concept and multithreading models.
- Scheduling and main management criteria.

3. Synchronization and concurrent programming
- Concurrency and race conditions.
- Critical sections and correctness requirements.
- Synchronization primitives and mechanisms.
- Process and thread synchronization.
- Classical concurrent-programming problems.

4. Deadlocks
- Necessary conditions for deadlock.
- Prevention, avoidance, detection and recovery.
- Scenario analysis and comparison of strategies.

5. Memory management
- Address spaces and relocation.
- Memory allocation.
- Paging and segmentation.
- Virtual memory and main management policies.

6. Processes and threads in Unix
- General use of Unix system calls.
- System calls for process management.
- Thread-management libraries.
- System calls and library functions for synchronization.
- Analysis and development of simple concurrent programs.

MODULE 2 – OPERATING SYSTEMS 2

7. Input/output subsystem architecture
- Role and organization of the I/O subsystem.
- Application I/O interface and system calls.
- Kernel I/O subsystem.
- Interrupts, polling, buffering, caching, spooling and error management.
- Criteria for comparing alternative design solutions.

8. Storage devices and disk management
- Structure and characteristics of storage devices.
- Logical and physical disk organization.
- Access times and performance metrics.
- Disk-scheduling policies and their evaluation.
- Disk-drive management.
- RAID systems: main levels, reliability, capacity and performance.

9. Device drivers
- Role and structure of a device driver.
- Interaction among drivers, kernel, controllers and devices.
- Management of requests, interrupts and errors.
- Driver organization in the xv6 operating system.
- Analysis of the xv6 IDE driver as a case study.

10. File-system concepts and architecture
- File concept and file attributes.
- File operations and access methods.
- Directories, naming hierarchies and disk structure.
- File sharing and protection mechanisms.
- Layered file-system structure.

11. File-system implementation
- Implementation of files and directories.
- Contiguous, linked and indexed allocation methods.
- Metadata structures and translation of logical addresses into physical addresses.
- Free-space management.
- Efficiency and performance.
- Consistency, reliability and crash recovery.
- Backup and restore.

12. Application activities and comparison of solutions
- Guided and autonomous solution of quantitative, algorithmic and design exercises.
- Requirement analysis and justified selection of mechanisms and policies.
- Comparison of alternatives in terms of correctness, performance, reliability, complexity and resource usage.
- Discussion of questions similar to those used in the examinations.

Integration of the gender dimension

Throughout the course, attention is drawn to the use of inclusive technical language and to the impact that system-software design choices may have on accessibility and the inclusion of different categories of users.

Knowledge and understanding

By the end of the integrated course, students will know and understand:

- the role, architecture and main components of an operating system;
- models and mechanisms for managing processes, threads, concurrency, synchronization and deadlocks;
- the principles and policies of main-memory and virtual-memory management;
- the role and use of the main Unix system calls and library primitives;
- the architecture of the input/output subsystem and the interaction among applications, kernels, controllers and devices;
- the main performance parameters of storage devices and disk-scheduling policies;
- the structure, responsibilities and operation of device drivers;
- the principles, data structures and algorithms used in file-system design and implementation;
- the advantages, limitations and application domains of the main alternative solutions discussed in the course.

Applying knowledge and understanding

Students will be able to:

- analyse and develop simple programs using processes, threads, system calls and synchronization primitives;
- identify race conditions, synchronization problems and deadlock situations and select appropriate strategies;
- apply memory-management algorithms and policies;
- solve exercises involving access times, disk scheduling, RAID organizations, file allocation and free-space management;
- analyse realistic scenarios and select solutions consistent with the assigned requirements;
- describe the behaviour of operating-system components through diagrams, calculations, code, pseudocode or technical argumentation;
- compare solutions in terms of correctness, performance, reliability, complexity and resource usage.

Making judgements

Students will be able to identify relevant information in a problem, state explicit assumptions, critically assess alternative solutions and justify the choice considered most appropriate.

Communication skills

Students will be able to present concepts, procedures, code and design choices in writing in a clear, logically organized and technically correct manner, using the specialist terminology of the discipline.

Learning skills

Students will be able to use the textbook, technical documentation and teaching materials to study autonomously operating-system mechanisms, components and solutions not directly examined during the course.

Minimum level required to pass

To achieve the minimum passing level, students must demonstrate knowledge of the fundamental concepts of all main areas of the syllabus, correctly apply standard procedures, understand and use simple system calls, solve basic exercises, provide essential justification for their choices and present their answers using understandable and substantially correct terminology. The minimum level must be achieved separately in both modules.

Advanced level

An advanced level requires broad and integrated knowledge, the ability to connect different operating-system components, independently analyse code and scenarios, address problems that are not identical to those previously practised, critically compare alternative solutions and produce rigorous, complete and well-organized answers.