yonilipman, danielle.kut
Yonatan Lipman (305629750), Danielle Kutner (204094460)
EX: 2
FILES:
README -- this file
uthreads.cpp -- implementation of the thread library
Thread.cpp -- implementation of the Thread class methods
Thread.h -- Thread Class header
REMARKS:
We decided to implement the library's data structures in separate structures
that act as follows keeping in mind that they all work in FIFO:
Ready queue is a deque
Blocked and sleeping threads are vectors that act as queues.
We also use a min-heap in order to manage the thread id's which is implemented
using a priority_queue.
This allows us to manage the threads that share the same state in an easy to
access manner.
We have also thought about holding all of the threads in a single dast but we
decided that it was redundant and complex - thus the modular approach was
chosen.
ANSWERS:
1) Google Chrome creates a new process to have each tab run independently
from each other, such that if one process is blocked or runs into some
problem, the other tabs (processes) wont be affected by it.
We can achieve a similar benefit by running all of the tabs on one process,
but splitting them into independent kernel level threads, such that the
operating system would manage the threads context switch and if one thread
(tab) runs into some problem, it would not affect the other threads.
Another benefit that process share with kernel level threads is that
both can enjoy the utilization of multi-core Processors.
Advantages of creating new process (instead of kernel level threads):
* Processes have more resources (e.g memory)
* Processes can create multi-threads inside each process in order to
calculate tasks faster
* Stability - Failure in one process wont lead to failure in other processes
Disadvantages of creating new process (instead of kernel level threads):
* Requires more resources than threads
* Process Context switch has larger overhead than thread context switch.
2) The shell's kill command invokes the kill() system call, which sends
signal(s) to the process referenced by its PID via interrupt made by the
operating system.
The signals that could be send by the kill command are:
SIGTERM (default signal sent)
SIGKILL
we can choose which would be sent by adding a flag to the kill command.
SIGKILL cannot be caught by a processes signal handler, such that this
signal will kill the process without any consideration regarding the
processes state.
SIGTERM on the other hand, can be intercepted by a processes signal handler
which could invoke useful cleanup operation such as saving information into
a file), thus is more common in order to allow processes to handle their
forced termination.
Writing on the keyboard invokes constant interrupts which interprets what is
typed to the shell (process). when the kill command is invoked in the shell,
it invokes the system call kill() as mentioned above.
By simply using kill without flags, sends the SIGTERM signal which allows
the application to handle its forced termination as mentioned above.
3) The difference between 'real' and 'virtual' time, is that 'real' time is
continuous and is counted in every process, while 'virtual' time is
counted only in the duration of the process's active computation time.
'Real' time example: the OS's clock application utilizes a 'real' time
timer the keeps counting no which process is currently active.
'Virtual' time example: when we want to mesaure the runtime of a single
process in order to analyze its own running time. e.g the round robin
scheduling algorithm utilizes virtual time in order to give each thread
a uniform running time.
4) a) Fork duplicates the parent process's environment into the child process
up until the command where fork was invoked.
Fork uses Copy on Write, such that each process (parent and children)
share the same memory resources(stack, heap and global variables) until
one of them writes onto the requested memory, invoking an independent
copy of the memory. from this moment their resources arent shared and
they remain independent.
b) Pipe is an inter-process communication channel, which receives 2 fd's
that act as read and write, and allows to write from one process into
another process which will read the data. By default, the fd's are
STDIN and STDOUT, but this could be changed for piping between
different independent processes. It is needed because different processes
dont share the same memory and this allows them to communicate with each
other.