• 沒有找到結果。

Operating Systems

N/A
N/A
Protected

Academic year: 2022

Share "Operating Systems"

Copied!
60
0
0

加載中.... (立即查看全文)

全文

(1)

Operating Systems

Elements of Computing Systems, Nisan & Schocken, MIT Press www.idc.ac.il/tecs

www.nand2tetris.org

Building a Modern Computer From First Principles

(2)

Where we are at:

Assembler Chapter 6

H.L. Language

&

Operating Sys.

abstract interface

Compiler

Chapters 10 - 11

VM Translator

Chapters 7 - 8

Computer Architecture

Chapters 4 - 5

Gate Logic

Chapters 1 - 3

Electrical

Engineering

Physics Virtual

Machine

abstract interface

Software hierarchy

Assembly Language

abstract interface

Hardware hierarchy

Machine Language

abstract interface

Hardware Platform

abstract interface

Chips &

Logic Gates

abstract interface

Human Thought

Abstract design

Chapters 9, 12

(3)

Jack revisited

/** Computes the average of a sequence of integers. */

class Main {

function void main() { var Array a;

var int length;

var int i, sum;

let length = Keyboard.readInt(”How many numbers? ”);

let a = Array.new(length); // Constructs the array let i = 0;

while (i < length) {

let a[i] = Keyboard.readInt(”Enter the next number: ”);

let sum = sum + a[i];

let i = i + 1;

}

do Output.printString(”The average is: ”);

do Output.printInt(sum / length);

do Output.println();

return;

}

(4)

/** Computes the average of a sequence of integers. */

class Main {

function void main() { var Array a;

var int length;

var int i, sum;

let length = Keyboard.readInt(”How many numbers? ”);

let a = Array.new(length); // Constructs the array let i = 0;

while (i < length) {

let a[i] = Keyboard.readInt(”Enter the next number: ”);

let sum = sum + a[i];

let i = i + 1;

}

do Output.printString(”The average is: ”);

do Output.printInt(sum / length);

do Output.println();

return;

}

Jack revisited

(5)

Typical OS functions

Language extensions / standard library

 Mathematical operations (abs, sqrt, ...)

 Abstract data types (String, Date, ...)

 Output functions

(printChar, printString ...)

 Input functions

(readChar, readLine ...)

 Graphics functions

(drawPixel, drawCircle, ...)

 And more ...

System-oriented services

 Memory management (objects, arrays, ...)

 I/O device drivers

 Mass storage

 File system

 Multi-tasking

 UI management (shell / windows)

 Security

 Communications

 And more ...

(6)

The Jack OS

Math : Provides basic mathematical operations;

String : Implements the String type and string-related operations;

Array : Implements the Array type and array-related operations;

Output : Handles text output to the screen;

Screen : Handles graphic output to the screen;

Keyboard : Handles user input from the keyboard;

Memory : Handles memory operations;

Sys : Provides some execution-related services.

(7)

Jack OS API

class Math {

function void init() function int abs(int x)

function int multiply(int x, int y) function int divide(int x, int y) function int min(int x, int y) function int max(int x, int y) function int sqrt(int x)

}

Class String {

constructor String new(int maxLength) method void dispose()

method int length()

method char charAt(int j)

method void setCharAt(int j, char c) method String appendChar(char c)

method void eraseLastChar() method int intValue()

method void setInt(int j) function char backSpace() function char doubleQuote() function char newLine() }

Class Array {

function Array new(int size) method void dispose()

}

class Output {

function void moveCursor(int i, int j) function void printChar(char c)

function void printString(String s) function void printInt(int i)

function void println() function void backSpace() }

Class Screen {

function void clearScreen()

function void setColor(boolean b)

function void drawPixel(int x, int y) function void drawLine(int x1, int y1,

int x2, int y2)

function void drawRectangle(int x1, int y1, int x2, int y2) function void drawCircle(int x, int y, int r) }

class Memory {

function int peek(int address)

function void poke(int address, int value) function Array alloc(int size)

function void deAlloc(Array o) }

Class Keyboard {

function char keyPressed() function char readChar()

function String readLine(String message) function int readInt(String message) }

Class Sys {

function void halt():

function void error(int errorCode)

function void wait(int duration)

(8)

A typical OS:

 Is modular and scalable

 Empowers programmers (language extensions)

 Empowers users (file system, GUI, ...)

 Closes gaps between software and hardware

 Runs in “protected mode”

 Typically written in some high level language

 Typically grows gradually, assuming more and more functions

 Must be efficient.

(9)

Efficiency

We have to implement various operations on n -bit binary numbers ( n = 16, 32, 64, ...).

For example, consider multiplication

 Naïve algorithm: to multiply x*y: { for i = 1 ... y do sum = sum + x } Run-time is proportional to y

In a 64-bit system, y can be as large as 2 64.

Multiplications can take years to complete

 Algorithms that operate on n -bit inputs can be either:

 Naïve: run-time is proportional to the value of the n -bit inputs

 Good: run-time is proportional to n, the input’s size.

(10)

 Run-time: proportional to n

 Can be implemented in SW or HW

 Division: similar idea.

Example I: multiplication

(11)

Example II: square root

The square root function has two convenient properties:

 It’s inverse function is computed easily

 Monotonically increasing

Functions that have these two properties can be computed by binary search:

Number of loop iterations is bounded by n/2, thus the run-time is O(n).

(12)

Complexity

(13)

Complexity

(14)

Donald Knuth 高德納

 Born in 1938

 Author of “The Art of Computer Programming”

《美國科學家》(American Scientist)雜誌曾將該書與愛因斯坦 的《相對論》、狄拉克的《量子力學》、理查·費曼的《量子電 動力學》等書並列為20世紀最重要的12本物理科學類專論書之 一。

 Creator of Tex and metafont

 Turing Award, 1974

 $2.56 check

(15)

Math operations (in the Jack OS)

class Math {

function void init() function int abs(int x)

function int multiply(int x, int y) function int divide(int x, int y) function int min(int x, int y) function int max(int x, int y) function int sqrt(int x)

}

class Math { class String {

class Array { class Output {

class Screen { class Memory {

class Keyboard { class Sys {

function (…)

}

The remaining functions are simple to implement.

(16)

String processing ( in the Jack OS)

Class String {

constructor String new(int maxLength) method void dispose()

method int length()

method char charAt(int j)

method void setCharAt(int j, char c) method String appendChar(char c)

method void eraseLastChar() method int intValue()

method void setInt(int j) function char backSpace() function char doubleQuote() function char newLine()

class Math { class String {

class Array { class Output {

class Screen { class Memory {

class Keyboard { class Sys {

function (…)

}

(17)

Single digit ASCII conversions

 asciiCode(digit) == digit + 48

 digit(asciiCode) == asciiCode - 48

(18)

 SingleDigit–to-character conversions: done

 Number–to-string conversions:

Converting a number to a string

(19)

Memory management ( in the Jack OS )

class Memory {

function int peek(int address)

function void poke(int address, int value) function Array alloc(int size)

function void deAlloc(Array o) }

class Math { class String {

class Array { class Output {

class Screen { class Memory {

class Keyboard { class Sys {

function (…)

}

(20)

 The data structure that this algorithm manages is a single pointer: free.

Memory management (naive)

 When a program constructs (destructs) an object, the OS has to allocate (de-allocate) a RAM block on the heap:

alloc(size): returns a reference to a free RAM block of size size

deAlloc(object): recycles the RAM block that object refers to

(21)

Memory management (improved)

(22)

Peek and poke

class Memory {

function int peek(int address)

function void poke(int address, int value) function Array alloc(int size)

function void deAlloc(Array o) }

 Implementation: based on our ability to exploit exotic casting in Jack:

(23)

Graphics primitives ( in the Jack OS )

Class Screen {

function void clearScreen()

function void setColor(boolean b)

function void drawPixel(int x, int y)

function void drawLine(int x1, int y1, int x2, int y2) function void drawRectangle(int x1, int y1,int x2, int y2) function void drawCircle(int x, int y, int r)

}

class Math { class String {

class Array { class Output {

class Screen { class Memory {

class Keyboard { class Sys {

function (…)

}

(24)

Memory-mapped screen

(25)

Pixel drawing

 Implementation: using poke(address,value)

screen program

application physical

refresh mechanism screen

driver

part of the part of the

(26)

Image representation: bitmap versus vector graphics

 Bitmap file: 00100, 01010,01010,10001,11111,10001,00000, . . .

 Vector graphics file: drawLine(2,0,0,5), drawLine(2,0,4,5), drawLine(1,4,3,4)

 Pros and cons of each method.

(0,0)

vector bitmap

pixel

(27)

Vector graphics: basic operations

drawPixel(x,y)

drawCircle(x,y,r)

drawLine(x1,y1,x2,y2)

drawRectangle(x1,y1,x2,y2)

1 2 3 4 5 6 7 8

0 1 2 3 4 5 6 7 8 9 10 11 12 13 0

drawLine(0,3,0,11)

drawRectangle(1,3,5,9) drawLine(1,12,2,12) drawLine(3,10,3,11) drawLine(6,4,6,9) drawLine(7,0,7,12) drawLine(8,1,8,12)

(Primitive operation)

drawTriangle(x1,y1,x2,y2,x3,y3) etc. (a few more similar operations) 1

2 3 . . .

0 1 2 3 . . . 0

Screen =

grid of pixels

(28)

How to draw a line?

drawLine(x1,y1,x2,y2)

 Basic idea: drawLine is implemented through a sequence of drawPixel operations

 Challenge 1: which pixels should be drawn ?

 Challenge 2: how to draw the line

fast

?

 Simplifying assumption: the line that we are asked to draw goes north-east.

(29)

Line Drawing

 Given: drawLine(x1,y1,x2,y2)

 Notation: x=x1, y=y1, dx=x2-x1, dy=y2-y1

 Using the new notation:

We are asked to draw a line between (x,y) and (x+dx,y+dy)

set (a,b) = (0,0)

while there is more work to do drawPixel(x+a,y+b)

decide if you want to go right, or up if you decide to go right, set a=a+1;

if you decide to go up, set b=b+1

set (a,b) = (0,0)

while (a ≤ dx) and (b ≤ dy) drawPixel(x+a,y+b)

decide if you want to go right, or up if you decide to go right, set a=a+1;

if you decide to go up, set b=b+1 dx

dy

(30)

Line Drawing algorithm

drawLine(x,y,x+dx,y+dy) set (a,b) = (0,0)

while (a ≤ dx) and (b ≤ dy) drawPixel(x+a,y+b)

decide if you want to go right, or up if you decide to go right, set a=a+1;

if you decide to go up, set b=b+1

drawLine(x,y,x+dx,y+dy) set (a,b) = (0,0)

while (a ≤ dx) and (b ≤ dy) drawPixel(x+a,y+b) if b/a > dy/dx set a=a+1

else set b=b+1

costy

(31)

Line Drawing algorithm, optimized

b/a > dy/dx is the same as a*dy < b*dx Define diff = a*dy – b*dx

Let’s take a close look at this diff:

1.

b/a > dy/dx is the same as diff < 0

2.

When we set (a,b)=(0,0), diff = 0

3.

When we set a=a+1, diff goes up by dy When we set b=b+1, diff goes down by dx drawLine(x,y,x+dx,y+dy)

set (a,b) = (0,0)

while (a ≤ dx) and (b ≤ dy) drawPixel(x+a,y+b) if b/a > dy/dx set a=a+1

else set b=b+1

drawLine(x,y,x+dx,y+dy) set (a,b) = (0,0), diff = 0 while (a ≤ dx) and (b ≤ dy)

drawPixel(x+a,y+b)

if diff < 0 set a=a+1, diff = diff + dx else set b=b+1, diff = diff - dy

Motivation

 When you draw polygons, e.g. in animation or video, you need to draw millions of lines

 Therefore, drawLine must be ultra fast

 Division is a very slow operation

 Addition is ultra fast (hardware based)

(32)

Circle drawing

The screen

origin (0,0)

is at the top

left.

(33)

An anecdote about efficiency and design

… Jobs obsessed about the look of what would appear on the screen. One day Bill Atkinson burst into his office all excited. He had just come up with a brilliant algorithm that could draw circles onscreen quickly. The math for making circles usually required calculating square roots, which the Motorola 68000 microprocessor didn’t support.

But Atkinson did a workaround based on the fact that the sum of a sequence of odd numbers produces a sequence of perfect squares (e.g. 1 + 3 = 4, 1 + 3 + 5 = 9, etc.)

When Atkinson fired up his demo, everyone was

impressed except Jobs. “Well, circles are nice,” he said,

“but how about drawing rectangles with rounded

corners?”

(34)

 To do vector graphics (e.g. display a PPT file), you have to draw polygons

 To draw polygons, you need to draw lines

 To draw lines, you need to divide

 Division can be

re-expressed as multiplication

 Multiplication can be reduced to addition

 Addition is easy.

To sum up (vector graphics)…

(35)

Ivan Sutherland

 Born in 1938

 PhD dissertation on Sketchpad (3D demo), 1963 one of the most influential computer programs ever written. This work was seminal in Human-Computer Interaction, Graphics and Graphical User Interfaces (GUIs), Computer Aided Design (CAD), and

contraint/object-oriented programming.

TX-2 computer (built circa 1958) on which the software ran was built from discrete transistors (not integrated circuits -it was room-sized) and contained just 64K of 36-bit words (~272k bytes).

 PhD advisor: Claude Shannon

 Father of computer graphics

 Turing Award, 1988

(36)

Character output primitives ( in the Jack OS )

class Output {

function void moveCursor(int i, int j) function void printChar(char c)

function void printString(String s) function void printInt(int i)

function void println() function void backSpace() }

class Math { class String {

class Array { class Output {

class Screen { class Memory {

class Keyboard { class Sys {

function (…)

}

(37)

Character output

 Given display: a physical screen, say 256 rows by 512 columns

 We can allocate an 11 by 8 grid for each character

 Hence, our output package should manage a 23 lines by 64 characters screen

 Font: each displayable character must have an agreed-upon bitmap

 In addition, we have to manage a “cursor”.

(38)

class Output {

static Array charMaps;

function void initMap() {

let charMaps = Array.new(127);

// Assign a bitmap for each character

do Output.create(32,0,0,0,0,0,0,0,0,0,0,0); // space do Output.create(33,12,30,30,30,12,12,0,12,12,0,0); // ! do Output.create(34,54,54,20,0,0,0,0,0,0,0,0); // “ do Output.create(35,0,18,18,63,18,18,63,18,18,0,0); // # ...

do Output.create(48,12,30,51,51,51,51,51,30,12,0,0); // 0 do Output.create(49,12,14,15,12,12,12,12,12,63,0,0); // 1 do Output.create(50,30,51,48,24,12,6,3,51,63,0,0); // 2 . . .

do Output.create(65,0,0,0,0,0,0,0,0,0,0,0); // A ** TO BE FILLED **

do Output.create(66,31,51,51,51,31,51,51,51,31,0,0); // B do Output.create(67,28,54,35,3,3,3,35,54,28,0,0); // C . . .

return;

}

Font implementation ( in the Jack OS )

// Creates a character map array

function void create(int index, int a, int b, int c, int d, int e, int f, int g, int h, int i, int j, int k) { var Array map;

let map = Array.new(11);

let charMaps[index] = map;

let map[0] = a;

let map[1] = b;

let map[2] = c;

...

let map[10] = k;

return; }

(39)

Keyboard primitives ( in the Jack OS )

Class Keyboard {

function char keyPressed() function char readChar()

function String readLine(String message) function int readInt(String message) }

class Math { class String {

class Array { class Output {

class Screen { class Memory {

class Keyboard { class Sys {

function (…)

}

(40)

Keyboard input

 If the RAM address of the keyboard’s memory map is known, the above logic can be implemented using a peek function

 Problem I: the elapsed time between a “key press” and key release”

events is unpredictable

 Problem II: when pressing a key, the user should get some visible

feedback (cursor, echo, ...).

(41)

A historic moment remembered

… Wozniak began writing the software that would get the microprocessor to display images on the screen. After a couple of month he was ready to test it. “I typed a few keys on the keyboard and I was shocked! The letters were displayed on the screen.”

It was Sunday, June 29, 1975, a milestone for the personal computer. “It was the first time in

history,” Wozniak later said, “anyone had typed a character on a keyboard and seen it show up on their own computer’s screen right in front of them”

(Steve Jobs, by Walter Isaacson, 2012)

(42)

Keyboard input (cont.)

(43)

Jack OS recap

class Math {

function void init() function int abs(int x)

Class String { Class Array {

function Array new(int size) method void dispose()

}

class Output {

Class Screen {

class Memory {

function int peek(int address) Class Keyboard {

Class Sys {

function void halt():

function void error(int errorCode) function void wait(int duration) }

Project 12:

Build it.

 Implementation: just like GNU Unix and Linux were built:

 Start with an existing system,

and gradually replace it with a new system,

(44)

Perspective

 What we presented can be described as a:

 mini OS

 Standard library

 Many classical OS functions are missing

 No separation between user mode and OS mode

 Some algorithms (e.g. multiplication and division) are standard

 Other algorithms (e.g. line- and circle-drawing) can be accelerated with special hardware

 And, by the way, we’ve just finished building the computer.

(45)

Typical computer system

(46)

OS as a resource manager

System and Application Programs

Operating System

Computer Hardware User

1 User

2

User 3

User n

compiler assembler Text editor Database

system

...

(47)

A detailed view of OS

(48)

OS History

(49)

Increasing software complexity

(50)

Computer Performance Over Time

(51)

OS Challenges

 Performance

 Latency/response time

 How long does an operation take to complete?

 Throughput

 How many operations can be done per unit of time?

 Overhead

 How much extra work is done by the OS?

 Fairness

 How equal is the performance received by different users?

 Predictability

 How consistent is the performance over time?

(52)

Early Operating Systems: Computers Very Expensive

 One application at a time

 Had complete control of hardware

 OS was runtime library

 Users would stand in line to use the computer

 Batch systems

 Keep CPU busy by having a queue of jobs

 OS would load next job while current one runs

 Users would submit jobs, and wait, and wait, and

(53)

Time-Sharing Operating Systems: Computers and People Expensive

 Multiple users on computer at same time

 Multiprogramming: run multiple programs at same time

 Interactive performance: try to complete everyone’s tasks quickly

 As computers became cheaper, more important to optimize for

user time, not computer time

(54)

Process and context switching

(55)

Scheduling

(56)

Memory management

(57)

Figure 2.9

Virtual Memory

Concepts

(58)

Root directory

bin cse

faculty grads

ls ps cp csh

Hierarchical file systems

elm sbrandt kag amer4

stuff

classes research

stuff

(59)

Today’s Operating Systems: Computers Cheap

 Smartphones

 Embedded systems

 Web servers

 Laptops

 Tablets

 Virtual machines

 …

(60)

Tomorrow’s Operating Systems

 Giant-scale data centers

 Increasing numbers of processors per computer

 Increasing numbers of computers per user

 Very large scale storage

參考文獻

相關文件

Numerical experiments are done for a class of quasi-convex optimization problems where the function f (x) is a composition of a quadratic convex function from IR n to IR and

strongly monotone or uniform P -function to obtain property of bounded level sets, see Proposition 3.5 of Chen and Pan (2006).. In this section, we establish that if F is either

Abstract Like the matrix-valued functions used in solutions methods for semidefinite pro- gram (SDP) and semidefinite complementarity problem (SDCP), the vector-valued func-

By this, the second-order cone complementarity problem (SOCCP) in H can be converted into an unconstrained smooth minimization problem involving this class of merit functions,

Lin, A smoothing Newton method based on the generalized Fischer-Burmeister function for MCPs, Nonlinear Analysis: Theory, Methods and Applications, 72(2010), 3739-3758..

Specifically, in Section 3, we present a smoothing function of the generalized FB function, and studied some of its favorable properties, including the Jacobian consistency property;

Specifically, in Section 3, we present a smoothing function of the generalized FB function, and studied some of its favorable properties, including the Jacobian consis- tency

int main(int argc, char** argv).