## With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

No credit card required

The issues that we have discussed so far do not change when the loops are nested: if you apply the techniques only to the inner loop, they will work. However, there are some other, very subtle issues that may apply to inner loops. Let’s return to our two dimensional SinTable. As mentioned, a loop interchange should allow the outer loop to be threaded. However, instead of the loop transformation, let’s try to thread the inner loop:

```public float[][] getValues() {
for (int i = 0; i < 360; i++) {
lookupValues[0][i] = 0;
}
for (int j = 1; j < 1000; j++) {
for (int i = 0; i < 360; i++) {
float sinValue = (float)Math.sin((i % 360)*Math.PI/180.0);
lookupValues[j][i] = sinValue * (float)i / 180.0f;
lookupValues[j][i] += lookupValues[j-1][i]*(float)j/180.0f;
}
}
return lookupValues;
}```

The first variable that we will classify is the outer-loop index variable, `j`. We must classify this variable since it is used inside the inner loop. In this case, `j` is classified as a read-only variable. At first glance, this does not make sense: how could an index variable be read-only? We must only look at the scope that we are attempting to thread. During the execution of the inner loop, the variable has a single value that does not change throughout the entire execution of the loop.

While the `lookupValues` array variable is a shared variable, the elements can be classified as loop private. Since each iteration of the loop accesses a different member of the array based on the loop index ...

## With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, interactive tutorials, and more.

No credit card required