In a homogeneous environment we think of a global variable as having the same value on each process, but of course this may not be true of floating point values in a heterogeneous environment.
Where possible, the high level routines in the ScaLAPACK and NAG Libraries check arguments supplied by users for their validity in order to aid users and provide as much reliability as possibility. In particular, global arguments are checked. When these global arguments are floating point values they may of course, for the reasons previously discussed, have different values on different processors.
This raises the question of how, and even whether, such arguments should be checked, and what action should be taken when a failure occurs. If we compare the values, they may not be the same on each process, so we need to allow a tolerance based upon the multiprocessor machine precision. Alternatively, we can check a global argument on just one process and then, if the value is valid, broadcast that value to all the other processes. Of course this alternative approach has extra overhead, but it may be the most numerically sound solution, since the library routine has algorithmic control, and puts slightly less burden on the user.
Similar issues occur whenever we communicate a floating point value from one processor to another. Unless we have special knowledge, and one such case will be discussed in the next section, we should not assume that the target processor will have exactly the same value as the sending processor and we must write the code accordingly.