Busy Waiting Article Index for
Busy 		Website Links For
Busy 		 

Information About

Busy Waiting
  CATEGORIES ABOUT BUSY WAITING
   
software engineering
   
anti-patterns
   
programming constructs
   
concurrency control
   
articles with example c code
   
APPAREL
BABY
BEAUTY
BOOKS
CAR TOYS
CELL PHONES
DVD'S
ELECTRONICS
GOURMET FOOD
GROCERIES
HEALTH & PERSONAL
HOME & GARDEN
JEWELRY
MUSIC
MUSIC INSTRUMENTS
OFFICE PRODUCTS
SOFTWARE
SPORTING GOODS
TOOLS & HARDWARE
TOYS
VIDEO GAMES
SHOPPING HOME
MORE SHOPPING...




EXAMPLE C CODE

The C code below shows two threads that share a global Integer i. The first thread uses busy waiting to check for a change in the value of i.


#include < Stdio.h >
#include < Pthread.h >
#include

  • i is global, so it is visible to all functions.

    • It's also marked Volatile , because it will change

in a way which is not predictable by the compiler
  • /


  • t1 uses a spinlock to wait for i to change from 0. ---/

  • f1()

    • {

while (i==0) {
  • do nothing - just keep checking over and over ---/

    • }

Printf ("i's value has changed to %d.
", i);

return NULL;
}

  • f2()

    • {

  • sleep for 60 seconds ---/

    • i = 99;

printf("t2 has changed the value of i to %d.
", i);

return NULL;
}

int main()
{
int rc;
pthread_t t1, t2;

i = 0;

rc = pthread_create(&t1, NULL, f1, NULL);
if (rc != 0) {
puts("pthread foo failed.");
}

rc = pthread_create(&t2, NULL, f2, NULL);
if (rc != 0) {
puts("pthread bar failed.");
}

pthread_join(t1, NULL);
pthread_join(t2, NULL);
puts("All pthreads finished.");
return 0;
}


On a Unix-like system, you can compile the above code like this:
$ cc spinlock.c -lpthread


CPU UTILIZATION

In the above code, the second thread immediately goes to sleep for 60 seconds. Meanwhile, the first thread checks repeatedly if the second thread has changed the value of i.

You can use the top or uptime utility found on Unix-like operating systems to see how this program utilizes the CPU. Run the program like this:
$ uptime; ./a.out ; uptime
13:25:47 up 53 days, 23:50, 4 users, load average: 0.00, 0.00, 0.00
t2 has changed the value of i to 99.
i's value has changed to 99.
All pthreads finished.
13:26:47 up 53 days, 23:51, 4 users, load average: 0.75, 0.21, 0.07

Of course, every system will return slightly different numbers, but the important thing to notice is that before we ran the program, the system load average for the previous 60 seconds was 0.00. After the program ran, the system load average bumped up to 0.75 for the last minute.


ALTERNATIVES TO BUSY WAITING

Most operating systems and threading libraries provide a wide set of System Call s which will Block the process on an event, such as lock acquisitions, timers, I/O availability, or Signals . This is often the simplest, most efficient, fair, and Race -free way. A single call checks, informs the scheduler of the event it is waiting for, inserts a Memory Barrier where applicable, and may perform a requested I/O operation before returning. Other processes can use the CPU while the caller is blocked. The scheduler is given the information needed to implement Priority Inheritance or other mechanisms to avoid Starvation .

Busy waiting itself can be made much less wasteful by using a "delay" function found on most operating systems. This puts a thread to sleep for a specified time, during which the thread will waste no CPU time. If the loop is checking something simple then it will spend most of its time asleep and will not waste a large proportion of the available CPU time. It will still consume some CPU time though.


WHEN BUSY WAITS ARE APPROPRIATE

In low-level hardware driver programming, sometimes busy waits are actually desirable. It is not practical to implement hardware interrupt-based signalling for every hardware device, particularly for devices that are seldom accessed. Sometimes it is necessary to write some sort of control data to a hardware device and then read back some sort of status data, which is not valid until several, perhaps even tens of clock cycles later. The programmer could call an operating system delay function, but more time would be spent simply performing the function call (let alone switching to an interim thread) than is required by the hardware. In such cases, it is common to implement a busy wait that keeps reading the status data until it is valid. Calling a delay function in this case would actually waste CPU time due to the comparatively large overhead involved in the function call and thread switching.


SEE ALSO



EXTERNAL LINKS