NAME

       pip_stress - Priority Inheritance with processes

SYNOPSIS

       pip_stress

DESCRIPTION

       This program demonstrates the technique of using priority inheritance (PI) mutexes with processes instead
       of  threads.   The  way  to do this is to obtain some shared memory - in this case with mmap that backs a
       pthread_mutex_t since this will support PI.  Pay particular  attention  to  how  this  is  intialized  to
       support  processes.   Function  init_shared_pthread_mutex() does this by setting the pthread_mutexattr to
       PTHREAD_PROCESS_SHARED and the mutex protocol to PTHREAD_PRIO_INHERIT.  In this program we purposely  try
       to  invoke  a  classic priority inversion.  A low priority process grabs the mutex and does some work.  A
       high priority process comes a long and is blocked since the mutex is taken.  A  medium  priority  process
       that doesn't require the mutex then takes the processor. Because the processes are restricted to one cpu,
       the  low  priority  processes  never  makes  any  progress because the medium priority process runs in an
       infinite loop. This is a priority inversion because  the  medium  priority  process  is  running  at  the
       expensive  of  the  high  priority process. However, since we have used PRIO_INHERIT and are running on a
       machine that supports preemption, the high priority process will lend it's priority to the  low  priority
       process  which  will  preempt the medium priority process. The low priority process will then release the
       mutex which the high priority process can obtain. When the high priority process gets to run it kills the
       medium priority process.  The state structure keeps track of the progress. Although this program  is  set
       up to likely trigger an inversion, there is no guarantee that scheduling will make that happen. After the
       program  completes  it  reports whether a priority inversion occurred or not. In either case this program
       demonstrates how to use priority inheritance mutexes with processes.  In fact, you would be better off to
       avoid scenarios in which a priority inversion occurs if possible - this program  tries  to  trigger  them
       just  to  show  that  it works. If you are having difficulty triggering an inversion, merely increase the
       time that the low priority process sleeps while holding the lock. (usleep); Also note that  you  have  to
       run as a user with permission to change scheduling priorities.

AUTHOR

       pip_stress was written by John Kacur <jkacur at redhat.com>

       This manual page was also written by John Kacur

                                               September 17, 2018                                  PIP STRESS(8)