cmsc 412 operating systems fall 2002

University of Maryland, CMSC 412, Fall 20021

CMSC 412Operating Systems

Fall 2002

Liviu Iftode

[email protected]


Course overview

Goals

Understand how an operating system works as a mediator between the computer architecture and user programs Learn how OS concepts are implemented in a real operating system Introduce to systems programming Learn about performance evaluation Learn about current trends in OS research


OS Learning

OS Concepts

Real OS OS Programming

OS Implementation (lectures, textbooks)

recitations

homeworks

project

(Unix/Linux textbooks) (man pages)

(source code, project doc)


Course Timeline

Lecture

Lab

Homework

Project

W

Apply A

HW A Due

W

W

Project AB Due

W

Apply B

W

Apply C

Tu Th

Concept A

Tu Th

Concept B

Tu Th

Concept C

HW BC Due

W


Suggested Approach

Read the assigned chapter from the textbook before the lecture to understand the basic idea and become familiar with the terminology

Attend the recitation Start homeworks and project right away, systems

programming is not easy ! Ask questions during lecture, recitation. Use the mailing list/newsgroup for discussions, do not be

afraid to answer a question posted by your colleague even if you are not sure. This is a way to validate your understanding of the material. Do not forget, questions and discussions are not graded !


Course Outline

Processes and process management Threads and thread programming Synchronization and Deadlock Memory management and Virtual Memory CPU Scheduling File systems and I/O Management Networking and Distributed Systems Security


Course requirements

Prerequisites

computer architecture good programming skills (C!!, C++, Java)

Expected work

substantial readings (textbooks and papers) challenging project extended over the entire

semester homeworks (require programming) midterm and final exams


Work Evaluation

midterm exam 25% homework 25% project 25% final exam 25%


HomeworksGoals

Deepen the understanding of OS concepts Develop systems programming skills: virtual memory, threads, synchronization, sockets Learn to design, implement, debug and evaluate the performance of an OS-bound program

Structure

4-5 homeworks Both theoretical and C-programming problems


Project

Goals

learn to design, implement and evaluate basic OS mechanisms and policies

Structure

individual project multiple phases project report for each phase


Textbooks

Stallings Operating Systems. Internals and Design Principles, 4th Edition, Prentice-Hall, 2001.

Silberschatz, Galvin and Gagne, Operating System Concepts, 6th Edition, John Wiley & Sons, 2001.

Papers will be made available on the course homepage


Logistics

TAs: Chunyuan Liao Iulian Neamtiu (to be confirmed)

Course homepage:

http://www.cs.umd.edu/~iftode/cs412/cs412syllabus.htm Preliminary schedule and course notes are already

available for the entire semester but they may be updated before each class.

Homeworks every other week. A project phase every other week. A mailing list/newsgroup will be announced shortly.


What is an operating system

a software layer between the hardware and the application programs/users which provides a virtual machine interface: easy and safe

a resource manager that allows programs/users to share the hardware resources: fair and efficient

hardware

operating system

application (user)


How does an OS work

receives requests from the application: system calls satisfies the requests: may issue commands to hardware handles hardware interrupts: may upcall the application OS complexity: synchronous calls + asynchronous events

hardware

OS

application (user) system calls upcalls

commands interrupts

hardware independent

hardware dependent


Files

traditional approach: OS does disk block allocation and caching (buffer cache) , disk operation scheduling and replacement in the buffer cache

new approaches: application-controlled cache replacement, log-based allocation (makes writes fast)

hardware: disk

operating system: files, directories

A file is a storage abstraction

application/user: copy file1 file2 naming, protection,operations on files

operations on disk blocks...


Traditional file system

application: read/write files

OS: translate file to disk blocks

...buffer cache ...maintains

controls disk accesses: read/write blocks

hardware:


Mechanism vs Policy

mechanism: data structures and operations that implement the abstraction (e.g. the buffer cache)

policy: the procedure that guides the selection of a certain course of action from among alternatives (e.g. the replacement policy for the buffer cache)

traditional OS is rigid: mechanism together with policy

hardware

operating system: mechanism+policy

application (user)


traditional OS cannot provide the best policy in all cases new OS approaches separate mechanisms from

policies:

OS provides the mechanism + some policy applications contribute to the policy

flexibility+efficiency require new OS structures and/or new OS interfaces

Mechanism-policy split


Application-controlled caching

application: read/write files replacement policy

OS: translate file to disk blocks

...buffer cache ...maintains

controls disk accesses: read/write blocks

hardware:


Processes

traditional approach: OS switches processes on the processor (process scheduling), provides inter-process communication and handles exceptions

new approaches: application-controlled scheduling, reservation-based scheduling, agile applications

hardware: processor

operating system: processes

A process is a processor abstraction

user: run application create, kill processes,inter-process comm

context switch


Traditional approach

OS mediates inter-process communication (IPC) OS schedules processes on the processor application provides hints: priorities

processor

OS

processes

IPC

active


Hierarchical scheduling

OS schedules schedulers which schedule dependent processes

processor

OS

processes schedulers


Virtual memory

traditional approach: OS provides a sufficiently large virtual address space for each running application, does memory allocation and replacement and may ensure protection

new approaches: external memory management, huge (64-bit) address space, global memory

hardware: physical memory

operating system: virtual memory

Virtual memory is a memory abstraction

application: address spacevirtual addresses

physical addresses


VM: mechanism and policy

processes can run being partially loaded in memory illusion of more memory than physically available: swapping processes can share physical memory if permitted replacement policy can be exposed to the application

physical memory:

v-to-p memory mappings

processes:

virtual address spacesp1 p2


Communication

traditional approach: OS provides naming schemes, reliable transport of messages, packet routing to destination

new approaches: zero-copy protocols, active messages, memory-mapped communication

hardware: network interface

operating system: TCP/IP protocols

Message passing is a communication abstraction

application: socketsnaming, messages

network packets


Traditional OS structure

monolithic/layered systems one/N layers all executed in “kernel-mode” good performance but rigid

OS kernel

hardware

userprocess

filesystem

memorysystem

usersystem calls


Micro-kernel OS

micro-kernel

hardware

clientprocess

fileserver

memoryserver

IPC

user mode

client-server model, IPC between clients and servers the micro-kernel provides protected communication OS functions implemented as user-level servers flexible but efficiency is the problem easy to extend for distributed systems


Extensible OS kernel

extensible kernel

hardware

process

defaultmemoryservice

user modeprocess

mymemoryservice

user processes can load customized OS services into the kernel

good performance but protection and scalability become problems


Virtual Machines

old concept which is heavily revived today

the real hardware in “cloned” in several identical virtual machines

OS functionality built on top of the virtual machine

hardware

user

exokernel

allocate resourceOS on virtual machine


Computer System Processor: performs data processing Main memory: stores both data and programs, typically volatile Disks: secondary memory devices which provide persistent storage Network interfaces: inter-machine communication Buses: intra-machine communication

memory bus (processor-memory) I/O bus (disks, network interfaces, other I/O

devices, memory-bus)


Basic computer structure

CPU Memory

memory bus

I/O bus

disk Net interface


Memory caches motivated by the mismatch between processor and memory speed closer to the processor than the main memory smaller and faster than the main memory act as “attraction memory”: contains the value of main memory locations which were recently accessed (temporal locality) transfer between caches and main memory is performed in units called cache blocks/lines caches contain also the value of memory locations which are close to locations which were recently accessed (spatial locality)


Cache design issues

cache size and cache block size mapping: physical/virtual caches, associativity replacement algorithm: LRU write policy: write through/write back

cpu

cache

mainmemory

word transfer

block transfer


Memory Hierarchy

cpu

cache

main memory

word transfer

block transfer

disks

page transfer

decrease cost per bit decrease frequency of access increase capacity increase access time increase size of transfer unit


Data transfer on the bus

CPUMemory

memory bus

I/O bus

disk Net interface

cache

cache-memory: cache misses, write-through/write-back memory-disk: swapping, paging, file accesses memory-Network Interface : packet send/receive I/O devices to the processor: interrupts


Direct Memory Access (DMA)

bulk data transfer between memory and an I/O device (disk, network interface) initiated by the processor

address of the I/O device starting location in memory number of bytes direction of transfer (read/write from/to

memory) processor interrupted when the operation completes bus arbitration between cache-memory and DMA

transfers memory cache must be consistent with DMA


Multiprocessors

CPUMemory

memory bus

I/O bus

disk Net interface

cache

simple scheme: more than one processor on the same bus memory is shared among processors-- cache consistency bus contention increases -- does not scale alternative (non-bus) system interconnect -- expensive single-image operating systems

CPU

cache


Multicomputers

network of computers: “share-nothing” -- cheap communication through message-passing: difficult to program challenge: build efficient shared memory abstraction in software each system runs its own operating system

CPUMemory

memory bus

I/O bus

disk Net interface

cache

CPUMemory

memory bus

I/O bus

diskNet interface

cache

network

cmsc 412 operating systems fall 2002

Documents