Automated dynamic detection of busy–wait synchronizations

Abstract

With the advent of multicores, multithreaded programming has acquired increased importance. In order to obtain good performance, the synchronization constructs in multithreaded programs need to be carefully implemented. These implementations can be broadly classified into two categories: busy-wait and schedulebased. For shared memory architectures, busy-wait synchronizations are preferred over schedule-based synchronizations because they can achieve lower wakeup latency, especially when the expected wait time is much shorter than the scheduling time. While busy-wait synchronizations can improve the performance of multithreaded programs running on multicore machines, they create a challenge in program debugging, especially in detecting and identifying the causes of data races. Although significant research has been done on data race detection, prior works rely on one important assumption-the debuggers are aware of all the synchronization operations performed during a program run. This assumption is a significant limitation as multithreaded programs, including the popular SPLASH-2 benchmark have busy-wait synchronizations such as barriers and flag synchronizations implemented in the user code. We show that the lack of knowledge of these synchronization operations leads to unnecessary reporting of numerous races. To tackle this problem, we propose a dynamic technique for identifying user-defined synchronizations that are performed during a program run. Both software and hardware implementations are presented. Furthermore, our technique can be easily exploited by a record/replay system to significantly speedup the replay. It can also be leveraged by a transactional memory system to effectively resolve a livelock situation. Our evaluation confirms that our synchronization detector is highly accurate with no false negatives and very few false positives. We further observe that the knowledge of synchronization operations results in 23% reduction in replay time. Finally, we show that using synchronization knowledge livelocks can be efficiently avoided during runtime monitoring of programs.

Fence Placement for Legacy Data-Race-Free Programs via Synchronization Read Detection

“…Our work is related to prior work [Tian et al 2008[Tian et al , 2009Xiong et al 2010] on busy-wait synchronization detection. Tian et al [2008Tian et al [ , 2009 proposed a dynamic analysis technique for identifying user-defined busy-wait synchronizations. Because that work uses dynamic analysis, they suffer from false negatives: In other words, some synchronizations can be missed.…”

Isolating bugs in multithreaded programs using execution suppression

“…Thus, for other programs that may involve user-defined synchronization that is not explicitly marked in the code, existing techniques may need to be incorporated into our approach in order to automatically and accurately detect this synchronization. Tian et al [27,28] have recently described a dynamic technique to accomplish this.…”

Dead code elimination based pointer analysis for multithreaded programs

“…The first category mentioned above covers several directions of research; synchronization analysis, deadlock, data race, and memory consistency. The purpose in the analysis of synchronization constructs [6,7] is to clarify how the synchronization actions apart executions of program segments. The result of this analysis can be used by compiler to conveniently add join-fork constructs.…”