CS2106 Introduction to
Operating Systems
Basics
Operating Systems ...
- Manages resources and coordination (process
synchronization, resource sharing)
- Simplify programming (abstraction of hardware,
convenient services)
- Enforce usage policies
- Security of protection
- User program portability (across different hardware)
- Efficiency (optimized for particular usage and hardware)
Kernel mode: complete access to all hardware resources
User mode: limited access to hardware resources
Monolithic OS: Kernel is one big special program
Microkernel OS: Kernel is very small and clean, and only
provide basic and essential facilities (e.g. IPC, address space
management, thread management); higher-level services
(device driver, process management, memory management,
file system) built on top of basic facilities and runs outside
the OS (using IPC to communicate). Kernel is more robust,
and there is more isolation and protection between kernel
and higher-level services, but at lower performance.
Type 1 Hypervisor: Runs directly on hardware
Type 2 Hypervisor: Runs on a host operating system
Process Abstraction
Generic 5-State Process Model:
Running
Ready
Generic 5-State Process Model
48
[ CS2106 L2 -AY1819S1 ]
admit
switch: scheduled exit
event wait
event occurs
create
switch:
release CPU
Notes: generic process states, details vary in actual OS
New
Blocked
Terminated
Process Control Block (PCB): information about a
process: registers, memory region info, PID, process state
Syscall mechanism:
1. User program invokes library call
2. Library call places the syscall number of designated
location (e.g. register)
3. Library call executes TRAP instruction to switch to
kernel mode
4. Appropriate system call handler is determined using the
syscall number as index (usually handled by a dispatcher)
5. Syscall handler is executed (this carries out the actual
request)
6. Control returned to library call, switched back to user
mode
7. Library call returns to user program
Exception: Synchronous (occurs due to program
execution, e.g. arithmetic errors, memory access errors).
Executes an exception handler, like a forced syscall.
Interrupt: Asynchronous (occurs independent of program
execution, e.g. timer, mouse movement, keypress). Executes
an interrupt handler, program execution is suspended.
Process Abstraction in Unix
pid t fork(void):
Parent returns PID of child, child returns zero
int execl(const char *path, const char *arg, ...)
int execv(const char *path, char *const argv[])
e.g. execl("/bin/ls", "ls", "-la", NULL)
init process is the root process (traditionally PID=1)
int wait(int *status)
Set status to NULL to ignore status
Least significant 8 bits is the value passed to exit(int)
Process Scheduling
Non-preemptive (Cooperative): Process stays
scheduled until it blocks or yields
Preemptive: At the end of time quota, the process is
suspended (it is still possible to block or yield early)
Batch Processing
No user interaction, non-preemptive scheduling is predominant
Turnaround time: Total time taken from arrival to finish
(including waiting time)
Throughput: Number of tasks finished per unit time
CPU utilization: Percentage of time CPU is doing work
First-come first-served: Use FIFO queue based on
arrival time (when tasked is blocked it is removed; it is
placed at the back of queue when it is ready again).
Guaranteed to have no starvation
Shortest Job First: Select task with smallest CPU time
(until next I/O). Starvation is possible because long job
may never get a chance (when short jobs keep arriving).
Prediction of CPU time usually uses exponential average of
history
Shortest Remaining Time: Preemptive version of SJF
Convoy effect: Many tasks contend for CPU (while I/O is
idle), and then contend for I/O (while CPU is idle)
Interactive Environment
Preemptive scheduling algorithms are used to ensure good
response time
Response time: Time between request and response by
system
Predictability: Less variation in response time Time
quantum: Execution duration given to a process, must be
a multiple of timer interrupt
Round robin: Like First-come first-served, but will be
interrupted when time quantum elapses
Priority scheduling: Each task gets a priority, highest
priority gets scheduled first.
Preemptive variant: new higher priority process preempts
currently running lower priority process
Non-preemptive variant: new higher priority process has to
wait for next round of scheduling
Low priority process can starve
Priority inversion: higher priority task forced to block while
lower priority task gets to run
Multi-level feedback queue:
If P riority(A)> P riority(B) then Aruns
If P riority(A) == P r iority(B) then round-robin
New job gets highest priority
If a job fully utilized its time slice then priority reduced
If a job yields/blocks then priority retained
Lottery scheduling: Lottery tickets assigned to processes
(possibly unevenly depending on priority), and randomly
chosen winner is allowed to run (preemptive)
Parent can distribute tickets to its child processes, and each
shared resource (CPU, I/O) can have its own set of tickets
Threads
“Lightweight process”
Benefits:
Much less additional resources needed as compared to
processes
No need for additional mechanism to pass information
between threads
Multithreaded programs can appear much more responsive
Multithread programs can take advantage of multiple CPUs
Problems:
Parallel syscall possible - have to guarantee correctness
Process behaviour - fork()/exec()/exit() when there are
multiple threads
User thread: Thread is implemented as a user library
(just library calls); kernel is not aware of the threads
- Implemented by library: more flexible, e.g. customized
thread scheduling policy - One thread blocked -¿ all threads
blocked - Cannot exploit multiple CPUs
Kernel thread: Thread is implemented in the OS (using
syscalls); thread-level scheduling is possible - Multiple
threads from same process can run simultaneously - Thread
operations are syscalls: more resource-intensive and slower -
Less flexible, so it can be generic enough for all
multithreaded programs
Hybrid thread model: User thread can bind to a kernel
thread
Hybrid Thread Model
Have both Kernel and User threads
OS schedule on kernel threads only
User thread can binds to a kernel thread
Offer great flexibility
Can limit the
concurrency
of any process / user
20
[ CS2106 L4 - AY1819S1 ]
int pthread_create(pthread_t *thread,
const pthread_attr_t *attr /*NULL*/,
void *(*start_routine) (void *) /*function ptr*/,
void *arg /*argument for start_routine*/);
int pthread_exit(void *retval);
int pthread_join(pthread_t thread, void **retval);
Inter-Process Communication
Shared memory
Advantages:
Efficient (only the initial steps involves OS)
Easy to use (shared mem region behaves like normal mem)
Disadvantages:
Synchronization (of access)
Implementation is usually harder
int shmget(key_t key /*can be IPC_PRIVATE*/,
size_t size, int shmflg /* IPC_CREAT | 600*/);
//IPC_CREAT means memory will be created if nonexistent
void *shmat(int shmid, const void *shmaddr /*NULL*/,
int shmflg /*0*/);
int shmdt(const void *shmaddr);
int shmctl(int shmid, int cmd /*IPC_RMID*/,
struct shmid_ds *buf /*unused for IPC_RMID*/);
Message passing
Messages stored in kernel memory space
Direct communication:
Sender/receiver explicitly names the other party
One buffer per pair of (sender, receiver)
Indirect communication:
Sender sends to mailbox/port
Receiver receives from mailbox/port
Blocking primitives (synchronous):
Send() blocks until message is received
Receive() blocks until message has arrived
Non-blocking primitives (asynchronous):
Send() does not block
Receive() returns some indication if no message is available
Advantages:
Portable (can implement in distributed system or network)
Easier synchronization (blocking primitives implicitly
synchronize sender/receiver)
Disadvantages:
Inefficient (needs OS intervention)
Harder to use (messages limited in size/format)
Unix Pipes
Pipes function as fixed-size circular byte buffer with implicit
synchronization
- writers wait when buffer is full
- readers wait when buffer is empty
int pipe(int pipefd[2]); // create new pipe
pipefd[0]: file descriptor for reading
pipefd[1]: file descriptor for writing
Unix Signals
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
// returns previous signal handler, or SIG_ERR on error
