Kill-safe synchronization abstractions

Matthew Flatt*, Robert Bruce Findler

*Corresponding author for this work

Research output: Chapter in Book/Report/Conference proceedingConference contribution

27 Scopus citations

Abstract

When an individual task can be forcefully terminated at any time, cooperating tasks must communicate carefully. For example, if two tasks share an object, and if one task is terminated while it manipulates the object, the object may remain in an inconsistent or frozen state that incapacitates the other task. To support communication among terminable tasks, language run-time systems (and operating systems) provide kill-safe abstractions for inter-task communication. No kill-safe guarantee is available, however, for abstractions that are implemented outside the run-time system. In this paper, we show how a run-time system can support new kill-safe abstractions without requiring modification to the run-time system, and without requiring the run-time system to trust any new code. Our design frees the run-time implementor to provide only a modest set of synchronization primitives in the trusted computing base, while still allowing tasks to communicate using sophisticated abstractions.

Original languageEnglish (US)
Title of host publicationProceedings of the 2004 ACM SIGPLAN Conference on Programming Language Design and Implementaion (PLD'04)
PublisherAssociation for Computing Machinery
Pages47-58
Number of pages12
Volume1
StatePublished - Jan 1 2004
EventProceedings of the 2004 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI'04) - Washington, DC, United States
Duration: Jun 9 2004Jun 11 2004

Other

OtherProceedings of the 2004 ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI'04)
CountryUnited States
CityWashington, DC
Period6/9/046/11/04

Keywords

  • Design
  • Languages

ASJC Scopus subject areas

  • Software

Fingerprint Dive into the research topics of 'Kill-safe synchronization abstractions'. Together they form a unique fingerprint.

  • Cite this

    Flatt, M., & Findler, R. B. (2004). Kill-safe synchronization abstractions. In Proceedings of the 2004 ACM SIGPLAN Conference on Programming Language Design and Implementaion (PLD'04) (Vol. 1, pp. 47-58). Association for Computing Machinery.