Detecting and escaping infinite loops with jolt

Michael Carbin, Sasa Misailovic, Michael Kling, Martin C. Rinard

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

Abstract

Infinite loops can make applications unresponsive. Potential problems include lost work or output, denied access to application functionality, and a lack of responses to urgent events. We present Jolt, a novel system for dynamically detecting and escaping infinite loops. At the user's request, Jolt attaches to an application to monitor its progress. Specifically, Jolt records the program state at the start of each loop iteration. If two consecutive loop iterations produce the same state, Jolt reports to the user that the application is in an infinite loop. At the user's option, Jolt can then transfer control to a statement following the loop, thereby allowing the application to escape the infinite loop and ideally continue its productive execution. The immediate goal is to enable the application to execute long enough to save any pending work, finish any in-progress computations, or respond to any urgent events. We evaluated Jolt by applying it to detect and escape eight infinite loops in five benchmark applications. Jolt was able to detect seven of the eight infinite loops (the eighth changes the state on every iteration). We also evaluated the effect of escaping an infinite loop as an alternative to terminating the application. In all of our benchmark applications, escaping an infinite loop produced a more useful output than terminating the application. Finally, we evaluated how well escaping from an infinite loop approximated the correction that the developers later made to the application. For two out of our eight loops, escaping the infinite loop produced the same output as the corrected version of the application.

Original languageEnglish (US)
Title of host publicationECOOP 2011 - Object-Oriented Programming - 25th European Conference, Proceedings
Pages609-633
Number of pages25
DOIs
StatePublished - Aug 10 2011
Event25th European Conference on Object-Oriented Programming, ECOOP 2011 - Lancaster, United Kingdom
Duration: Jul 25 2011Jul 29 2011

Publication series

NameLecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
Volume6813 LNCS
ISSN (Print)0302-9743
ISSN (Electronic)1611-3349

Other

Other25th European Conference on Object-Oriented Programming, ECOOP 2011
CountryUnited Kingdom
CityLancaster
Period7/25/117/29/11

Fingerprint

Iteration
Output
Benchmark
Potential Problems
Consecutive
Monitor
Continue
Alternatives

ASJC Scopus subject areas

  • Theoretical Computer Science
  • Computer Science(all)

Cite this

Carbin, M., Misailovic, S., Kling, M., & Rinard, M. C. (2011). Detecting and escaping infinite loops with jolt. In ECOOP 2011 - Object-Oriented Programming - 25th European Conference, Proceedings (pp. 609-633). (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 6813 LNCS). https://doi.org/10.1007/978-3-642-22655-7_28

Detecting and escaping infinite loops with jolt. / Carbin, Michael; Misailovic, Sasa; Kling, Michael; Rinard, Martin C.

ECOOP 2011 - Object-Oriented Programming - 25th European Conference, Proceedings. 2011. p. 609-633 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 6813 LNCS).

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

Carbin, M, Misailovic, S, Kling, M & Rinard, MC 2011, Detecting and escaping infinite loops with jolt. in ECOOP 2011 - Object-Oriented Programming - 25th European Conference, Proceedings. Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 6813 LNCS, pp. 609-633, 25th European Conference on Object-Oriented Programming, ECOOP 2011, Lancaster, United Kingdom, 7/25/11. https://doi.org/10.1007/978-3-642-22655-7_28
Carbin M, Misailovic S, Kling M, Rinard MC. Detecting and escaping infinite loops with jolt. In ECOOP 2011 - Object-Oriented Programming - 25th European Conference, Proceedings. 2011. p. 609-633. (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)). https://doi.org/10.1007/978-3-642-22655-7_28
Carbin, Michael ; Misailovic, Sasa ; Kling, Michael ; Rinard, Martin C. / Detecting and escaping infinite loops with jolt. ECOOP 2011 - Object-Oriented Programming - 25th European Conference, Proceedings. 2011. pp. 609-633 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)).
@inproceedings{d6a654f6d5304843b5bef39b3f0388e0,
title = "Detecting and escaping infinite loops with jolt",
abstract = "Infinite loops can make applications unresponsive. Potential problems include lost work or output, denied access to application functionality, and a lack of responses to urgent events. We present Jolt, a novel system for dynamically detecting and escaping infinite loops. At the user's request, Jolt attaches to an application to monitor its progress. Specifically, Jolt records the program state at the start of each loop iteration. If two consecutive loop iterations produce the same state, Jolt reports to the user that the application is in an infinite loop. At the user's option, Jolt can then transfer control to a statement following the loop, thereby allowing the application to escape the infinite loop and ideally continue its productive execution. The immediate goal is to enable the application to execute long enough to save any pending work, finish any in-progress computations, or respond to any urgent events. We evaluated Jolt by applying it to detect and escape eight infinite loops in five benchmark applications. Jolt was able to detect seven of the eight infinite loops (the eighth changes the state on every iteration). We also evaluated the effect of escaping an infinite loop as an alternative to terminating the application. In all of our benchmark applications, escaping an infinite loop produced a more useful output than terminating the application. Finally, we evaluated how well escaping from an infinite loop approximated the correction that the developers later made to the application. For two out of our eight loops, escaping the infinite loop produced the same output as the corrected version of the application.",
author = "Michael Carbin and Sasa Misailovic and Michael Kling and Rinard, {Martin C.}",
year = "2011",
month = "8",
day = "10",
doi = "10.1007/978-3-642-22655-7_28",
language = "English (US)",
isbn = "9783642226540",
series = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",
pages = "609--633",
booktitle = "ECOOP 2011 - Object-Oriented Programming - 25th European Conference, Proceedings",

}

TY - GEN

T1 - Detecting and escaping infinite loops with jolt

AU - Carbin, Michael

AU - Misailovic, Sasa

AU - Kling, Michael

AU - Rinard, Martin C.

PY - 2011/8/10

Y1 - 2011/8/10

N2 - Infinite loops can make applications unresponsive. Potential problems include lost work or output, denied access to application functionality, and a lack of responses to urgent events. We present Jolt, a novel system for dynamically detecting and escaping infinite loops. At the user's request, Jolt attaches to an application to monitor its progress. Specifically, Jolt records the program state at the start of each loop iteration. If two consecutive loop iterations produce the same state, Jolt reports to the user that the application is in an infinite loop. At the user's option, Jolt can then transfer control to a statement following the loop, thereby allowing the application to escape the infinite loop and ideally continue its productive execution. The immediate goal is to enable the application to execute long enough to save any pending work, finish any in-progress computations, or respond to any urgent events. We evaluated Jolt by applying it to detect and escape eight infinite loops in five benchmark applications. Jolt was able to detect seven of the eight infinite loops (the eighth changes the state on every iteration). We also evaluated the effect of escaping an infinite loop as an alternative to terminating the application. In all of our benchmark applications, escaping an infinite loop produced a more useful output than terminating the application. Finally, we evaluated how well escaping from an infinite loop approximated the correction that the developers later made to the application. For two out of our eight loops, escaping the infinite loop produced the same output as the corrected version of the application.

AB - Infinite loops can make applications unresponsive. Potential problems include lost work or output, denied access to application functionality, and a lack of responses to urgent events. We present Jolt, a novel system for dynamically detecting and escaping infinite loops. At the user's request, Jolt attaches to an application to monitor its progress. Specifically, Jolt records the program state at the start of each loop iteration. If two consecutive loop iterations produce the same state, Jolt reports to the user that the application is in an infinite loop. At the user's option, Jolt can then transfer control to a statement following the loop, thereby allowing the application to escape the infinite loop and ideally continue its productive execution. The immediate goal is to enable the application to execute long enough to save any pending work, finish any in-progress computations, or respond to any urgent events. We evaluated Jolt by applying it to detect and escape eight infinite loops in five benchmark applications. Jolt was able to detect seven of the eight infinite loops (the eighth changes the state on every iteration). We also evaluated the effect of escaping an infinite loop as an alternative to terminating the application. In all of our benchmark applications, escaping an infinite loop produced a more useful output than terminating the application. Finally, we evaluated how well escaping from an infinite loop approximated the correction that the developers later made to the application. For two out of our eight loops, escaping the infinite loop produced the same output as the corrected version of the application.

UR - http://www.scopus.com/inward/record.url?scp=79961148273&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=79961148273&partnerID=8YFLogxK

U2 - 10.1007/978-3-642-22655-7_28

DO - 10.1007/978-3-642-22655-7_28

M3 - Conference contribution

AN - SCOPUS:79961148273

SN - 9783642226540

T3 - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)

SP - 609

EP - 633

BT - ECOOP 2011 - Object-Oriented Programming - 25th European Conference, Proceedings

ER -