Semophores

Operating Systems

soft real time and hard real time
Hard real-time means you must absolutely hit every deadline. Very few systems have this requirement. Some examples are nuclear systems, some medical applications such as pacemakers, a large number of defense applications, avionics, etc.

Firm real time systems can miss some deadlines, but eventually performance will degrade if too many are missed. A good example is the sound system in your computer. If you miss a few bits, no big deal, but miss too many and you're going to eventually degrade the system. Similar would be seismic sensors. If you miss a few datapoints, no big deal, but you have to catch most of them to make sense of the data. More importantly, nobody is going to die if they don't work correctly.

Semaphore:
A Semaphore "S" is an integer variable,which is accessed only through two standard atomic operations-"wait" and "Signal".
Simplest ways to avoid busy waiting is to use a pair "sleep" and "wakeup".
"Sleep" is a system call that causes the caller to block,that is suspend until another process wakes it up.The wake uo call has one parameter,the process to be awaked.
wait is the generalization of sleep
Signal is the generalization of wakeup
Positive S indicates no. of successfull down operations that can be performed.
Negative S indicates no. of blocked processes

Details of Semaphore Operation
  Semaphore “s” is initially 1
  Before entering the critical section, a
thread calls “P(s)” or “wait(s)”
● wait (s):
  s = s – 1
  if (s < 0)
block the thread that called wait(s) on a
queue associated with semaphore s
  otherwise
let the thread that called wait(s) continue into
the critical section
  After leaving the critical section, a thread
calls “V(s)” or “signal(s)”
● signal (s):
  s = s + 1
  if (s ≤ 0), then
wake up one of the threads that called
wait(s), and run it so that it can continue
into the critical section

Semaphores (simplified slightly):
wait (s): signal (s):
s = s – 1 s = s + 1
if (s < 0) if (s ≤ 0)
block the thread wake up & run one of
that called wait(s) the waiting threads
otherwise
continue into CS
n Semaphore values:
● Positive semaphore = number of(additional) threads that can be allowed into the critical section
● Negative semaphore = number of threads blocked (note — there’s also one in CS)
● Binary semaphore has an initial value of 1
● Counting semaphore has an initial value greater than 1