## On-The-Fly Detection of Access Anomalies (1998)

Venue: | In Proceedings of the SIGPLAN 1989 Conference on Programming Language Design and Implementation |

Citations: | 71 - 0 self |

### BibTeX

@INPROCEEDINGS{Schonberg98on-the-flydetection,

author = {Edith Schonberg},

title = {On-The-Fly Detection of Access Anomalies},

booktitle = {In Proceedings of the SIGPLAN 1989 Conference on Programming Language Design and Implementation},

year = {1998},

pages = {285--297}

}

### Years of Citing Articles

### OpenURL

### Abstract

Access anomalies are a common class of bugs in shared-memory parallel programs. An access anomaly occurs when two concurrent execution threads both write (or one thread reads and the other writes) the same shared memory location. Approaches to the detection of access anomalies include static analysis, post-mortem trace analysis, and onthe -fly monitoring. A general on-the-fly algorithm for access anomaly detection is presented, which can be applied to programs with both nested fork-join and synchronization operations. The advantage of on-the-fly detection over post-mortem analysis is that the amount of storage used can be greatly reduced by data compression techniques and by discarding information as soon as it becomes obsolete. In the algorithm presented, the amount of storage required at any time depends only on the number V of shared variables being monitored and the number N of threads, not on the number of synchronizations. Data compression is achieved by the use of two techniques...

### Citations

89 | The Design and Analysis of Computer Algorithms (Addison-Wesley - Aho, Hopcroft, et al. - 1974 |

1 |
prove Lemma 3, we show that for an execution instance P that includes fork, join, and synchronous coordination operations, there is an execution instance Q that simulates P, such that Q consists of M tasks executing only synchronous coordination operation
- To
(Show Context)
Citation Context ... step, as follows: ________________________________ 2 This construction is due to Peter Frankl [Fr]. Ultracomputer Note 149sA monitored variable v is removed from the read (resp. write) subset of S y =-=(t)-=- iff v is in the read (resp. write) subset of S x (t) and CL y (t) is a subset of CL x (t). We justify subtraction as follows. Suppose CL y (t) is a subset of CL x (t). Subsequently, any shared variab... |

1 |
time t = 0, the claim clearly is true. Ultracomputer Note 149 Assuming the hypothesis is true at time t, we consider concurrency lists at time t + 1. For each new concurrency list CL
- At
(Show Context)
Citation Context ...nt. Therefore, if the tasks T i 1 , . . . , T i n execute a join together, the update operation is similar to the synchronous coordination rule: (3c) Update. For each complete shared variable set S z =-=(t): (i-=-) If all of T i 1 , . . . , T i n are in the concurrency list CL z (t - 1), CL z (t) = CL z (t - 1) - {T i 1 , . . . , T i n } �� {T i }; (ii) otherwise, CL z (t) = CL z (t - 1) - {T i 1 , . . . ,... |

1 |
the claim holds at t + 1. Case 2. The operation at time t + 1 is a fork executed by task T i , creating k tasks. Let T j be a task created by the fork. If T i is
- Therefore
(Show Context)
Citation Context ...nt. Therefore, if the tasks T i 1 , . . . , T i n execute a join together, the update operation is similar to the synchronous coordination rule: (3c) Update. For each complete shared variable set S z =-=(t): (i-=-) If all of T i 1 , . . . , T i n are in the concurrency list CL z (t - 1), CL z (t) = CL z (t - 1) - {T i 1 , . . . , T i n } �� {T i }; (ii) otherwise, CL z (t) = CL z (t - 1) - {T i 1 , . . . ,... |

1 |
by the update rule for fork
- then
(Show Context)
Citation Context ...er Note 149sAt time t, we consider every sequential block B x that is currently executing, starting to execute, or has finished executing, and associate with each such block a shared variable set S x =-=(t)-=-. S x (t) consists of two subsets: the shared variables read in B x and the shared variables written in B x by time t. Two shared variable sets are said to be concurrent if the sequential blocks assoc... |

1 | prove the claim, we must show that - To |

1 | The operation at time t + 1 is a join. If T i is added to CL x P - Case |

1 | i ) cannot be assigned to any task T existing between the time that B x finishes and t + 1. It follows that AS(T i ) must be in the concurrency list of CL Q - Therefore |

1 | complete the proof, we must show that the correspondence of concurrency lists in P to concurrency lists in Q is 1-1. More precisely, if two concurrency lists CL y 1 Q - To |

1 |
R is not assigned to any task that is currently executing at time t. At time t = 0, the claim clearly is true. Assuming the hypothesis is true at time t, we consider concurrency lists at time t + 1. The claim clearly holds for new concurrency lists associ
- then
(Show Context)
Citation Context ...nt. Therefore, if the tasks T i 1 , . . . , T i n execute a join together, the update operation is similar to the synchronous coordination rule: (3c) Update. For each complete shared variable set S z =-=(t): (i-=-) If all of T i 1 , . . . , T i n are in the concurrency list CL z (t - 1), CL z (t) = CL z (t - 1) - {T i 1 , . . . , T i n } �� {T i }; (ii) otherwise, CL z (t) = CL z (t - 1) - {T i 1 , . . . ,... |

1 |
after the barrier synchronization operations
- then
(Show Context)
Citation Context ...er Note 149sAt time t, we consider every sequential block B x that is currently executing, starting to execute, or has finished executing, and associate with each such block a shared variable set S x =-=(t)-=-. S x (t) consists of two subsets: the shared variables read in B x and the shared variables written in B x by time t. Two shared variable sets are said to be concurrent if the sequential blocks assoc... |

1 | The operation at time t + 1 is a join. If a task T j executes the join operation and is not - Case |

1 | j is not a currently executing at time t + 1. If T i begins executing after the join, and is not - unknown authors |

1 | for some T j that executes the join, T j is not - then |

1 |
the barrier synchronization operations corresponding to the join
- After
(Show Context)
Citation Context |