Upgrade to remove ads
Only $35.99/year

OPSYS Exam1

Terms in this set (83)

Mention any three main purposes of an operating system?
The 5 Managers DPMFN
Two design objectives of operating system
Portability
Extensibility
Convenience
Performance
Isolation and Protection
Main characteristics of Von Neumann Architecture
1. Separation btwn CPU, memory, I/O, and logic
2. Program stored in memory during execution
3. Instructions fetched from memory line by line
What is an interrupt and why are they useful? How are they handled?
Events that invoke OS, handled by OS

Software interrupt: issued by program to request system call
Hardware interrupt: issued by hardware to signal OS they need CPU
Programmed I/O
CPU keeps checking status if I/O (busy waiting) until it's ready
Interrupt Driven I/O
CPU checks once (with read), does other things
Devices responsibility to tell CPU it's ready w/ interrupt
DMA I/O
Separation of CPU and I/O
CPU issues command to DMA controller (read or write)
Controller performs transfer btwn memory and I/O without processor
Controller sends interrupt to CPU when device done
Polling
Checking status of device
Polling in Programmed I/O
Keeps polling till device ready
Polling in Interrupt Driven I/O
Polling happens once
Device sends interrupt when ready
Blocking I/O
I/O requests block CPU, doesn't contribute until I/O is complete
Non-Blocking I/O
Asynchronous request, returns immediately without waiting for I/O to complete
Multi-core System
Single processor with more than one core

Higher efficiency
Shared memory
Not as fast
Multiprocessor System
More than one processor chip in system

Increased throughput
More reliable

More traffic, throughput can be decreased cause resources shared
Symmetric Multiprocessing (SMP)
All processors equal,
each processor performs all tasks within the OS
A: shared memory
D: costly
Asymmetric Multiprocessing (AMP)
Master-dove relationship between processors

A: specialized rolls = different tasks
D: IPC more difficult, processors largely unaware of each other
Main goal of Clustered System?
Multiple computers are merged to perform tasks in parallel

Improves performance, great scalability, reliable
Degree of Multiprogramming
Maximum # of processes a single processor can accommodate efficiently
Why a high degree of Multiprogramming?
Less wait time, keeps CPU utilization high
What is timesharing and what's it's main goal?
Multiple jobs executed at the same time by context switching for a short burst of time
Goal: lower response time
When is it appropriate to "waste" resources?
Waste CPU cycles to optimize user interaction

Not technically wasted cause it doesn't hurt performance and it increases usability
Why does having user and kernal mode provide rudimentary form of protection in system?
Separation btwn user and kernel mode provides maximum security and stability
Why is timer so important?
Fairness
So one process doesn't take up too much tjme
5 functions of Operating Systems
DPMFN
Client-Server Model
Separation of client and server. Client requests, server serves requests
A: stable
D: costly
Peer-to-Peer Model
No differentiation, every node can request and respond to requests

A: costs less, easy to implement
D: less stable, less secure
Any 4 resources
Memory
Devices
Files
Network
CPU time
Programming example where multithreading doesn't provide better performance than single threaded
When a process is majorly serial code
4 Programming challenges when using threads in multicore
Identifying tasks
Balancing tasks
Data splitting (prevent interference)
Testing and Debugging
Data Dependency (order of execution)
Data Dependency between 2 tasks in 2 threads?
Dependent task needs to be AFTER task it's dependent on
Data Parallelism
Same tasks running on different data
Task Parallelism
Different tasks running on same data
User Level Threads
Easy, no overhead for synchronization, switching faster
Can run concurrently but not in parallel
Blocking blocks whole process/all threads

Better for POSIX
Kernal level threads
Can run in parallel
Slow and inefficient
Overhead for event handling
Blocking only blocks the one thread

Better for Solaris
One to One
A: blocking one doesn't block other
Can run in parallel on diff processors
D: lot of overhead
Limit of # of user threads
Many to Many
A: parallelism
Low overhead
No limit to # of user threads

D: complex implementation
Two level
Combines many to many and one to one
Has advantages of both
Good for real time systems cause few threads have 1-1
Implicit threading
Creation and management of threads done by library
Hides management of threads
Thread Pool
create a number of threads at process startup and place them in a pool
Threads pulled from pool to do server request then put back
Faster: no need to delete and create for each client
A: faster, less overhead, concurrency
Concurrency
More processes than processors, context switching
3 issues with multithreaded applications
Increased complexity
Unpredictable results
Difficult to debug
Complications with Concurrency
Goal of scheduler activation?
Mimic functionality of kernal threads
Kernal creates a virtual processors and schedules threads with up all handlers
Zombie
Child terminates before parent
Orphan
Parent terminates before child
Zombie process issue and how to avoid
Takes up memory and table space
Have parent wait() for child
Why create orphan?
To create daemon
5 information in Process Control Block PCB
Process ID
Process State
Process Privileges
Pointer
Context Data
Memory Management
Job Queue
Where process placed before accepted by system
Ready Queue
Where process placed when accepted
I/O Queue
Where process placed if it needs I/O operations
(After it's moved back to ready queue)
Short-term scheduler, why fast?
CPU scheduler
Handles priority
Moves processes in and out of ready state
Long-term scheduler, why slow?
Regulates programs selected for programming
Why do medium term schedulers decrease degree of Multiprogramming?
Swaps and removes processes from memory
Priorities higher quality processes instead of running processes with multiple tasks
Three scenarios for context switching
Multitasking
Handling interrupts
Switching between user and kernal mode
Scenario where parent wants to abort child
Child used up too many resources
Task for child no longer needed
Example when message passing preferred
Producer to consumer
One way communication
Example when prefer memory sharing
Process needs to send and receive (multidirectional)
Resolve 2 processes calling receive at same time?
Only let one call receive at a time
Only let 2 processes share mailbox at a time
Select process at random to be receiver
Blocking send
the sender is blocked until the message is received
Non-blocking send
the sender sends the message and continue
Blocking receive
the receiver is blocked until a message is available
Non-blocking receive
Returns immediately, receiver receives a valid message or null message.
Producer Consumer Zero buffer capacity
Producer must wait for consumer to take each item
Producer consumer bounded buffer
Finite storage amount
Producer consumer unbounded
(Seemingly) unlimited storage
Connection oriented socket TCP
Reliable
Order maintained
If server doesn't acknowledge client, client assumes data was lost and resends
Connectionless UDP
Unreliable
No guarantee data will reach destination
Order not preserved
Very difficult
Advantage of Remote Procedure Call RPC in distributed network
Hides details of communication
Hugh level
Can make distant prosecute call over network
Ordinary Pipe
Unnamed
Unidirectional
Can only communicate with processes w/ common ancestor (parent and child)
Named Pipe
FIFO - First in first out
Same rules as unnamed but can be used by unrelated processes
Created with file attached
What is a system call and what is it's purpose
Mechanism for process to request services from OS like CPU time, memory allocation, or other resources
System call vs interrupts
System call is a software interrupt, let's process invoke operating system

Interrupt - event that causes CPU to hault
Different ways to pass parameters during a system call
• Passing to registers in memory
• Storting Params in memory and passing addresses to registers
• Pushing params onto stack
Policy
Rules and decisions of activities (tasks) to be performed
Mechanism
How rules are implemented
Why separation of policy and mechanism?
Allows different applications use same mechanism for different policies
What is a kernal? Why have kernal as small as possible?
Single process that controls everything in system
Small as possible: it's in main memory, takes up space, not enough for other processes
Layered OS advantages and disadvantages
A: simple, easier to implement and debug
D: very slow cause request goes through every layer one at a time
Philosophy behind microkernal OS?
Has basic kernal stuff like file systems and device drivers run in user space
A: reduces kernal size, improves security, stability, robustness
D: poor performance, increased overhead from message passing
Monolithic
Faster, larger OS, cost of IPC in kernal low
D: less secure, costs more memory
Advantage of visualization
Tailors OS to run different applications run by different users on a single machine

Reduces down time
Resiliency
Increased efficiency
Bare metal architecture vs hosted architecture
Bare metal is Type1:
VM monitor installed directly on hardware
Like enterprises

Hosted is Type2:
OS installed on hardware, then VM monitor installed, apps run on VM
Like virtual machine
5 stages in System Boot
Power Supply - switching mode power supply
Boot Strapping - looking in same place for BIOS
BIOS - Basic Input/Output System
CMOS - Complementary Metal-Oxide Semiconductor
Master Boot Record- contains program that boots OS
Sets found in the same folder