It is straightforward to generate parallelized code for loops for which there are no dependences, but in the presence of array privatization, the system must ensure that initial and final values of the array are copied to and from the private copies.
If an array has upwards-exposed read regions, the compiler must copy these regions into the private copy prior to execution of the parallel loop. If an array is live on exit of the loop, then after a parallel execution of the loop the array must contain the same values as those obtained had the loop been executed sequentially; we do not test array liveness on exit, so we limit privatization to those cases where every iteration in the loop writes to exactly the same region of data. To do so the analysis performs the following test to finalize a loop whose index i has upper bound ub: If , the last loop iteration is peeled, and this final iteration writes to the original array. Earlier iterations write to a private copy of the array. No peeling is necessary if the compiler can guarantee that the last processor executes the last iteration. Then the compiler can generate code which simply writes to private copies in all the processors except the last one.