Recently Read

Research is much about reading, so here are publications listed I have recently read. This list is imported from my BibSonomy account.
  • Marr, Stefan and Torres Lopez, Carmen and Aumayr, Dominik and Gonzalez Boix, Elisa and Mössenböck, Hanspeter, Kómpos: A Platform for Debugging Complex Concurrent Applications, ACM, 2017. bibtex pdf
    @presentation{Marr:2017:KomposDemo, abstract = {With the omnipresence of multicore processors, developers combine various concurrency abstractions such as actors, communicating sequential processes, or fork/join programming to utilize the available parallelism. Unfortunately, when we debug such systems today, we need to reason about low-level memory accesses, locks, and thread pools, because debuggers rarely know about actors, messages, channels, or fork/join tasks. With Kómpos, we present a concurrent debugger that is designed to enable us to reason about our programs on the level of these abstractions. We will demonstrate some of the features of Kómpos and discuss the research challenges for building a concurrent debugger for a wide range of concurrency abstractions.},
      author = {Marr, Stefan and Torres Lopez, Carmen and Aumayr, Dominik and Gonzalez Boix, Elisa and Mössenböck, Hanspeter},
      booktitle = {Proceedings of the International Conference on the Art, Science, and Engineering of Programming},
      day = 2, interhash = {9abcfadddac4f838ffbbf883d41bbde9},
      intrahash = {2e2d63d8a518c585cfd8d79175cab10a},
      month = {April},
      pages = 2, pdf = {http://stefan-marr.de/downloads/progdemo-marr-et-al-kompos-a-platform-for-debugging-complex-concurrent-applications.pdf},
      publisher = {ACM},
      series = {Programming'17},
      title = {{Kómpos: A Platform for Debugging Complex Concurrent Applications}},
      type = {Demo},
      year = 2017 }
  • S. Keidel, W. Pfeiffer, and S. Erdweg, "The IDE Portability Problem and Its Solution in Monto," in Proceedings of the 2016 ACM SIGPLAN International Conference on Software Language Engineering, 2016, pp. 152-162. bibtex doi
    @inproceedings{Keidel:2016:IPP, abstract = {Modern IDEs support multiple programming languages via plug-ins, but developing a high-quality language plug-in is a huge development effort and individual plug-ins are not reusable in other IDEs. We call this the IDE portability problem. In this paper, we present a solution to the IDE portability problem based on a language-independent and IDE-independent intermediate representation (IR) for editor-service products. This IR enables IDE-independent language services to provide editor services for arbitrary IDEs, using language-independent IDE plug-ins. We combine the IR with a service-oriented architecture to facilitate the modular addition of language services, the decomposition of language services into smaller interdependent services, and the use of arbitrary implementation languages for services. To evaluate the feasibility of our design, we have implemented the IR and architecture in a framework called Monto. We demonstrate the generality of our design by constructing language services for Java, JavaScript, Python, and Haskell and show that they are reusable in the Eclipse IDE and in a web-based IDE. We also evaluate the performance of Monto and show that Monto is responsive and has admissible performance overhead.},
      author = {Keidel, Sven and Pfeiffer, Wulf and Erdweg, Sebastian},
      booktitle = {Proceedings of the 2016 ACM SIGPLAN International Conference on Software Language Engineering},
      doi = {10.1145/2997364.2997368},
      interhash = {d0bbc415b73407e56be310f8e7fd626f},
      intrahash = {c922aa00bb774b27c96caad08b6f2617},
      isbn = {978-1-4503-4447-0},
      location = {Amsterdam, Netherlands},
      numpages = {11},
      pages = {152--162},
      publisher = {ACM},
      series = {SLE '16},
      title = {{The IDE Portability Problem and Its Solution in Monto}},
      year = 2016 }
  • Van De Vanter, Michael, Building Flexible, Low-Overhead Tooling Support into a High-Performance Polyglot VM: Extended Abstract, 2017. bibtex html
    @presentation{MVDV:2017:MoreVMs, abstract = {The disconnect between programming languages and the developer tools needed to make them useful has grown wide since the days of programming systems with integral tool support, such as Self (1989), Smalltalk (1980), and Lisp (1965). Tools now are typically an afterthought: expensive to develop, delivered late if ever, and arrive with undesirable performance trade-offs. The time has come to build modern programming systems. We can do that by embedding flexible, reusable, low-overhead instrumentation and tool support deeply into modern Virtual Machines. We can “have it all”, but only if we can re-establish close collaboration between language engineers (who optimize utilization of expensive machines) and tool builders (who optimize utilization of expensive people).},
      author = {Van De Vanter, Michael},
      booktitle = {Workshop on Modern Language Runtimes, Ecosystems, and VMs},
      day = 2, interhash = {b30a33fba831616f18007aa329a2a45d},
      intrahash = {b3c397d020aaa7fe2fd35f7ea23f5b3b},
      month = {April},
      pages = 3, series = {MoreVMs'17},
      title = {{Building Flexible, Low-Overhead Tooling Support into a High-Performance Polyglot VM: Extended Abstract}},
      type = {Extended Abstract},
      url = {http://vandevanter.net/mlvdv/publications/mlvdv-morevms-2017.pdf},
      year = 2017 }
  • M. L. Van De Vanter, "Building Debuggers and Other Tools: We Can "Have It All"," in Proceedings of the 10th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems, 2015, p. 2:1-2:3. bibtex doi
    @inproceedings{VanDeVanter:2015:BDO, abstract = {Software development tools that "instrument" running programs, notably debuggers, are presumed to demand difficult tradeoffs among performance, functionality, implementation complexity, and user convenience. A fundamental change in our thinking about such tools makes that presumption obsolete. By building instrumentation directly into the core of a high-performance language implementation framework, tool-support can be always on, with confidence that optimization will apply uniformly to instrumentation and result in near zero overhead. Tools can be always available (and fast), not only for end user programmers, but also for language implementors throughout development.},
      acmid = {2843917},
      articleno = {2},
      author = {Van De Vanter, Michael L.},
      booktitle = {Proceedings of the 10th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems},
      doi = {10.1145/2843915.2843917},
      interhash = {beda4e769c19d7ab76f408ed4ea9e77a},
      intrahash = {5dfb39086a5ac0bc06056d5f2c6313fd},
      isbn = {978-1-4503-3657-4},
      location = {Prague, Czech Republic},
      numpages = {3},
      pages = {2:1--2:3},
      publisher = {ACM},
      series = {ICOOOLPS '15},
      title = {{Building Debuggers and Other Tools: We Can "Have It All"}},
      year = 2015 }
  • S. Ryu and N. Ramsey, "Source-Level Debugging for Multiple Languages with Modest Programming Effort," in Compiler Construction: 14th International Conference, CC 2005, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2005, Edinburgh, UK, April 4-8, 2005. Proceedings, 2005, pp. 10-26. bibtex doi
    @inproceedings{Ryu2005,
      author = {Ryu, Sukyoung and Ramsey, Norman},
      booktitle = {Compiler Construction: 14th International Conference, CC 2005, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2005, Edinburgh, UK, April 4-8, 2005. Proceedings},
      doi = {10.1007/978-3-540-31985-6_2},
      editor = {Bodik, Rastislav},
      interhash = {db93f4f533f5f223af9438365cb60c7e},
      intrahash = {484ec6c19d966c79e23dc1b233e69cb3},
      isbn = {978-3-540-31985-6},
      pages = {10--26},
      publisher = {Springer},
      series = {CC '05},
      title = {{Source-Level Debugging for Multiple Languages with Modest Programming Effort}},
      year = 2005 }
  • J. Silva, "A Survey on Algorithmic Debugging Strategies," Advances in Engineering Software, vol. 42, iss. 11, pp. 976-991, 2011. bibtex doi
    @article{Silva:2011:SAD, abstract = {Algorithmic debugging is a debugging technique that has been extended to practically all programming paradigms. Roughly speaking, the technique constructs an internal representation of all (sub)computations performed during the execution of a buggy program; and then, it asks the programmer about the correctness of such computations. The answers of the programmer guide the search for the bug until it is isolated by discarding correct parts of the program. After twenty years of research in algorithmic debugging many different techniques have appeared to improve the original proposal. Surprisingly, no study exists that joins together all these techniques and compares their advantages and their performance. This article presents a study that compares all current algorithmic debugging techniques and analyzes their differences and their costs. The research identifies the dimensions on which each strategy relies. This information allows us to combine the strong points of different strategies. },
      author = {Silva, Josep},
      doi = {10.1016/j.advengsoft.2011.05.024},
      interhash = {3098e0bc0f51a63d88e199fdad61b39e},
      intrahash = {33e7f6ac57d7141b819a50d243eae408},
      issn = {0965-9978},
      issue_date = {November, 2011},
      journal = {Advances in Engineering Software},
      month = {November},
      number = 11, numpages = {16},
      pages = {976--991},
      publisher = {Elsevier},
      title = {{A Survey on Algorithmic Debugging Strategies}},
      volume = 42, year = 2011 }
  • R. Meier, A. Rigo, and T. R. Gross, "Parallel Virtual Machines with RPython," in Proceedings of the 12th Symposium on Dynamic Languages, 2016, pp. 48-59. bibtex doi
    @inproceedings{Meier:2016:PVM, abstract = {The RPython framework takes an interpreter for a dynamic language as its input and produces a Virtual Machine (VM) for that language. RPython is being used to develop PyPy, a high-performance Python interpreter. However, the produced VM does not support parallel execution since the framework relies on a Global Interpreter Lock (GIL): PyPy serialises the execution of multi-threaded Python programs. We describe the rationale and design of a new parallel execution model for RPython that allows the generation of parallel virtual machines while leaving the language semantics unchanged. This model then allows different implementations of concurrency control, and we discuss an implementation based on a GIL and an implementation based on Software Transactional Memory (STM). To evaluate the benefits of either choice, we adapt PyPy to work with both implementations (GIL and STM). The evaluation shows that PyPy with STM improves the runtime of a set of multi-threaded Python programs over PyPy with a GIL by factors in the range of 1.87× up to 5.96× when executing on a processor with 8 cores.},
      acmid = {2989233},
      author = {Meier, Remigius and Rigo, Armin and Gross, Thomas R.},
      booktitle = {Proceedings of the 12th Symposium on Dynamic Languages},
      doi = {10.1145/2989225.2989233},
      interhash = {8a2ff736d55f03de6a9f2acdfdc377ee},
      intrahash = {fcee44dd8269b9f5c9b369aa26716360},
      isbn = {978-1-4503-4445-6},
      location = {Amsterdam, Netherlands},
      numpages = {12},
      pages = {48--59},
      publisher = {ACM},
      series = {DLS '16},
      title = {{Parallel Virtual Machines with RPython}},
      year = 2016 }
  • T. L. Harris, "A Pragmatic Implementation of Non-blocking Linked-Lists," in Proceedings of the 15th International Conference on Distributed Computing, London, UK, 2001, pp. 300-314. bibtex doi
    @inproceedings{Harris:2001:PIN, abstract = {We present a new non-blocking implementation of concurrent linked-lists supporting linearizable insertion and deletion operations. The new algorithm provides substantial benefits over previous schemes: it is conceptually simpler and our prototype operates substantially faster.},
      acmid = {676105},
      address = {London, UK},
      author = {Harris, Timothy L.},
      booktitle = {Proceedings of the 15th International Conference on Distributed Computing},
      doi = {10.1007/3-540-45414-4_21},
      interhash = {10e170c24e487d19a06baf3d0c168543},
      intrahash = {330df2ba58dc5aed2ff1d8d7f1f07358},
      isbn = {3-540-42605-1},
      numpages = {15},
      pages = {300--314},
      publisher = {Springer},
      series = {DISC '01},
      title = {{A Pragmatic Implementation of Non-blocking Linked-Lists}},
      year = 2001 }
  • T. Domani, G. Goldshtein, E. K. Kolodner, E. Lewis, E. Petrank, and D. Sheinwald, "Thread-local Heaps for Java," in Proceedings of the 3rd International Symposium on Memory Management, 2002, pp. 76-87. bibtex doi
    @inproceedings{Domani:2002:THJ, acmid = {512439},
      author = {Domani, Tamar and Goldshtein, Gal and Kolodner, Elliot K. and Lewis, Ethan and Petrank, Erez and Sheinwald, Dafna},
      booktitle = {Proceedings of the 3rd International Symposium on Memory Management},
      doi = {10.1145/512429.512439},
      interhash = {6b99030968fb84393b21804949466135},
      intrahash = {1f82f79291a08f098294c1b15dcbf2df},
      isbn = {1-58113-539-4},
      location = {Berlin, Germany},
      numpages = {12},
      pages = {76--87},
      publisher = {ACM},
      series = {ISMM '02},
      title = {{Thread-local Heaps for Java}},
      year = 2002 }
  • N. Cohen, A. Tal, and E. Petrank, "Layout Lock: A Scalable Locking Paradigm for Concurrent Data Layout Modifications," in Proceedings of the 22Nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2017, pp. 17-29. bibtex doi
    @inproceedings{Cohen:2017:LLS, abstract = {Data-structures can benefit from dynamic data layout modifications when the size or the shape of the data structure changes during the execution, or when different phases in the program execute different workloads. However, in a modern multi-core environment, layout modifications involve costly synchronization overhead. In this paper we propose a novel layout lock that incurs a negligible overhead for reads and a small overhead for updates of the data structure. We then demonstrate the benefits of layout changes and also the advantages of the layout lock as its supporting synchronization mechanism for two data structures. In particular, we propose a concurrent binary search tree, and a concurrent array set, that benefit from concurrent layout modifications using the proposed layout lock. Experience demonstrates performance advantages and integration simplicity.},
      acmid = {3018753},
      author = {Cohen, Nachshon and Tal, Arie and Petrank, Erez},
      booktitle = {Proceedings of the 22Nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming},
      doi = {10.1145/3018743.3018753},
      interhash = {caf524ba527fc3cc3b51ce4b4e6785cc},
      intrahash = {e7150b0f4bf24ad49b6d5f6daf451ac0},
      isbn = {978-1-4503-4493-7},
      location = {Austin, Texas, USA},
      numpages = {13},
      pages = {17--29},
      publisher = {ACM},
      series = {PPoPP '17},
      title = {{Layout Lock: A Scalable Locking Paradigm for Concurrent Data Layout Modifications}},
      year = 2017 }
  • D. Clifford, H. Payer, M. Stanton, and B. L. Titzer, "Memento Mori: Dynamic Allocation-site-based Optimizations," in Proceedings of the 2015 International Symposium on Memory Management, 2015, pp. 105-117. bibtex doi
    @inproceedings{Clifford:2015:MMD,
      author = {Clifford, Daniel and Payer, Hannes and Stanton, Michael and Titzer, Ben L.},
      booktitle = {Proceedings of the 2015 International Symposium on Memory Management},
      doi = {10.1145/2754169.2754181},
      interhash = {e8053e5d7f1c70dbf02aaa85874bb3bc},
      intrahash = {0a26f807a6cb87373bd4ee4d577672f7},
      isbn = {978-1-4503-3589-8},
      location = {Portland, OR, USA},
      numpages = {13},
      pages = {105--117},
      publisher = {ACM},
      series = {ISMM '15},
      title = {{Memento Mori: Dynamic Allocation-site-based Optimizations}},
      year = 2015 }
  • A. Spiegelman, G. Golan-Gueta, and I. Keidar, "Transactional Data Structure Libraries," in Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation, 2016, pp. 682-696. bibtex doi
    @inproceedings{Spiegelman:2016:TDS,
      author = {Spiegelman, Alexander and Golan-Gueta, Guy and Keidar, Idit},
      booktitle = {Proceedings of the 37th ACM SIGPLAN Conference on Programming Language Design and Implementation},
      doi = {10.1145/2908080.2908112},
      interhash = {e9bb0835860b6ca07ea2dffb84954804},
      intrahash = {039595d2f1ddcd7c35c720dffa364c5e},
      isbn = {978-1-4503-4261-2},
      location = {Santa Barbara, CA, USA},
      numpages = {15},
      pages = {682--696},
      publisher = {ACM},
      series = {PLDI '16},
      title = {{Transactional Data Structure Libraries}},
      year = 2016 }
  • J. Castanos, D. Edelsohn, K. Ishizaki, P. Nagpurkar, T. Nakatani, T. Ogasawara, and P. Wu, "On the Benefits and Pitfalls of Extending a Statically Typed Language JIT Compiler for Dynamic Scripting Languages," in Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications, 2012, pp. 195-212. bibtex doi
    @inproceedings{Castanos:2012:BPE,
      author = {Castanos, Jose and Edelsohn, David and Ishizaki, Kazuaki and Nagpurkar, Priya and Nakatani, Toshio and Ogasawara, Takeshi and Wu, Peng},
      booktitle = {Proceedings of the ACM International Conference on Object Oriented Programming Systems Languages and Applications},
      doi = {10.1145/2384616.2384631},
      interhash = {89cf42818f20c02829ed1d03cd51dc80},
      intrahash = {ca6a240262f56008b64ce9022dbf9e77},
      isbn = {978-1-4503-1561-6},
      location = {Tucson, Arizona, USA},
      numpages = {18},
      pages = {195--212},
      publisher = {ACM},
      series = {OOPSLA '12},
      title = {On the Benefits and Pitfalls of Extending a Statically Typed Language JIT Compiler for Dynamic Scripting Languages},
      year = 2012 }
  • S. Lauterburg, R. K. Karmani, D. Marinov, and G. Agha, "Basset: A Tool for Systematic Testing of Actor Programs," in Proceedings of the Eighteenth ACM SIGSOFT International Symposium on Foundations of Software Engineering, New York, NY, USA, 2010, pp. 363-364. bibtex doi html
    @inproceedings{Lauterburg:2010:BTS, abstract = {This paper presents Basset, a tool for systematic testing of JVM-based actor programs. The actor programming model offers a promising approach for developing reliable concurrent and distributed systems. Since the actor model is based on message passing and disallows shared state, it avoids some of the problems inherent in shared-memory programming, e.g., low-level dataraces involving access to shared data. However, actor programs can still have bugs that result from incorrect orders of messages among actors or processing of messages by individual actors. To systematically test an actor program, it is necessary to explore different message delivery schedules that might occur during execution. Basset facilitates such exploration and provides a generic platform that can support actor systems that compile to Java bytecode. Our current implementation of Basset supports testing of programs developed using the ActorFoundry library and the Scala programming language.},
      acmid = {1882349},
      address = {New York, NY, USA},
      author = {Lauterburg, Steven and Karmani, Rajesh K. and Marinov, Darko and Agha, Gul},
      booktitle = {Proceedings of the Eighteenth ACM SIGSOFT International Symposium on Foundations of Software Engineering},
      doi = {10.1145/1882291.1882349},
      interhash = {7a4cebb4587540207ef90e03e9b906c8},
      intrahash = {3d50b1ae7b9c5b2850b22ca855cab515},
      isbn = {978-1-60558-791-2},
      location = {Santa Fe, New Mexico, USA},
      numpages = {2},
      pages = {363--364},
      publisher = {ACM},
      series = {FSE '10},
      title = {{Basset: A Tool for Systematic Testing of Actor Programs}},
      url = {http://doi.acm.org/10.1145/1882291.1882349},
      year = 2010 }
  • S. Lauterburg, M. Dotta, D. Marinov, and G. A. Agha, "A Framework for State-Space Exploration of Java-Based Actor Programs," in 2009 IEEE/ACM International Conference on Automated Software Engineering, 2009, pp. 468-479. bibtex doi
    @inproceedings{5431748, abstract = {The actor programming model offers a promising model for developing reliable parallel and distributed code. Actors provide flexibility and scalability: local execution may be interleaved, and distributed nodes may operate asynchronously. The resulting nondeterminism is captured by nondeterministic processing of messages. To automate testing, researchers have developed several tools tailored to specific actor systems. As actor languages and libraries continue to evolve, such tools have to be reimplemented. Because many actor systems are compiled to Java bytecode, we have developed Basset, a general framework for testing actor systems compiled to Java bytecode. We illustrate Basset by instantiating it for the Scala programming language and for the ActorFoundry library for Java. Our implementation builds on Java PathFinder, a widely used model checker for Java. Experiments show that Basset can effectively explore executions of actor programs; e.g., it discovered a previously unknown bug in a Scala application.},
      author = {Lauterburg, Steven and Dotta, Mirco and Marinov, Darko and Agha, Gul A.},
      booktitle = {2009 IEEE/ACM International Conference on Automated Software Engineering},
      doi = {10.1109/ASE.2009.88},
      interhash = {bc7bed301924323ad36310665ccf48e7},
      intrahash = {69d5a29aab3e21cb689e3655dbb2d188},
      issn = {1938-4300},
      month = nov, pages = {468--479},
      title = {{A Framework for State-Space Exploration of Java-Based Actor Programs}},
      year = 2009 }
  • Y. Zheng, T. Bao, and X. Zhang, "Statically Locating Web Application Bugs Caused by Asynchronous Calls," in Proceedings of the 20th International Conference on World Wide Web, 2011, pp. 805-814. bibtex doi
    @inproceedings{Zheng:2011:SLW, abstract = {Ajax becomes more and more important for web applications that care about client side user experience. It allows sending requests asynchronously, without blocking clients from continuing execution. Callback functions are only executed upon receiving the responses. While such mechanism makes browsing a smooth experience, it may cause severe problems in the presence of unexpected network latency, due to the non-determinism of asynchronism. In this paper, we demonstrate the possible problems caused by the asynchronism and propose a static program analysis to automatically detect such bugs in web applications. As client side Ajax code is often wrapped in server-side scripts, we also develop a technique that extracts client-side JavaScript code from server-side scripts. We evaluate our technique on a number of real-world web applications. Our results show that it can effectively identify real bugs. We also discuss possible ways to avoid such bugs.},
      author = {Zheng, Yunhui and Bao, Tao and Zhang, Xiangyu},
      booktitle = {Proceedings of the 20th International Conference on World Wide Web},
      doi = {10.1145/1963405.1963517},
      interhash = {522f507c8f9dcc45fcd3d52e6a1a7b01},
      intrahash = {b2368afb4d04cffd6b754937fc0d63a9},
      isbn = {978-1-4503-0632-4},
      location = {Hyderabad, India},
      numpages = {10},
      pages = {805--814},
      publisher = {ACM},
      series = {WWW '11},
      title = {{Statically Locating Web Application Bugs Caused by Asynchronous Calls}},
      year = 2011 }
  • S. Biswas, M. Cao, M. Zhang, M. D. Bond, and B. P. Wood, "Lightweight Data Race Detection for Production Runs," in Proceedings of the 26th International Conference on Compiler Construction, 2017, pp. 11-21. bibtex doi
    @inproceedings{Biswas:2017:LDR, abstract = {To detect data races that harm production systems, program analysis must target production runs. However, sound and precise data race detection adds too much run-time overhead for use in production systems. Even existing approaches that provide soundness or precision incur significant limitations. This work addresses the need for soundness (no missed races) and precision (no false races) by introducing novel, efficient production-time analyses that address each need separately. (1) Precise data race detection is useful for developers, who want to fix bugs but loathe false positives. We introduce a precise analysis called RaceChaser that provides low, bounded run-time overhead. (2) Sound race detection benefits analyses and tools whose correctness relies on knowledge of all potential data races. We present a sound, efficient approach called Caper that combines static and dynamic analysis to catch all data races in observed runs. RaceChaser and Caper are useful not only on their own; we introduce a framework that combines these analyses, using Caper as a sound filter for precise data race detection by RaceChaser. Our evaluation shows that RaceChaser and Caper are efficient and effective, and compare favorably with existing state-of-the-art approaches. These results suggest that RaceChaser and Caper enable practical data race detection that is precise and sound, respectively, ultimately leading to more reliable software systems.},
      author = {Biswas, Swarnendu and Cao, Man and Zhang, Minjia and Bond, Michael D. and Wood, Benjamin P.},
      booktitle = {Proceedings of the 26th International Conference on Compiler Construction},
      doi = {10.1145/3033019.3033020},
      interhash = {2e0b77268b5c7da72c79ed61a580524a},
      intrahash = {a679561eb0641b48aa2a590fe226396f},
      isbn = {978-1-4503-5233-8},
      location = {Austin, TX, USA},
      numpages = {11},
      pages = {11--21},
      publisher = {ACM},
      series = {CC 2017},
      title = {{Lightweight Data Race Detection for Production Runs}},
      year = 2017 }
  • S. Lu, J. Tucek, F. Qin, and Y. Zhou, "AVIO: Detecting Atomicity Violations via Access Interleaving Invariants," in Proceedings of the 12th International Conference on Architectural Support for Programming Languages and Operating Systems, 2006, pp. 37-48. bibtex doi
    @inproceedings{Lu:2006:ADA, acmid = {1168864},
      author = {Lu, Shan and Tucek, Joseph and Qin, Feng and Zhou, Yuanyuan},
      booktitle = {Proceedings of the 12th International Conference on Architectural Support for Programming Languages and Operating Systems},
      doi = {10.1145/1168857.1168864},
      interhash = {04cb7f3ded33d14f18a08d5c689c32ce},
      intrahash = {85d5382f5a58abc477f95b76e67616c4},
      isbn = {1-59593-451-0},
      location = {San Jose, California, USA},
      numpages = {12},
      pages = {37--48},
      publisher = {ACM},
      series = {ASPLOS XII},
      title = {AVIO: Detecting Atomicity Violations via Access Interleaving Invariants},
      year = 2006 }
  • C. Flanagan and S. N. Freund, "FastTrack: Efficient and Precise Dynamic Race Detection," in Proceedings of the 30th ACM SIGPLAN Conference on Programming Language Design and Implementation, 2009, pp. 121-133. bibtex doi
    @inproceedings{Flanagan:2009:FEP, acmid = {1542490},
      author = {Flanagan, Cormac and Freund, Stephen N.},
      booktitle = {Proceedings of the 30th ACM SIGPLAN Conference on Programming Language Design and Implementation},
      doi = {10.1145/1542476.1542490},
      interhash = {5cab2be8832818388bb1be92d14ec72e},
      intrahash = {aa8cc16bf9885c96e500006266634d5f},
      isbn = {978-1-60558-392-1},
      location = {Dublin, Ireland},
      numpages = {13},
      pages = {121--133},
      publisher = {ACM},
      series = {PLDI '09},
      title = {{FastTrack: Efficient and Precise Dynamic Race Detection}},
      year = 2009 }
  • T. Elmas, S. Qadeer, and S. Tasiran, "Goldilocks: A Race and Transaction-aware Java Runtime," in Proceedings of the 28th ACM SIGPLAN Conference on Programming Language Design and Implementation, 2007, pp. 245-255. bibtex doi
    @inproceedings{Elmas:2007:GRT, acmid = {1250762},
      author = {Elmas, Tayfun and Qadeer, Shaz and Tasiran, Serdar},
      booktitle = {Proceedings of the 28th ACM SIGPLAN Conference on Programming Language Design and Implementation},
      doi = {10.1145/1250734.1250762},
      interhash = {f46902092f3ed54a3603a41910837cf4},
      intrahash = {45b54e772482eb1e803328193354d145},
      isbn = {978-1-59593-633-2},
      location = {San Diego, California, USA},
      numpages = {11},
      pages = {245--255},
      publisher = {ACM},
      series = {PLDI '07},
      title = {Goldilocks: A Race and Transaction-aware Java Runtime},
      year = 2007 }