Advanced Operating Systems  (263‐3800‐00L) Timothy Roscoe Herbstsemester 2014

Advanced Operating Systems  (263‐3800‐00L) Timothy Roscoe Herbstsemester 2014

Advanced Operating Systems 

(263‐3800‐00L)

Timothy Roscoe

Herbstsemester 2014 http://www.systems.ethz.ch/courses/fall2014/aos

© Systems Group | Department of Computer Science | ETH Zürich

1

Course aims and goals

2

Writing real OS code

There’s a limit to how much you can learn  about an OS by reading books.

Solve common OS problems for yourself

Dealing with 

concurrency

Dealing with 

asynchrony

Tailoring code to specific 

hardware

Architecting complete 

system

of processes

3

It’s not Unix

The course avoids using a Unix‐like OS:

Gives a  broader outlook  on what an OS can be

Encourages a  critical approach  to OS designs

Better  understanding of the structure of Unix / 

Linux / Windows / Android / iOS / …

Clearer picture of  ideas (finally) appearing in  older OS designs

Or not yet…

4

What is OS research?

We’ll be working with a research OS

You’ll get a sense of how OS research is done

Read research  papers

Relate them to  implementations

How to  evaluate such ideas

See what constitutes an OS research topic

What  problems do these ideas solve?

How are they  motivated , where do they come  from?

5

Key ideas in OS research

The OS we use includes a selection of key  ideas in OS research

You get hands‐on  experience with the ideas

We’ll go through the  papers on the topic

We’ll put them into historical  context

Many are not well‐known and/or  unimplemented in the wider community

6

Motivation

7

Why teach non‐Unix OS design?

This is an interesting time for OS research:

Multicore

Heterogeneous processing

System complexity

System diversity

The basic assumptions of Unix/Windows/etc.  are being re‐evaluated. 

8

Moore’s law: the free lunch

4004

8086

286

Intel 386

Intel

Pentium

Intel

Pentium II

Intel 486

Intel

Pentium 4

Intel

Itanium 2

9

Source: table from http://download.intel.com/pressroom/kits/events/moores_law_40th/MLTimeline.pdf

The power wall

AMD Athlon 1500 processor http://www.phys.ncku.edu.tw/~htsu/humor/fry_egg.html

10

The power wall

Power dissipation = 

Capacitive load  Voltage

2

 Frequency

Increase in clock frequency 

 mean more power dissipated 

 more cooling required

Decrease in voltage reduces dynamic power but increase the static power leakage

We’ve reached the practical power limit for  cooling commodity microprocessors

Can’t increase clock frequency without expensive  cooling

11

The memory wall

10000

1000

100

10

1MHz CPU clock, 

500ns to access  memory in 1985

1

CPU

Memory

12

The ILP wall

ILP = “Instruction level parallelism”

Implicit parallelism between instructions in 1 thread

Processor can re‐order and pipeline instructions, split  them into microinstructions, do aggressive branch  prediction etc.

Requires hardware safeguards to prevent potential errors  from out‐of‐order execution

Increases execution unit complexity and associated  power consumption

Diminishing returns

Serial performance acceleration using ILP has stalled

13

End of the road  for serial hardware

Power wall + ILP wall + memory wall 

= brick wall

Power wall  can’t clock processors any faster

Memory wall  for many workloads  performance dominated by memory access times

ILP wall  can’t keep functional units busy while  waiting for memory accesses

There is also a complexity wall, but chip  designers don’t like to talk about it…

14

Multicore processors

Multiple processor cores per chip

This is the future (and present) of computing

Most multicore chips so far are shared  memory multiprocessors (SMP)

Single physical address space shared by all  processors

Communication between processors happens  through shared variables in memory

Hardware typically provides cache coherence

15

Implications for software

The things that would have  used this “lost” perf must  now be written to use 

Historical 1‐thread perf gains via improved clock  rate and transistors used  but delivered as  additional cores and  accelerators

Year

16

And the others?

Trends towards:

Heterogeneous processing

Different types of core on a chip

System  complexity

Devices, interconnects, memory system

System  diversity

No two systems are alike

Very different performance tradeoffs

We’ll see this all very shortly…

17

Structure and Logistics

18

Assumptions

C Programming

Practical labs are mostly in C. 

You will be writing an OS. 

Computer Architecture

Need to know about hardware, registers, DMA, 

You will be writing a device driver, pager, etc.

Command line development

– gcc, emacs/vi, make, etc. 

Debugging facilities are primitive!

19

ETH courses

(or similar elsewhere)

Parallel programming

Concurrency, locks, synchronization, …

Digital Design

Basics of hardware

Computer Architecture and Systems Programming

C and assembly

Caches, devices, I/O, virtual memory, traps, …

Networks and Operating Systems

Memory management, protection, scheduling, device drivers…

Systembau: alternative/complementary

Our emphasis: microkernels (practical) and advanced/research OS  topics (theoretical)

20

Structure of the course

Project

Lectures

Readings

21

Lectures

Cover topics related to current project milestone.

Key ideas

History / influences

Lectures

Explanation / elaboration of readings

Also Q&A if required

Project

Readings

22

Readings

Project

Most of our material is not (or  insufficiently) covered in textbooks

Lectures

Readings will be research papers

Seminal papers in the field

Background to the concepts you will deal with in  the weeks’ project milestone

Context for the material covered in the lecture

Readings

23

Project

Build (most of) an OS

– based on Barrelfish research OS

PandaBoard hardware

Lectures

Project

Readings

24

Project Milestones

Project

Demonstrate new functionality

Important to keep up with the schedule!

Milestone 0: this week

Familiarization, building, booting

Lectures

Readings

Each milestone covers one or more research  concepts

E.g. self‐paging, DSLs, multikernel architecture, URPC, 

Final codebase: complete OS

Final milestone: documentation for the system

25

Evaluation: Project (65%)

There are marks for  each milestone

Late milestones incur a  penalty

Beware milestones  which build on previous  ones

Don’t slip behind 

26

Evaluation: Exam (35%)

Date(s)

To be determined – sometime in February

Material 

Lectures, readings, and project material

Format

Written examination (new this year!)

90 minutes.

We are reasonable people!

Test understanding and principles, not fiddly details

27

Dates and times

Lecture:

Thursday 10:00 ‐ 12:00 in CAB G.59

Consultations and marking:

Friday 10:00 ‐ 12:00 in CAB H.57

Mailing list (for questions):

[email protected]

28

Logistics

Initial milestone is done individually

Project is undertaken in teams of 2

Everyone gets a PandaBoard + cables each

Take care of them – they are fragile!

So:

Please find a team partner before tomorrow’s session

You 

MUST

attend tomorrow’s session to sign out your 

PandaBoard

If you can’t find a partner, you will be assigned one at  the session. 

29

People

Timothy Roscoe

Pravin Shinde

Simon Gerber

Kornilios Kourtis

30

What you need to do.

Attend the session tomorrow!

Sign out your Pandaboard kits

Bring your student ID

Verify your board works before leaving

Form groups of 2 for subsequent milestones

Inform Pravin by email before COB Friday

Deliver your first (individual) milestone by  next Friday

Come to the session and demo it

31

Hardware

32

Hardware: PandaBoard ES

Many thanks to ARM Ltd  and Texas Instruments for  their generosity in  providing the hardware! 

33

PandaBoard block diagram

34

The TI OMAP 4460 SoC

35

USB booting

“USB On‐The‐Go” port:

Provides power from  the host PC

Host copies code over 

USB into PandaBoard  memory

Jumps to start of boot  image

No need for network, 

SD card, etc.

USB OTG port

Reset button

36

Serial console

One byte at a time,  bidirectional serial line

Still the best low‐level  console interface for  real OS hacking

First milestone includes:

Very simple console  output

Flash indicator LED

RS‐232 interface

37

ARM CPU cores

2 x ARM Cortex A9 cores

SMP configuration

We’ll start with just one core

We’ll bring up the other one later

There are, in fact, two more ARM Cortex M3 cores.  

We’ll ignore these.

(unless you want to play with them in your spare time )

38

ARM architecture overview

Data Sizes:

16 bits: Halfword

32 bits: Word

64 bits: Doubleword

Note: different from Intel/AMD names!

64

Doubleword

32

Word

Byte

Halfword

16 8

39

ARM Processor modes

Mode Description

Supervisor (SVC) Entered on reset or SWI instruction

FIQ

IRQ

Abort

Undef

Fast interrupt

Normal interrupt

Memory access violations

Undefined instructions

System

User

Privileged mode, same registers as user mode

User mode (regular processes)

Each mode has its own stack!

40

User/

Supervisor r8 r9 r10 r11 r12 r13 (sp) r14 (lr) r15 (pc) r4 r5 r6 r7 r0 r1 r2 r3 cpsr

ARM register sets 

(all 32 bits)

IRQ r13 (sp) r14 (lr)

FIQ r8 r9 r10 r11 r12 r13 (sp) r14 (lr)

Undef

Extra (banked) registers r13 (sp) r14 (lr)

Abort r13 (sp) r14 (lr) spsr spsr spsr spsr

SVC r13 (sp) r14 (lr) spsr

41

ARM condition codes

(some of them)

Z

C

I

V

Flag

N

Description

Negative result

Zero result

Carry from ALU

Overflow from ALU

Disable IRQ

F Disable FIQ mode Current mode (4 bits)

Found in the 

CPSR/SPSR  registers

42

Exception handling

1. CPSR → SPSR mode

2. Set CPSR bits

New mode

Disable interrupts 

(if appropriate)

3. Return addr → LR mode

4. Vector addr → PC

0x1C

0x18

0x14

0x10

0x0C

0x08

0x04

0x00

FIQ

IRQ reserved

Data abort

Prefetch abort

Software interrupt

Undefined instruction

Reset

Base address

= 0x00 or 0xFFFF0000

43

ARM instruction set

Classic RISC load/store architecture

ALU operations are register‐register

All instructions 32 bits long

Most instructions are conditional

On‐die barrel shifter

Branches are PC‐relative

LDR r0,[r1]

STRNEB r2,[r3,r4]

B

SUB

<label> r0,r1,#5

ADD r2,r3,r3,LSL#2

ADDEQ r5,r5,r6

44

OS: Barrelfish

45

What is Barrelfish?

Open source research operating system

Fairly influential in research community

ETH Zurich + Microsoft Research

Currently supports:

32‐ and 64‐bit x86 AMD/Intel 

Intel MIC/Xeon Phi (Knight’s Ferry)

ARMv5, Xscale, ARMv7m, 

ARMv7a

11/11/2011 HPI 46

46

What things run on it?

Many microbenchmarks

Parallel benchmarks: Parsec, SPLASH‐2, NAS

Webserver: 

http://www.barrelfish.org/

Databases: SQLite, PostgreSQL

OpenSSH, other utils

Virtual machine monitor 

Linux kernel binary

Microsoft Office 2010!

– via Drawbridge

11/11/2011 HPI 47

47

Why use Barrelfish?

Very different to Linux, BSD, MacOS, Windows

The shock of the new

Smaller OS

Easier to understand, easier to hack

Multikernel approach (see later)

Simplifies multicore issues

Includes lots of other people’s research ideas

Good illustration of any concepts

48

Some of the (non‐original) ideas in Barrelfish

Capabilities for resource management (KeyKOS, seL4)

Minimize shared state (Tornado, K42)

Upcall processor dispatch (Psyche, Sched. Activations)

Push policy into user space (Exokernel, Nemesis)

User‐space RPC decoupled from IPIs (URPC)

Lots of information (Infokernel)

Single‐threaded non‐preemptive kernel per core (K42)

Run drivers in their own domains (µkernels, Xen)

Fast interprocess communication (LRPC, L4)

Specify device registers in a little language (Devil)

We’ll see many of these later in the course

49

Toolchain

50

Toolchain

C compiler: 

gcc

Haskell compiler: 

ghc

make

Terminal emulator: 

picocom

Boot utility: 

usbboot

Huh?

We provide a VirtualBox image with all this

You are welcome to use your own platform

51

Building Barrelfish

$ mkdir ~/build_milestone_0

$ cd ~/build_milestone_0

$ /hake/hake.sh -s ~/barrelfish -a armv7

Builds a Makefile for Barrelfish in the 

build_milestone_0

directory,  based on the  source tree in 

~/barrelfish

, for just the 

ARMv7 architecture.

You can look at 

./Makefile

to see the result 

(but it can be very large…)

52

Building Barrelfish

$ mkdir ~/build_milestone_0

$ cd ~/build_milestone_0

$ /hake/hake.sh -s ~/barrelfish -a armv7

$ make aos_image

$ ls -l aos_image

Make builds its own directories, dependencies,  and other tools as well.

Result ends up in the top of the build directory.

53

What’s this Hake thing?

(for the curious)

Scattered through the source tree are files called 

Hakefile

Hake concatenates all of these and interprets them as a  single, large Haskell expression

This expression evaluates to the contents of 

./Makefile

Why?

Allows us to build multiple architectures from one source  tree at the same time

Power of a full programming language in expressing  configurations

Still get the efficiency of 

make

for building

54

And finally, some advice

55

Important advice

You will be graded on the 

design

of your code

Does it work?

Handle corner cases, errors, invalid inputs, etc?

An operating system runs for a long time. 

Do you leak memory?  Etc. 

Have you thought about issues not explicit in the  milestones, but important to a real OS?

Not all these criteria can be well‐specified in advance

Use common‐sense in system design

You will be graded on issues you can think of and deal with

56

Important advice

You will be graded on the 

quality

of your report

Doxygen and other tools document lines of code

not the design of a system!  

Don’t submit generated documentation in place of a  report. 

Describe the choices you made (and didn’t make)

Talk about the tradeoffs

Mention the difficulties and challenges, and how you  overcame them.

Show you understand how to build a system.

57

Important advice

You will be examined on the depth of your 

understanding

Design principles

Why do techniques work?

When do they work (or not)?

What are the tradeoffs in a problem?

What factors affect the tradeoffs?

How might this change? How has it changed?

58

Final advice

This course is a lot of fun, but a lot of work

– and we are aware of this!

It is important not to fall behind

If your team is struggling, ask for help.

If you're good, it's tempting to be clever and cool

Resist this temptation!

Get the required work done before freestyling. 

We are here to help you!

Good luck and have fun!

59

Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement