Operating Systems - Introduction
This page gives a general introduction to the course for those
deciding whether to take it.
SUMMARY
This course is about modern computers 'under the hood' -- how do we get them to
do all the things that have to happen behind the scenes in order to get any
useful work done up front.
The course is delivered via lectures and slides. My
aim in lectures is not to impart large quantities of facts - I expect
you to read round the subject outside lectures - but rather to convey
the basic understanding required to do reading. Thus lectures are
monologues (and sometimes dialogues) woven around the slides.
The practical exercise is not really intended to connect
particularly strongly with the lectures. Rather, I see the practical
as an opportunity to get you to do things that any Computer Scientist
ought to have done - working inside a large piece of software, using C
(even if you've never used it before), and looking at real operating
system code.
The exams are in the standard format, and aim to test understanding
rather than just recall of facts.
A few years ago, the course was felt to have a fairly high
workload. However, after adjustments to the practical, for the last
three or four years, the general student view has been that the
workload is about right.
The course is overall consistently average or slightly high in
terms of exam scores; students who engage well with the course can
and often do get 90% or more on the exam.
COURSE AIMS
- general understanding of structure of modern computers
- purpose, structure and functions of operating systems
- illustration of key OS aspects by example
COURSE OUTCOMES
Ability to:
- describe the general architecture of computers
- describe, contrast and compare differing structures for
operating systems
- understand and analyse theory and implementation of: processes,
resource control (concurrency etc.), physical and virtual
memory, scheduling, I/O and files
In addition, during the practical exercise and associated self-study,
you will:
- become familiar (if not already) with the C language, gcc
compiler, and Makefiles
- understand the high-level structure of the Linux kernel both in
concept and source code
- acquire a detailed understanding of one aspect (the scheduler)
of the Linux kernel
COURSE OUTLINE
This outline is subject to modification during the course.
- Introduction; history of computers; overview of OS
- Computer architecture (high-level view); machines viewed at
different abstraction levels
- Basic OS functions and the historical development of OSes
- Processes (1)
- Processes (2) -- threads and SMP
- Scheduling (1) -- cpu utilization and task scheduling
- Concurrency (1) -- mutual exclusion, synchronization
- Concurrency (2) -- deadlock, starvation, analysis of concurrency
- Memory (1) -- physical memory, early paging and segmentation
techniques
- Memory (2) -- modern virtual memory concepts and techniques
- I/O (1) -- low level I/O functions
- I/O (2) -- high level I/O functions and filesystems
- Case studies: one or both of: the Windows NT family; IBM's
System/390 family -- N.B. you will be expected to study Linux
during the practical exercise and in self-study.
- Other topics to be determined, e.g. security.
ASSESSMENT
The course is assessed by a written examination (75\%) and one practical
exercise (25\%).
The practical exercise will run through weeks 3--10, and will involve
understanding and modifying the Linux kernel. The final assessed
outcome is a relatively small part of the work, and will not be too
hard; most of the work will be in understanding C,
Makefiles, the structure of a real OS kernel, etc. This is
essential for real systems work!
