RTS

1) Least slack time (LST) scheduling is a scheduling algorithm. It assigns priority based on
the slack time of a process. Slack time is the amount of time left after a job if the job was
started now. This algorithm is also known as least laxity first. Its most common use is in
embedded systems, especially those with multiple processors. It imposes the simple
constraint that each process on each available processor possesses the same run time, and
that individual processes do not have an affinity to a certain processor.
In PIP, whenever a request for a resource is made, the resource will be
2)
allocated to the requesting task if it is free. However, in PCP a resource may not
be granted to a requesting task even if the resource is free. This strategy in PCP
helps in avoiding potential deadlocks.

3) Fault tolerance is often considered as a good additional feature for multiprocessor systems but nowadays it is
becoming an essential attribute. Fault tolerance can beachieved by the use of dedicated customized hardware that
may have the disadvantage of large cost. Another approach to fault tolerance is to exploit existing redundancy
in multiprocessor systems via a task scheduling software strategy based on time redundancy. Time redundancy
reduces the expense of additional hardware needed to achieve fault tolerance at the expense of additional
computation time, which is more affordable.
4)PCP overcomes unbounded priority inversions because whenever a high priority
task waits for some resources which are currently being used by a low priority
task, then the executing lower priority task is made to inherit the priority of the
higher priority task. So, the intermediate priority tasks cannot preempt lower
priority task from CPU usage. Therefore, unbounded priority inversions cannot
occur in PCP.
Tasks are single blocking under PCP. That means, under PCP a task can undergo at
most one inversion during its execution. This feature of PCP prevents chain
blocking.
5) A basic difference between multiprocessor and distributed systems is sharing
of physical memory. Multiprocessor systems (aka. tightlycoupled systems) are
characterized by the existence of a shared physical memory. In contrast, a
distributed system (aka. looselycoupled system) is devoid of any shared physical
memory. In a tightlycoupled system, the interprocess communication is
inexpensive and is achieved through read and writes to the shared memory.
However, the same is not true for distributed systems where intertask
communication times are comparable to the task execution times. Due to this, a
multiprocessor system may use a centralized scheduler/dispatcher whereas a
distributed system cannot.
6) A task is a piece of code that is to be run within a single thread of execution. A task
issues a sequence of jobs to the processor which are queued and executed.
The time spent by the job actively using processor resources is its execution time. The
execution time of each job instance from the same task is likely to differ.
Common sources of variation are path data dependencies (the path taken through the code
depends on input parameters) and hard-to-predict hardware features such as branch
prediction, instruction pipelining and caches.
The response time for a job is the time between when it becomes active (e.g. an external
event or timer triggers an interrupt) and the time it completes. Several factors can cause the
response time of a job to be longer than its execution time.
7)It is the average time between a request to lock a semaphore , which is locked by another process and
the time when it request is granted
8) Asynchronous I/O means nonblocking I/O. Under synchronous I/O system
calls, a process needs to wait till the hardware has completed the physical I/O.
Thus, in case of synchronous I/O, the process is blocked while it waits for the
results of the system call.
On the other hand, if a process uses asynchronous I/O, then the system call will
return immediately once the I/O request has been passed down to the hardware
or queued in the operating system typically before the physical I/O operation has
even begun. The execution of the process is not blocked because it does not
needto wait for the results of the system call. This helps in achieving deterministic
I/O times in an RTOS.
9) The following example shows why 2PLWP protocol is free from
deadlocks. two transactions T1 and T2 which need
access to two data items d1 and d2.
T1: Lock d1, Lock d2, Unlock d2, Unlock d1
T2: Lock d2, Lock d1, Unlock d1, Unlock d2
Assume that T1 has higher priority than T2. T2 starts running first and locks
data item d2. After some time, T1 locks d1 and then tries to lock d2 which is
being held by T2. As a consequence T1 blocks, and T2 needs to lock the data
item d1 being held by T1. Now, the transactions T1 and T2 are deadlocked.
10. The following are the main differences between a realtime database and a
conventional database:
Unlike traditional databases, timing constraints are associated with the
different operations carried out on realtime databases.
Realtime databases have to deal with temporal data compared to static
data as in the case of traditional databases.
 The performance metrics that are meaningful to the transactions of these
two types of databases are very different.