Re: Safety and legality of optimizations

Cliff Click <cliffc@crocus.hpl.hp.com> wrote:
>Moving I/O across a potentially infinite loop is bad.
>However, you _can_ move everything else across the loop, as long as you
>preserve all data- & control- dependences. You can even move other
>potentially infinite loops across.


This is not quite true, especially in certain system applications
where multiple threads or processes might be active. A typical case is
when spinlocks/busy-waits are used for implementing critical sections.
A critical section may contain non-I/O statements that manipulate a
shared data structure, e.g. a bounded buffer. The lock-variable
itself might be declared as volatile, but not necessarily the data
structure being manipulated in the critical section:




#define LOCKED 1
#define FREE 0
      volatile int lock;


              ...


void worker(...) {


      int old = LOCKED;
      /*
        * try to acquire the lock
        */
      do { /* potentialy infinite loop */
          while (lock == LOCKED) {}
          old = atomic_exchange(lock, old);
      } while (old == LOCKED);


      /*
        * critical section code;
        */


            ...


      /*
        * release the lock.
        */
        lock = FREE; /* assume atomic store */
              ...


}


In the above example you don't want the critical section code to be moved
out.


--Vinod Grover
--

Return to the comp.compilers page.
Search the comp.compilers archives again.