IEEE Transactions on Software Engineering - Special issue on formal methods in software practice
Eraser: a dynamic data race detector for multithreaded programs
ACM Transactions on Computer Systems (TOCS)
An efficient algorithm for computing MHP information for concurrent Java programs
ESEC/FSE-7 Proceedings of the 7th European software engineering conference held jointly with the 7th ACM SIGSOFT international symposium on Foundations of software engineering
Type-based race detection for Java
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
Transaction Processing: Concepts and Techniques
Transaction Processing: Concepts and Techniques
CIL: Intermediate Language and Tools for Analysis and Transformation of C Programs
CC '02 Proceedings of the 11th International Conference on Compiler Construction
A type and effect system for atomicity
PLDI '03 Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation
Process structuring, synchronization, and recovery using atomic actions
Proceedings of an ACM conference on Language design for reliable software
Language support for lightweight transactions
OOPSLA '03 Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, systems, languages, and applications
TLDI '05 Proceedings of the 2005 ACM SIGPLAN international workshop on Types in languages design and implementation
AtomCaml: first-class atomicity via rollback
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
Autolocker: synchronization inference for atomic sections
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Polyglot: an extensible compiler framework for Java
CC'03 Proceedings of the 12th international conference on Compiler construction
Transactions with isolation and cooperation
Proceedings of the 22nd annual ACM SIGPLAN conference on Object-oriented programming systems and applications
Inferring locks for atomic sections
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
The theory of deadlock avoidance via discrete control
Proceedings of the 36th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Minimum Lock Assignment: A Method for Exploiting Concurrency among Critical Sections
Languages and Compilers for Parallel Computing
Elyze: enabling safe parallelism in event-driven servers
Proceedings of the 8th ACM SIGPLAN-SIGSOFT workshop on Program analysis for software tools and engineering
FlexSync: An aspect-oriented approach to Java synchronization
ICSE '09 Proceedings of the 31st International Conference on Software Engineering
Proceedings of the 15th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming
Using data structure knowledge for efficient lock generation and strong atomicity
Proceedings of the 15th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming
Abstraction-guided synthesis of synchronization
Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Keep off the grass: locking the right path for atomicity
CC'08/ETAPS'08 Proceedings of the Joint European Conferences on Theory and Practice of Software 17th international conference on Compiler construction
Views: object-inspired concurrency control
Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering - Volume 1
Transactional memory should be an implementation technique, not a programming interface
HotPar'09 Proceedings of the First USENIX conference on Hot topics in parallelism
Automatic atomic region identification in shared memory SPMD programs
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
Task types for pervasive atomicity
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
From boolean to quantitative synthesis
EMSOFT '11 Proceedings of the ninth ACM international conference on Embedded software
Accentuating the positive: atomicity inference and enforcement using correct executions
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
Automatic fine-grain locking using shape properties
Proceedings of the 2011 ACM international conference on Object oriented programming systems languages and applications
An algorithmic framework for synthesis of concurrent programs
ATVA'11 Proceedings of the 9th international conference on Automated technology for verification and analysis
Applying transactional memory to concurrency bugs
ASPLOS XVII Proceedings of the seventeenth international conference on Architectural Support for Programming Languages and Operating Systems
Logical concurrency control from sequential proofs
ESOP'10 Proceedings of the 19th European conference on Programming Languages and Systems
Concurrent data representation synthesis
Proceedings of the 33rd ACM SIGPLAN conference on Programming Language Design and Implementation
Reasoning about lock placements
ESOP'12 Proceedings of the 21st European conference on Programming Languages and Systems
Axis: automatically fixing atomicity violations through solving control constraints
Proceedings of the 34th International Conference on Software Engineering
Lock inference in the presence of large libraries
ECOOP'12 Proceedings of the 26th European conference on Object-Oriented Programming
Views: Synthesizing fine-grained concurrency control
ACM Transactions on Software Engineering and Methodology (TOSEM)
Detecting deadlock in programs with data-centric synchronization
Proceedings of the 2013 International Conference on Software Engineering
Quantitative reactive modeling and verification
Computer Science - Research and Development
Hi-index | 0.00 |
We introduce lock allocation, an automatic technique that takes a multi-threaded program annotated with atomic sections (that must be executed atomically), and infers a lock assignment from global variables to locks and a lock instrumentation that determines where each lock should be acquired and released such that the resulting instrumented program is guaranteed to preserve atomicity and deadlock freedom (provided all shared state is accessed only within atomic sections). Our algorithm works in the presence of pointers and procedures, and sets up the lock allocation problem as a 0-1 ILP which minimizes the conflict cost between atomic sections while simultaneously minimizing the number of locks. We have implemented our algorithm for both C with pthreads and Java, and have applied it to infer locks in 15K lines of AOLserver code. Our automatic allocation produces the same results as hand annotations for most of this code, while solving the optimization instances within a second for most programs.