SlicK: Slice-based locality exploitation for efficient redundant multithreading

Angshuman Parashar, Anand Sivasubramaniam, Sudhanva Gurumurthi

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

30 Citations (Scopus)

Abstract

Transient faults are expected a be a major design consideration in future microprocessors. Recent proposals for transient fault detection in processor cores have revolved around the idea of redundant threading, which involves redundant execution of a program across multiple execution contexts. This paper presents a new approach to redundant threading by bringing together the concepts of slice-level execution and value and control-flow locality into a novel partial redundant threading mechanism called SlicK.The purpose of redundant execution is to check the integrity of the outputs propagating out of the core (typically through stores). SlicK implements redundancy at the granularity of backward-slices of these output instructions and exploits value and control-flow locality to avoid redundantly executing slices that lead to predictable outputs, thereby avoiding redundant execution of a significant fraction of instructions while maintaining extremely low vulnerabilities for critical processor structures.We propose the microarchitecture of a backward-slice extractor called SliceEM that is able to identify backward slices without interrupting the instruction flow, and show how this extractor and a set of predictors can be integrated into a redundant threading mechanism to form SlicK. Detailed simulations with SPEC CPU2000 benchmarks show that SlicK can provide around 10.2% performance improvement over a well known redundant threading mechanism, buying back over 50% of the loss suffered due to redundant execution. SlicK can keep the Architectural Vulnerability Factors of processor structures to typically 0%-2%. More importantly, SlicK's slice-based mechanisms provide future opportunities for exploring interesting points in the performance-reliability design space based on market segment needs.

Original languageEnglish (US)
Title of host publicationASPLOS XII
Subtitle of host publicationTwelfth International Conference on Architectural Support for Programming Languages and Operating Systems
Pages95-105
Number of pages11
DOIs
StatePublished - Dec 1 2006

Publication series

NameInternational Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS

Fingerprint

Flow control
Fault detection
Redundancy
Microprocessor chips

All Science Journal Classification (ASJC) codes

  • Software
  • Information Systems
  • Hardware and Architecture

Cite this

Parashar, A., Sivasubramaniam, A., & Gurumurthi, S. (2006). SlicK: Slice-based locality exploitation for efficient redundant multithreading. In ASPLOS XII: Twelfth International Conference on Architectural Support for Programming Languages and Operating Systems (pp. 95-105). (International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS). https://doi.org/10.1145/1168857.1168870
Parashar, Angshuman ; Sivasubramaniam, Anand ; Gurumurthi, Sudhanva. / SlicK : Slice-based locality exploitation for efficient redundant multithreading. ASPLOS XII: Twelfth International Conference on Architectural Support for Programming Languages and Operating Systems. 2006. pp. 95-105 (International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS).
@inproceedings{8eb9394061a844f6b1fdfea0eec92eed,
title = "SlicK: Slice-based locality exploitation for efficient redundant multithreading",
abstract = "Transient faults are expected a be a major design consideration in future microprocessors. Recent proposals for transient fault detection in processor cores have revolved around the idea of redundant threading, which involves redundant execution of a program across multiple execution contexts. This paper presents a new approach to redundant threading by bringing together the concepts of slice-level execution and value and control-flow locality into a novel partial redundant threading mechanism called SlicK.The purpose of redundant execution is to check the integrity of the outputs propagating out of the core (typically through stores). SlicK implements redundancy at the granularity of backward-slices of these output instructions and exploits value and control-flow locality to avoid redundantly executing slices that lead to predictable outputs, thereby avoiding redundant execution of a significant fraction of instructions while maintaining extremely low vulnerabilities for critical processor structures.We propose the microarchitecture of a backward-slice extractor called SliceEM that is able to identify backward slices without interrupting the instruction flow, and show how this extractor and a set of predictors can be integrated into a redundant threading mechanism to form SlicK. Detailed simulations with SPEC CPU2000 benchmarks show that SlicK can provide around 10.2{\%} performance improvement over a well known redundant threading mechanism, buying back over 50{\%} of the loss suffered due to redundant execution. SlicK can keep the Architectural Vulnerability Factors of processor structures to typically 0{\%}-2{\%}. More importantly, SlicK's slice-based mechanisms provide future opportunities for exploring interesting points in the performance-reliability design space based on market segment needs.",
author = "Angshuman Parashar and Anand Sivasubramaniam and Sudhanva Gurumurthi",
year = "2006",
month = "12",
day = "1",
doi = "10.1145/1168857.1168870",
language = "English (US)",
isbn = "1595934510",
series = "International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS",
pages = "95--105",
booktitle = "ASPLOS XII",

}

Parashar, A, Sivasubramaniam, A & Gurumurthi, S 2006, SlicK: Slice-based locality exploitation for efficient redundant multithreading. in ASPLOS XII: Twelfth International Conference on Architectural Support for Programming Languages and Operating Systems. International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS, pp. 95-105. https://doi.org/10.1145/1168857.1168870

SlicK : Slice-based locality exploitation for efficient redundant multithreading. / Parashar, Angshuman; Sivasubramaniam, Anand; Gurumurthi, Sudhanva.

ASPLOS XII: Twelfth International Conference on Architectural Support for Programming Languages and Operating Systems. 2006. p. 95-105 (International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS).

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

TY - GEN

T1 - SlicK

T2 - Slice-based locality exploitation for efficient redundant multithreading

AU - Parashar, Angshuman

AU - Sivasubramaniam, Anand

AU - Gurumurthi, Sudhanva

PY - 2006/12/1

Y1 - 2006/12/1

N2 - Transient faults are expected a be a major design consideration in future microprocessors. Recent proposals for transient fault detection in processor cores have revolved around the idea of redundant threading, which involves redundant execution of a program across multiple execution contexts. This paper presents a new approach to redundant threading by bringing together the concepts of slice-level execution and value and control-flow locality into a novel partial redundant threading mechanism called SlicK.The purpose of redundant execution is to check the integrity of the outputs propagating out of the core (typically through stores). SlicK implements redundancy at the granularity of backward-slices of these output instructions and exploits value and control-flow locality to avoid redundantly executing slices that lead to predictable outputs, thereby avoiding redundant execution of a significant fraction of instructions while maintaining extremely low vulnerabilities for critical processor structures.We propose the microarchitecture of a backward-slice extractor called SliceEM that is able to identify backward slices without interrupting the instruction flow, and show how this extractor and a set of predictors can be integrated into a redundant threading mechanism to form SlicK. Detailed simulations with SPEC CPU2000 benchmarks show that SlicK can provide around 10.2% performance improvement over a well known redundant threading mechanism, buying back over 50% of the loss suffered due to redundant execution. SlicK can keep the Architectural Vulnerability Factors of processor structures to typically 0%-2%. More importantly, SlicK's slice-based mechanisms provide future opportunities for exploring interesting points in the performance-reliability design space based on market segment needs.

AB - Transient faults are expected a be a major design consideration in future microprocessors. Recent proposals for transient fault detection in processor cores have revolved around the idea of redundant threading, which involves redundant execution of a program across multiple execution contexts. This paper presents a new approach to redundant threading by bringing together the concepts of slice-level execution and value and control-flow locality into a novel partial redundant threading mechanism called SlicK.The purpose of redundant execution is to check the integrity of the outputs propagating out of the core (typically through stores). SlicK implements redundancy at the granularity of backward-slices of these output instructions and exploits value and control-flow locality to avoid redundantly executing slices that lead to predictable outputs, thereby avoiding redundant execution of a significant fraction of instructions while maintaining extremely low vulnerabilities for critical processor structures.We propose the microarchitecture of a backward-slice extractor called SliceEM that is able to identify backward slices without interrupting the instruction flow, and show how this extractor and a set of predictors can be integrated into a redundant threading mechanism to form SlicK. Detailed simulations with SPEC CPU2000 benchmarks show that SlicK can provide around 10.2% performance improvement over a well known redundant threading mechanism, buying back over 50% of the loss suffered due to redundant execution. SlicK can keep the Architectural Vulnerability Factors of processor structures to typically 0%-2%. More importantly, SlicK's slice-based mechanisms provide future opportunities for exploring interesting points in the performance-reliability design space based on market segment needs.

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

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

U2 - 10.1145/1168857.1168870

DO - 10.1145/1168857.1168870

M3 - Conference contribution

AN - SCOPUS:34547434242

SN - 1595934510

SN - 9781595934512

T3 - International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS

SP - 95

EP - 105

BT - ASPLOS XII

ER -

Parashar A, Sivasubramaniam A, Gurumurthi S. SlicK: Slice-based locality exploitation for efficient redundant multithreading. In ASPLOS XII: Twelfth International Conference on Architectural Support for Programming Languages and Operating Systems. 2006. p. 95-105. (International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS). https://doi.org/10.1145/1168857.1168870