Scribd
Upload
77 views11 pages

Last Class: OS and Computer Architecture: CPU, Memory, I/O Devices, Network Card, System Bus

The document discusses operating system structures and services. It introduces system calls and describes four common OS organizations: monolithic kernel, layered architecture, microkernel, and modular. It provides examples of system call implementation in Windows and Unix and how APIs, system calls, and the OS interact. Parameters methods for system calls are covered, along with examples of OS structures from Mac OS X, Windows 8, layered and microkernel designs. [/SUMMARY]

Uploaded by

Debashish Pal
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
77 views11 pages

Last Class: OS and Computer Architecture: CPU, Memory, I/O Devices, Network Card, System Bus

The document discusses operating system structures and services. It introduces system calls and describes four common OS organizations: monolithic kernel, layered architecture, microkernel, and modular. It provides examples of system call implementation in Windows and Unix and how APIs, system calls, and the OS interact. Parameters methods for system calls are covered, along with examples of OS structures from Mac OS X, Windows 8, layered and microkernel designs. [/SUMMARY]

Uploaded by

Debashish Pal
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 11

Last Class: OS and Computer Architecture

System bus

Network
card

• CPU, memory, I/O devices, network card, system bus

Computer Science CS377: Operating Systems Lecture 3, page 1

Last Class: OS and Computer Architecture

OS Service Hardware Support


Protection Kernel/user mode, protected
instructions, base/limit registers
Interrupts Interrupt vectors

System calls Trap instructions and trap vectors


I/O Interrupts and memory mapping
Scheduling, error recovery, Timer
accounting
Synchronization Atomic instructions

Virtual memory Translation look-aside buffers

Computer Science CS377: Operating Systems Lecture 3, page 2


Today: OS Structures & Services
• More on System Calls
• Introduce the organization and components in an OS.
• Four example OS organizations
– Monolithic kernel
– Layered architecture
– Microkernel
– Modular

Computer Science CS377: Operating Systems Lecture 3, page 3

Class Exercise

• iOS 7 and iPhone 5S


– “iPhone 5S first 64-bit smartphone, iOS 7 first 64-bit OS”

• iPhone 5S has M7 co-processor in addition to main A7


processor
– Offloads work (primarily sensor data processing) from main
CPU to co-processor

• Critique these design decisions. Benefits?

Computer Science Lecture 3, page 4


System Calls

• Programming interface to the services provided by the OS


• Typically written in a high-level language (C or C++)
• Mostly accessed by programs via a high-level Application
Program Interface (API) rather than direct system call use
• Three most common APIs are Win32 API for Windows, POSIX
API for POSIX-based systems (including virtually all versions of
UNIX, Linux, and Mac OS X), and Java API for the Java virtual
machine (JVM)
• Why use APIs rather than system calls?

Computer Science CS377: Operating Systems Lecture 3, page 5

Standard C Library Example


• C program invoking printf() library call, which
calls write() system call

Computer Science CS377: Operating Systems Lecture 3, page 6


Example of Standard API
• Consider the ReadFile() function in the
• Win32 API—a function for reading from a file

• A description of the parameters passed to ReadFile()


– HANDLE file—the file to be read
– LPVOID buffer—a buffer where the data will be read into and written from
– DWORD bytesToRead—the number of bytes to be read into the buffer
– LPDWORD bytesRead—the number of bytes read during the last read
– LPOVERLAPPED ovl—indicates if overlapped I/O is being used

Computer Science CS377: Operating Systems Lecture 3, page 7

System Call Implementation

• Typically, a number associated with each system call


– System-call interface maintains a table indexed according to these numbers
• The system call interface invokes intended system call in OS
kernel and returns status of the system call and any return values
• The caller need know nothing about how the system call is
implemented
– Just needs to obey API and understand what OS will do as a result call
– Most details of OS interface hidden from programmer by API
• Managed by run-time support library (set of functions built into libraries
included with compiler)

Computer Science CS377: Operating Systems Lecture 3, page 8


API – System Call – OS Relationship

Computer Science CS377: Operating Systems Lecture 3, page 9

System Call Parameter Passing

• Often, more information is required than simply identity of


desired system call
– Exact type and amount of information vary according to OS and call
• Three general methods used to pass parameters to the OS
– Simplest: pass the parameters in registers
• In some cases, may be more parameters than registers
– Parameters stored in a block, or table, in memory, and address of block
passed as a parameter in a register
• This approach taken by Linux and Solaris
– Parameters placed, or pushed, onto the stack by the program and popped off
the stack by the operating system
– Block and stack methods do not limit the number or length of parameters
being passed

Computer Science CS377: Operating Systems Lecture 3, page 10


Examples of Windows and Unix System Calls

Computer Science CS377: Operating Systems Lecture 3, page 11

One Basic OS Structure

• The kernel is the protected part of the OS that runs in


kernel mode, protecting the critical OS data structures
and device registers from user programs.
• Debate about what functionality goes into the kernel
(above figure: UNIX) - “monolithic kernels”
Computer Science CS377: Operating Systems Lecture 3, page 12
Mac OS X Architecture

Computer Science Lecture 3, page 13

Windows 8 Architecture

Computer Science Lecture 3, page 14


Layered OS design
User programs
Device drivers
Virtual memory
I/O channel
Cpu scheduler
Hardware

Layer N: uses layer N-1 and provides new functionality to N+1


• Advantages: modularity, simplicity, portability, ease of
design/debugging
• Disadvantage - communication overhead between layers,
extra copying, book-keeping, layer design

Computer Science CS377: Operating Systems Lecture 3, page 15

Microkernel

• Small kernel that provides communication (message


passing) and other basic functionality
• other OS functionality implemented as user-space processes
Computer Science CS377: Operating Systems Lecture 3, page 16
Microkernel Features
• Goal: to minimize what goes in the kernel (mechanism, no
policy), implementing as much of the OS in User-Level processes
as possible.
• Advantages
– better reliability, easier extension and customization
– mediocre performance (unfortunately)

• First Microkernel was Hydra (CMU '70). Current systems include


Chorus (France) and Mach (CMU).

Computer Science CS377: Operating Systems Lecture 3, page 17

Mac OS X - hybrid approach

• Layered system: Mach microkernel (mem, RPC, IPC) + BSD


(threads, CLI, networking, filesystem) + user-level services (GUI)

Computer Science CS377: Operating Systems Lecture 3, page 18


Modules

• Most modern operating systems implement kernel


modules
– Uses object-oriented approach
– Each core component is separate
– Each talks to the others over known interfaces
– Each is loadable as needed within the kernel
• Overall, similar to layers but more flexible

Computer Science CS377: Operating Systems Lecture 3, page 19

Solaris Modular Approach

Computer Science CS377: Operating Systems Lecture 3, page 20


Summary
• Big Design Issue: How do we make the OS efficient, reliable, and
extensible?

• General OS Philosophy: The design and implementation of an


OS involves a constant tradeoff between simplicity and
performance. As a general rule, strive for simplicity except when
you have a strong reason to believe that you need to make a
particular component complicated to achieve acceptable
performance (strong reason = simulation or evaluation study)

Computer Science CS377: Operating Systems Lecture 3, page 21

Computer Science CS377: Operating Systems Lecture 3, page 22

You might also like