A probe effect in concurrent programs

Reviewer: John Gauntlett Benedict Heal

We have all experienced programs which, like children, behave perfectly when being monitored, but cease to do so as soon as they are unleashed in a real environment. In this short paper, the author is concerned with this effect in the context of concurrent programs. He terms a “probe effect” any change in the correctness of execution, which results when delays are introduced into concurrent programs which contain errors in the synchronization logic. Correct programs would clearly be immune to the insertion of extra delay. Incorrect ones may sometimes start to work correctly, though having failed to do so without the delay; alternatively, a previous, apparently functioning program may cease behaving correctly when unrelated program modifications introduce extra delays. The paper describes experiments done to investigate the nature of this probe effect. A varying number of identical tasks, incorporating a typical synchronization error of a misplaced semaphore operation when writing to shared memory, were run concurrently under the nondeterministic scheduling of UNIX V7. In the given program, correct final values could sometimes arise even for some incorrect sequences of writes. Synchronization errors were detectable by both incorrect final values in the shared memory and incorrect sequences of writes in a log file of memory operations provided by the CBUG debugging environment. (CBUG also provided the means of introducing varying delays between the statement executions in the program.) Experiments were done varying the number of processes and the interstatement delay. The ratio of successful runs for each configuration was plotted against the inserted delay. Success was considered first as a correct final value, reached after a correctly ordered sequence of write operations. Later it was considered simply as a correct final value, ignoring “shared memory side-effects” of incorrect write sequences. All of the graphs show the same phenomenon—they indicate a stable region in which uniformly correct behavior results from large values of the delay, thus masking the logic error. For small values of the delay, there is a very unstable region, in which a small change to the delay produces very large changes in the proportion of successful runs. It is in this area that extra delays introduced with trivial program changes can have dramatic effects on the successful behavior of a program. The paper is an exciting and tantalizing introduction to a new way of looking at certain program malfunctions. Having been shown the phenomenon, though, it is a pity that there is not more in the way of discussion, particularly in attempting to relate the onset of the unstable behavior with the size of other delays in the system.