Model checking for programming languages using VeriSoft
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Replay and Testing for Concurrent Programs
IEEE Software
Concurrent Bug Patterns and How to Test Them
IPDPS '03 Proceedings of the 17th International Symposium on Parallel and Distributed Processing
Heuristics for Finding Concurrent Bugs
IPDPS '03 Proceedings of the 17th International Symposium on Parallel and Distributed Processing
OOPSLA '04 Companion to the 19th annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications
Stress testing real-time systems with genetic algorithms
GECCO '05 Proceedings of the 7th annual conference on Genetic and evolutionary computation
Using genetic algorithms for early schedulability analysis and stress testing in real-time systems
Genetic Programming and Evolvable Machines
Concurrency and Computation: Practice & Experience - Parallel and Distributed Systems: Testing and Debugging (PADTAD)
Reachability Testing of Concurrent Programs
IEEE Transactions on Software Engineering
Atomizer: A dynamic atomicity checker for multithreaded programs
Science of Computer Programming
CTrigger: exposing atomicity violation bugs from their hiding places
Proceedings of the 14th international conference on Architectural support for programming languages and operating systems
IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
Hi-index | 0.00 |
Managing and controlling interference conditions in multi-threaded programs has been an issue of worry for application developers for a long time. Typically, when write events from two concurrent threads to the same shared variable are not properly protected, an occurrence of the interference bug pattern could be exposed. We propose a mathematical formulation and its resolution to maximize the possibility of exposing occurrences of the interference bug pattern. We formulate and solve the issue as an optimization problem that gives us (1) the optimal position to inject a delay in the execution flow of a thread and (2) the optimal duration for this delay to align at least two different write events in a multi-threaded program. To run the injected threads and calculate the thread execution times for validating the results, we use a virtual platform modelling a perfectly parallel system. All the effects due to the operating system's scheduler or the latencies of hardware components are reduced to zero, exposing only the interactions between threads. To the best of our knowledge, no previous work has formalized the alignment of memory access events to expose occurrences of the interference bug pattern. We use three different algorithms (random, stochastic hill climbing, and simulated annealing) to solve the optimization problem and compare their performance. We carry out experiments on four small synthetic programs and three real-world applications with varying numbers of threads and read/write executions. Our results show that the possibility of exposing interference bug pattern can be significantly enhanced, and that metaheuristics (hill climbing and simulated annealing) provide much better results than a random algorithm.