1. Introduction to Operating Systems
CS 499: Special Topics in Cyber Security S. Sean Monemi

2. Overview Operating Systems Definition Processes and Threads
Program Control Blocks
Process Scheduling and Interrupts

3. What is an Operating System
A program that acts as an intermediary between a user and the computer hardware
Operating system goals:
Make the computer system convenient to use
Use the computer hardware in an efficient manner
Execute user programs and make solving user problems easier

4. What is an Operating System
The operating system is that portion of the software that runs in Kernel mode or Supervisor mode
It performs two basic unrelated functions:
Extending the machine
Managing resources

5. What is an Operating System
An extended machine
Hides the messy details which must be performed
Presents user with a virtual machine, easier to use
Controls the execution of user programs and operations of I/O devices
Resource manager (allocator)
Manages and allocates resources
Each program gets time with the resource
Each program gets space on the resource

6. Example A computer system consists of hardware system programs
application programs

7. Process

8. Introduction Computers perform operations concurrently
Examples:
compiling a program
sending a file to a printer
rendering a Web page
playing music
receiving
Process – an abstraction of a running program
The terms job and process used almost interchangeably

9. Process Definition A process includes: Process
Processes enable systems to perform and track simultaneous activities
A program in execution; process execution must progress in sequential fashion
Processes transition between process states
Operating systems perform operations on processes such as creating, destroying, suspending, resuming and waking
A process includes:
program counter
stack
data section

10. Definition of Process A program in execution
A process has its own address space consisting of:
Text region
Stores the code that the processor executes
Data region
Stores variables and dynamically allocated memory
Stack region
Stores instructions and local variables for active procedure calls

11. Processes Multiprogramming of four programs
Conceptual model of 4 independent, sequential processes
Only one program active at any instant

12. Process Creation Ways to cause process creation System initialization
Execution of a process creation system
User request to create a new process
Initiation of a batch job

13. Process Termination Conditions which terminate processes
Normal exit (voluntary)
Error exit (voluntary)
Fatal error (involuntary)
Killed by another process (involuntary)

14. Process Management OS provide fundamental services to processes:
Creating processes
Destroying processes
Suspending processes
Resuming processes
Changing a process’s priority
Blocking processes
Waking up processes
Dispatching processes
Interprocess communication (IPC)

15. Process States
A process moves through a series of discrete process states:
Running state
The process is executing on a processor
Instructions are being executed, using CPU
Ready state
The process could execute on a processor if one were available
Runnable; temporarily stopped to let another process run
Blocked state
The process is waiting for some event to happen before it can proceed
Unable to run until some external event happens

16. Process Transitions State Transitions 4 possible state transitions:
ready to running:
when a process is dispatched
running to ready:
when the quantum expires
running to blocked:
when a process blocks
blocked to ready:
when the event occurs

17. Suspend and Resume Suspending a process
Indefinitely removes it from contention for time on a processor without being destroyed
Useful for detecting security threats and for software debugging purposes
A suspension may be
initiated by the process
being suspended or
by another process
A suspended process must
be Resumed by another p
Two suspended states:
suspendedready
suspendedblocked

18. Process Hierarchies Parent creates a child process,
child processes can create its own process
Forms a hierarchy
UNIX calls this a "process group“
Windows has no concept of process hierarchy
all processes are created equal

19. Process Control Blocks (PCBs) Process Descriptors

20. Process Control Blocks
PCBs maintain information that the OS needs to manage the process
Typically include information such as
Process identification number (PID)
Process state
Program counter
Scheduling priority
Credentials
A pointer to the process’s parent process
Pointers:
to the process’s child processes
to locate the process’s data and instructions in memory
to allocated resources

21. Process Control Blocks
Process table
The OS maintains pointers to each process’s PCB in a system-wide or per-user process table
Allows for quick access to PCBs
When a process is terminated, the OS removes the process from the process table and frees all of the process’s resources
Process table and process control blocks

22. Context Switching Context switches
Performed by the OS to stop executing a running process and begin executing a previously ready process
Save the execution context of the running process to its PCB
Load the ready process’s execution context from its PCB
Must be transparent to processes
Require the processor to not perform any “useful” computation
OS must therefore minimize context-switching time
Performed in hardware by some architectures

23. Threads

24. The Thread Model
(a) Three processes (unrelated) each with one thread, each of them with a different address space
(b) One process with three threads (part of the same job), (Multithreading), all three of them share the same address space

25. Each thread has its own stack
The Thread Model
Each thread has its own stack
Each thread designate a portion of a program that may execute concurrently with other threads

26. Thread Definition Processes are used to group resources together and
threads are the entities scheduled for execution on the CPU
A traditional or heavyweight process is equal to a task with one thread
A thread (or lightweight process) is a basic unit of CPU utilization; it consists of:
program counter
register set
stack space
Thread shares with its peer threads:
code section
data section
OS resources
collectively known as a task

27. The Thread Model Items shared by all threads in a process
Items private to each thread

28. Thread States Thread states Born state Ready state (runnable)
Running state
Dead state
Blocked state
Waiting state
Sleeping state
Sleep interval specifies for how long a thread will sleep

29. Thread Operations Threads and processes have common operations Create
Exit (terminate)
Suspend
Resume
Sleep
Wake

30. The Thread Library Multithreading Library Procedure Calls:
thread_create
Thread has the ability to create new threads
thread_exit
When a thread has finished its work, it can exit
thread_wait
One thread can wait for a (specific) thread to exit
thread_yield
Allows a thread to voluntarily give up the CPU to let another thread run

31. Windows XP Threads Windows XP threads can create fibers
Fiber is similar to thread
Fiber is scheduled for execution by the thread that creates it
Thread is scheduled by the scheduler
Windows XP provides each process:
with a thread pool that consists of a number of worker threads, which are kernel threads that execute functions specified by user threads
Windows XP thread state-transition diagram

32. Linux Threads
Linux allocates the same type of process descriptor to processes and threads (tasks)
Linux uses the UNIX-based system call fork to spawn child tasks
To enable threading, Linux provides a modified version named clone
Clone accepts arguments that specify which resources to share with the child task
Linux task state-transition diagram

33. A word processor with three threads
Thread Usage
T1 – interact with user
T2 – handles reformatting
T3 – save to disk
A word processor with three threads

34. Thread Usage A multithreaded Web server (a) Dispatcher thread
(b) Worker thread

35. Threading Models Three most popular threading models
User-level threads
Kernel-level threads
Hybrid- level threads (Combination of user-level and kernel-level threads)

36. A user-level threads package
- Thread Management done by User-Level Threads Library
supported above the kernel, via a set of library calls at the user level
- Each process has its own private thread table
to keep track of the threads in that process,
such as thread’ PC, SP, RX’s, state, etc.
- The thread table is managed by the
run-time system
Many-to-one thread mappings
OS maps all threads in a multithreaded
process to single execution context
Examples:
POSIX Pthreads
Mach C-threads
Solaris threads
A user-level threads package

37. Implementing Threads in User Space
Advantages:
They can run with existing OS
Thread switching is faster than trapping to the kernel
no trap and context switch is needed
the memory cache need not be flashed
Thread scheduling is very fast
local procedures used to save the thread’s state and the scheduler
Each process has its own customized scheduling algorithm
Better scalability
kernel threads invariably require some table and stack space in the kernel

38. Implementing Threads in User Space
Disadvantages:
The problem of how blocking system calls are implemented
a thread reads from the keyboard before any keys have been hit
letting the thread actually make the system call is unacceptable
(this will stop all the threads)
Kernel blocking the entire process
if a thread causes a page fault, the kernel, not even knowing about the existence of threads, naturally blocks the entire process until the disk I/O is complete, even though other threads might be runnable
If a thread starts running, no other thread in that process will ever run unless the 1st thread voluntary gives up the CPU
unless a thread enters the run-time system of its own free will, the scheduler will never get a chance

39. Implementing Threads in the Kernel
Supported by the Kernel
- kernel know about & manage threads
- no run-time system is needed in each process
- no thread table in each process
Kernel has a thread table
- thread table keeps track of all threads in the system
Thread makes a kernel call
- when a thread wants to create a new thread
- when a thread wants to destroy an existing thread
- updates the kernel thread table
Examples
- Windows 95/98/NT
- Solaris
- Digital UNIX
A threads package managed by the kernel

40. Implementing Threads in the Kernel
Kernel-level threads attempt to address the limitations of user-level threads by mapping each thread to its own execution context
Kernel-level threads provide a one-to-one thread mapping
Advantages:
Increased scalability, interactivity, and throughput
Disadvantages:
Overhead due to context switching and reduced portability due to OS-specific APIs
Kernel-level threads are not always the optimal solution for multithreaded applications

41. Hybrid Implementations
The combination of user- and kernel-level thread implementation
Many-to-many thread mapping (m-to-n thread mapping)
Number of user and kernel threads need not be equal
Can reduce overhead compared to one-to-one thread mappings by implementing thread pooling

42. Pop-Up Threads Threads are frequently useful in distributed system
No more of traditional approach to have a thread that is blocked on a receive system call waiting for an incoming message
Pop-up thread - Creation of a new thread caused by the arrival of a new message
(a) before message arrives (b) after message arrives

43. Java Multithreading
Java allows the application programmer to create threads that can port to many computing platforms
Threads
Created by class Thread
Execute code specified in a Runnable object’s run method
Java supports operations such as naming, starting and joining threads

44. Java threads being created, starting, sleeping and printing
Java Multithreading
Java allows the application programmer to create threads that can port to many computing platforms
Threads
Created by class Thread
Execute code specified in a Runnable object’s run method
Java supports operations such as naming, starting and joining threads
Java threads being created, starting, sleeping and printing

45. Java Multithreading

46. Processor Scheduling

47. Scheduling Concepts Scheduling is a fundamental OS function
Scheduling is central to OS design
Almost, all computer resources are scheduled before use
Maximum CPU utilization obtained with multiprogramming
CPU scheduling is the basics of multiprogrammed OS
Scheduler – the part of OS that makes the decision which process (in ready state) to run next

48. Scheduling Concepts CPU–I/O Burst Cycle The success of CPU scheduling,
depends on the following observed property of processes:
Process execution consist of:
a cycle of CPU execution
and I/O wait.
Process alternate back and forth between theses two states.

49. Scheduling Concepts Alternating sequence of CPU and I/O bursts
Process execution begins with:
a CPU burst
then an I/O burst
then another CPU burst
then another I/O burst
…..and so on
Eventually, the final CPU burst ends with a
system request to terminate execution, rather than with another I/O burst

50. Scheduling Histogram of CPU-burst times
Bursts of CPU usage alternate with periods of I/O wait
a CPU-bound program might have a few long CPU bursts
an I/O-bound program typically will have many short CPU bursts

51. Processor scheduling policy
Decides which process runs at given time
Different schedulers will have different goals
Maximize throughput
Minimize latency
Prevent indefinite postponement
Complete process by given deadline
Maximize processor utilization

52. Scheduling Levels High-level scheduling Intermediate-level scheduling
Determines which jobs can compete for resources
Controls number of processes in system at one time
Intermediate-level scheduling
Determines which processes can compete for processors
Responds to fluctuations in system load
Low-level scheduling
Assigns priorities
Assigns processors to processes

53. Scheduling Algorithms
Nonpreemptive
picks a process to run and then just lets it run until it blocks
(either on I/O or waiting for another process) or voluntarily releases the CPU.
Preemptive
picks a process and lets it run for a maximum of some fixed time.

54. Preemptive vs. Nonpreemptive Scheduling
Preemptive processes
Can be removed from their current processor
Can lead to improved response times
Important for interactive environments
Preempted processes remain in memory
Nonpreemptive processes
Run until completion or until they yield control of a processor
Unimportant processes can block important ones indefinitely

55. Scheduling Categories
Batch
Quick response is not the issue
Nonpreemptive and Preemptive algorithms are acceptable
Reduces process switches and improve performance
Interactive
Preemption is essential
Real Time
Preemption not needed

56. CPU Scheduler
Selects from among the processes in memory that are ready to execute, and allocates the CPU to one of them.
CPU scheduling decisions may take place when a process:
1. Switches from running to waiting state.
2. Switches from running to ready state.
3. Switches from waiting to ready.
4. Terminates.
Scheduling under 1 and 4 is nonpreemptive.
All other scheduling is preemptive.

57. Scheduling Objective Items
CPU utilization
– keep the CPU as busy as possible
Throughput
– # of processes that complete their execution per time unit
Turnaround time
– amount of time to execute a particular process
Waiting time
– amount of time a process has been waiting in the ready queue
Response time
– amount of time it takes from when a request was submitted until the first response is produced, not output (for time-sharing environment)

58. Scheduling Objectives
Different objectives depending on system
Maximize throughput
Maximize number of interactive processes receiving acceptable response times
Minimize resource utilization
Avoid indefinite postponement
Enforce priorities
Minimize overhead
Ensure predictability
Several goals common to most schedulers
Fairness
Predictability
Scalability

59. Scheduling Optimization Criteria
Max CPU utilization
Max throughput
Min turnaround time
Min waiting time
Min response time

60. Scheduling Algorithms
Decide when and for how long each process runs
Make choices about:
Preemptibility
Priority
Running time
Run-time-to-completion
fairness

61. Scheduling Algorithm Goals

62. Scheduling Algorithms
Interactive
Round-Robin Scheduling
Priority Scheduling
Multiple Queues
Shortest Process Next
Guaranteed Scheduling
Lottery Scheduling
Fair-Share Scheduling
Batch
First-In First-Out
Shortest Job First
Shortest Remaining Time Next
Three-Level Scheduling
Real Time
Static
Dynamic

63. First-In-First-Out (FIFO) Scheduling
Simplest scheme
Processes dispatched according to arrival time
Nonpreemptible
Rarely used as primary scheduling algorithm
See Examples…

64. Shortest-Process-First (SPF) Scheduling
Scheduler selects process with smallest time to finish
Lower average wait time than FIFO
Reduces the number of waiting processes
Potentially large variance in wait times
Nonpreemptive
Results in slow response times to arriving interactive requests
Relies on estimates of time-to-completion
Can be inaccurate or falsified
Unsuitable for use in modern interactive systems

65. Shortest-Job-First (SJF) Scheduling
Associate with each process the length of its next CPU burst. Use these lengths to schedule the process with the shortest time.
When several equally important jobs are sitting in the queue waiting to be started, the scheduler picks the shortest job first.
Two schemes:
Nonpreemptive – once CPU given to the process it cannot be preempted until completes its CPU burst.
Preemptive – if a new process arrives with CPU burst length less than remaining time of current executing process, preempt. This scheme is know as the Shortest-Remaining-Time-First (SRTF).
SJF is optimal – gives minimum average waiting time for a given set of processes.

66. Shortest-Remaining-Time (SRT) Scheduling
Preemptive version of SPF
Shorter arriving processes preempt a running process
Very large variance of response times: long processes wait even longer than under SPF
Not always optimal
Short incoming process can preempt a running process that is near completion
Context-switching overhead can become significant
See Examples…

67. Three level scheduling
1. Admission scheduler – which job in input queue?
2. Memory scheduler – which process in disk?
3. CPU scheduler – which ready process in main memory?

68. Round-Robin (RR) Scheduling
Round-robin scheduling
Based on FIFO
Processes run only for a limited amount of time called a time slice or quantum
Preemptible
Requires the system to maintain several processes in memory to minimize overhead
Often used as part of more complex algorithms

69. Round-Robin (RR) Scheduling
Each process gets a small unit of CPU time (time quantum), usually milliseconds. After this time has elapsed, the process is preempted and added to the end of the ready queue.
If there are n processes in the ready queue and the time quantum is q, then each process gets 1/n of the CPU time in chunks of at most q time units at once.
No process waits more than (n-1)q time units.

70. Round-Robin (RR) Scheduling
Quantum size
Determines response time to interactive requests
Very large quantum size
Processes run for long periods
Degenerates to FIFO
Very small quantum size
System spends more time context switching than running processes
Middle-ground
Long enough for interactive processes to issue I/O request
Batch processes still get majority of processor time
See Examples…

71. Highest-Response-Ratio-Next (HRRN) Scheduling
Improves upon SPF scheduling
Still nonpreemptive
Considers how long process has been waiting
Prevents indefinite postponement

72. Fair Share Scheduling (FSS)
FSS controls users’ access to system resources
Some user groups more important than others
Ensures that less important groups cannot monopolize resources
Unused resources distributed according to the proportion of resources each group has been allocated
Groups not meeting resource-utilization goals get higher priority
Standard UNIX process scheduler.
The scheduler grants the processor to users, each of whom may have many processes.
Fair share scheduler. The fair share scheduler divides system resource capacity into portions, which are then allocated by process schedulers assigned to various fair share groups.

73. A scheduling algorithm with four priority classes
Priority Scheduling
Priority scheduling – Each process is assigned a priority, and the runnable process with the highest priority is allowed to run first
A scheduling algorithm with four priority classes

74. Deadline Scheduling Deadline scheduling
Process must complete by specific time
Used when results would be useless if not delivered on-time
Difficult to implement
Must plan resource requirements in advance
Incurs significant overhead
Service provided to other processes can degrade

75. Scheduling in Real-Time Systems
Real-time Systems Categories:
Soft real-time computing – requires that critical processes receive priority over less fortunate ones.
Missing an occasional deadline is undesirable, but nevertheless tolerable
Hard real-time systems – required to complete a critical task within a guaranteed amount of time.
absolute deadlines that must be met

76. Real-Time Scheduling Real-time scheduling Two categories
Related to deadline scheduling
Processes have timing constraints
Also encompasses tasks that execute periodically
Two categories
Soft real-time scheduling
Does not guarantee that timing constraints will be met
For example, multimedia playback
Hard real-time scheduling
Timing constraints will always be met
Failure to meet deadline might have catastrophic results
For example, air traffic control

77. Real-Time Scheduling Static real-time scheduling
Does not adjust priorities over time
Low overhead
Suitable for systems where conditions rarely change
Hard real-time schedulers
Rate-monotonic (RM) scheduling
Process priority increases monotonically with the frequency with which it must execute
Deadline RM scheduling
Useful for a process that has a deadline that is not equal to its period

78. Real-Time Scheduling Dynamic real-time scheduling
Adjusts priorities in response to changing conditions
Can incur significant overhead, but must ensure that the overhead does not result in increased missed deadlines
Priorities are usually based on processes’ deadlines
Earliest-deadline-first (EDF)
Preemptive, always dispatch the process with the earliest deadline
Minimum-laxity-first
Similar to EDF, but bases priority on laxity, which is based on the process’s deadline and its remaining run-time-to-completion

79. Scheduling in Real-Time Systems
Real-time System Responding to Events:
Periodic – occurring at regular intervals
Aperiodic – occurring unpredictably
Schedulable real-time system
Given
m periodic events (multiple periodic event streams)
event i occurs within period Pi and requires Ci seconds of CPU to handle each event
Then the load can only be handled if:
See Examples…

80. Java Thread Scheduling
Operating systems provide varying thread scheduling support
User-level threads
Implemented by each program independently
Operating system unaware of threads
Kernel-level threads
Implemented at kernel level
Scheduler must consider how to allocate processor time to a process’s threads

81. Java Thread Scheduling
Java threading scheduler
Uses kernel-level threads if available
User-mode threads implement timeslicing
Each thread is allowed to execute for at most one quantum before preemption
Threads can yield to others of equal priority
Only necessary on nontimesliced systems
Threads waiting to run are called waiting, sleeping or blocked

82. Thread Scheduling – User level
Possible scheduling of user-level threads
50-msec process quantum
threads run 5 msec/CPU burst

83. Thread Scheduling – Kernel level
Possible scheduling of kernel-level threads
50-msec process quantum
threads run 5 msec/CPU burst