1,486 research outputs found
Exposing errors related to weak memory in GPU applications
© 2016 ACM.We present the systematic design of a testing environment that uses stressing and fuzzing to reveal errors in GPU applications that arise due to weak memory effects. We evaluate our approach on seven GPUS spanning three NVIDIA architectures, across ten CUDA applications that use fine-grained concurrency. Our results show that applications that rarely or never exhibit errors related to weak memory when executed natively can readily exhibit these errors when executed in our testing environment. Our testing environment also provides a means to help identify the root causes of such errors, and automatically suggests how to insert fences that harden an application against weak memory bugs. To understand the cost of GPU fences, we benchmark applications with fences provided by the hardening strategy as well as a more conservative, sound fencing strategy
Performance regression testing of concurrent classes
Developers of thread-safe classes struggle with two oppos-ing goals. The class must be correct, which requires syn-chronizing concurrent accesses, and the class should pro-vide reasonable performance, which is difficult to realize in the presence of unnecessary synchronization. Validating the performance of a thread-safe class is challenging because it requires diverse workloads that use the class, because ex-isting performance analysis techniques focus on individual bottleneck methods, and because reliably measuring the per-formance of concurrent executions is difficult. This paper presents SpeedGun, an automatic performance regression testing technique for thread-safe classes. The key idea is to generate multi-threaded performance tests and to com-pare two versions of a class with each other. The analysis notifies developers when changing a thread-safe class signif-icantly influences the performance of clients of this class. An evaluation with 113 pairs of classes from popular Java projects shows that the analysis effectively identifies 13 per-formance differences, including performance regressions that the respective developers were not aware of
Architecture Smells vs. Concurrency Bugs: an Exploratory Study and Negative Results
Technical debt occurs in many different forms across software artifacts. One
such form is connected to software architectures where debt emerges in the form
of structural anti-patterns across architecture elements, namely, architecture
smells. As defined in the literature, ``Architecture smells are recurrent
architectural decisions that negatively impact internal system quality", thus
increasing technical debt. In this paper, we aim at exploring whether there
exist manifestations of architectural technical debt beyond decreased code or
architectural quality, namely, whether there is a relation between architecture
smells (which primarily reflect structural characteristics) and the occurrence
of concurrency bugs (which primarily manifest at runtime). We study 125
releases of 5 large data-intensive software systems to reveal that (1) several
architecture smells may in fact indicate the presence of concurrency problems
likely to manifest at runtime but (2) smells are not correlated with
concurrency in general -- rather, for specific concurrency bugs they must be
combined with an accompanying articulation of specific project characteristics
such as project distribution. As an example, a cyclic dependency could be
present in the code, but the specific execution-flow could be never executed at
runtime
- …