Parallel programming in Split-C
Proceedings of the 1993 ACM/IEEE conference on Supercomputing
The SPLASH-2 programs: characterization and methodological considerations
ISCA '95 Proceedings of the 22nd annual international symposium on Computer architecture
Eraser: a dynamic data race detector for multi-threaded programs
Proceedings of the sixteenth ACM symposium on Operating systems principles
Pattern languages of program design 3
Typed memory management in a calculus of capabilities
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proceedings of the ACM SIGPLAN 2001 conference on Programming language design and implementation
Efficient and precise datarace detection for multithreaded object-oriented programs
PLDI '02 Proceedings of the ACM SIGPLAN 2002 Conference on Programming language design and implementation
Ownership types for safe programming: preventing data races and deadlocks
OOPSLA '02 Proceedings of the 17th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Ownership types for object encapsulation
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Type-safe multithreading in cyclone
Proceedings of the 2003 ACM SIGPLAN international workshop on Types in languages design and implementation
CIL: Intermediate Language and Tools for Analysis and Transformation of C Programs
CC '02 Proceedings of the 11th International Conference on Compiler Construction
Ownership types for safe region-based memory management in real-time Java
PLDI '03 Proceedings of the ACM SIGPLAN 2003 conference on Programming language design and implementation
RacerX: effective, static detection of race conditions and deadlocks
SOSP '03 Proceedings of the nineteenth ACM symposium on Operating systems principles
Capriccio: scalable threads for internet services
SOSP '03 Proceedings of the nineteenth ACM symposium on Operating systems principles
Atomizer: a dynamic atomicity checker for multithreaded programs
Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Safejava: a unified type system for safe programming
Safejava: a unified type system for safe programming
TLDI '05 Proceedings of the 2005 ACM SIGPLAN international workshop on Types in languages design and implementation
Automated type-based analysis of data races and atomicity
Proceedings of the tenth ACM SIGPLAN symposium on Principles and practice of parallel programming
RaceTrack: efficient detection of data race conditions via adaptive tracking
Proceedings of the twentieth ACM symposium on Operating systems principles
Autolocker: synchronization inference for atomic sections
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Observations on the assured evolution of concurrent Java programs
Science of Computer Programming - Special issue: Concurrency and synchronization in Java programs
LOCKSMITH: context-sensitive correlation analysis for race detection
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
A dynamic analysis for revealing object ownership and sharing
Proceedings of the 2006 international workshop on Dynamic systems analysis
Conditional must not aliasing for static race detection
Proceedings of the 34th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Goldilocks: a race and transaction-aware java runtime
Proceedings of the 2007 ACM SIGPLAN conference on Programming language design and implementation
RELAY: static race detection on millions of lines of code
Proceedings of the the 6th joint meeting of the European software engineering conference and the ACM SIGSOFT symposium on The foundations of software engineering
Checking race freedom via linear programming
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
SharC: checking data sharing strategies for multithreaded c
Proceedings of the 2008 ACM SIGPLAN conference on Programming language design and implementation
Dependent types for low-level programming
ESOP'07 Proceedings of the 16th European conference on Programming
Fast byte-granularity software fault isolation
Proceedings of the ACM SIGOPS 22nd symposium on Operating systems principles
Dynamically checking ownership policies in concurrent c/c++ programs
Proceedings of the 37th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Race-free and memory-safe multithreading: design and implementation in cyclone
Proceedings of the 5th ACM SIGPLAN workshop on Types in language design and implementation
Cache topology aware computation mapping for multicores
PLDI '10 Proceedings of the 2010 ACM SIGPLAN conference on Programming language design and implementation
Composable specifications for structured shared-memory communication
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
Capabilities for uniqueness and borrowing
ECOOP'10 Proceedings of the 24th European conference on Object-oriented programming
Effective data-race detection for the kernel
OSDI'10 Proceedings of the 9th USENIX conference on Operating systems design and implementation
Secure the clones: static enforcement of policies for secure object copying
ESOP'11/ETAPS'11 Proceedings of the 20th European conference on Programming languages and systems: part of the joint European conferences on theory and practice of software
Aliasing in Object-Oriented Programming
Hi-index | 0.00 |
SharC is a recently developed system for checking data-sharing in multithreaded programs. Programmers specify sharing rules (read-only, protected by a lock, etc.) for individual objects, and the SharC compiler enforces these rules using static and dynamic checks. Violations of these rules indicate unintended data sharing, which is the underlying cause of harmful data-races. Additionally, SharC allows programmers to change the sharing rules for a specific object using a sharing cast, to capture the fact that sharing rules for an object often change during the object's lifetime. SharC was successfully applied to a number of multi-threaded C programs. However, many programs are not readily checkable using SharC because their sharing rules, and changes to sharing rules, effectively apply to whole data structures rather than to individual objects. We have developed a system called Shoal to address this shortcoming. In addition to the sharing rules and sharing cast of SharC, our system includes a new concept that we call groups. A group is a collection of objects all having the same sharing mode. Each group has a distinguished member called the group leader. When the sharing mode of the group leader changes by way of a sharing cast, the sharing mode of all members of the group also changes. This operation is made sound by maintaining the invariant that at the point of a sharing cast, the only external pointer into the group is the pointer to the group leader. The addition of groups allows checking safe concurrency at the level of data structures rather than at the level of individual objects. We demonstrate the necessity and practicality of groups by applying Shoal to a wide range of concurrent C programs (the largest approaching a million lines of code). In all benchmarks groups entail low annotation burden and no significant additional performance overhead.