Speculative parallelization using software multi-threaded transactions

Arun Raman, Hanjun Kim, Thomas R. Mason, Thomas B. Jablin, David I. August

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

58 Citations (Scopus)

Abstract

With the right techniques, multicore architectures may be able to continue the exponential performance trend that elevated the performance of applications of all types for decades. While many scientific programs can be parallelized without speculative techniques, speculative parallelism appears to be the key to continuing this trend for general-purpose applications. Recently-proposed code parallelization techniques, such as those by Bridges et al. and by Thies et al., demonstrate scalable performance on multiple cores by using speculation to divide code into atomic units (transactions) that span multiple threads in order to expose data parallelism. Unfortunately, most software and hardware Thread-Level Speculation (TLS) memory systems and transactional memories are not sufficient because they only support single-threaded atomic units. Multi-threaded Transactions (MTXs) address this problem, but they require expensive hardware support as currently proposed in the literature. This paper proposes a Software MTX (SMTX) system that captures the applicability and performance of hardware MTX, but on existing multicore machines. The SMTX system yields a harmonic mean speedup of 13.36x on native hardware with four 6-core processors (24 cores in total) running speculatively parallelized applications.

Original languageEnglish
Title of host publicationASPLOS XV - 15th International Conference on Architectural Support for Programming Languages and Operating Systems
Pages65-76
Number of pages12
DOIs
Publication statusPublished - 2010 May 19
Event15th International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS XV - Pittsburgh, PA, United States
Duration: 2010 Mar 132010 Mar 17

Other

Other15th International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS XV
CountryUnited States
CityPittsburgh, PA
Period10/3/1310/3/17

Fingerprint

Hardware
Data storage equipment
Computer hardware
Computer systems

All Science Journal Classification (ASJC) codes

  • Software
  • Information Systems
  • Hardware and Architecture

Cite this

Raman, A., Kim, H., Mason, T. R., Jablin, T. B., & August, D. I. (2010). Speculative parallelization using software multi-threaded transactions. In ASPLOS XV - 15th International Conference on Architectural Support for Programming Languages and Operating Systems (pp. 65-76) https://doi.org/10.1145/1736020.1736030
Raman, Arun ; Kim, Hanjun ; Mason, Thomas R. ; Jablin, Thomas B. ; August, David I. / Speculative parallelization using software multi-threaded transactions. ASPLOS XV - 15th International Conference on Architectural Support for Programming Languages and Operating Systems. 2010. pp. 65-76
@inproceedings{4a6c961c9633441c95c8e0f429cb80a6,
title = "Speculative parallelization using software multi-threaded transactions",
abstract = "With the right techniques, multicore architectures may be able to continue the exponential performance trend that elevated the performance of applications of all types for decades. While many scientific programs can be parallelized without speculative techniques, speculative parallelism appears to be the key to continuing this trend for general-purpose applications. Recently-proposed code parallelization techniques, such as those by Bridges et al. and by Thies et al., demonstrate scalable performance on multiple cores by using speculation to divide code into atomic units (transactions) that span multiple threads in order to expose data parallelism. Unfortunately, most software and hardware Thread-Level Speculation (TLS) memory systems and transactional memories are not sufficient because they only support single-threaded atomic units. Multi-threaded Transactions (MTXs) address this problem, but they require expensive hardware support as currently proposed in the literature. This paper proposes a Software MTX (SMTX) system that captures the applicability and performance of hardware MTX, but on existing multicore machines. The SMTX system yields a harmonic mean speedup of 13.36x on native hardware with four 6-core processors (24 cores in total) running speculatively parallelized applications.",
author = "Arun Raman and Hanjun Kim and Mason, {Thomas R.} and Jablin, {Thomas B.} and August, {David I.}",
year = "2010",
month = "5",
day = "19",
doi = "10.1145/1736020.1736030",
language = "English",
isbn = "9781605588391",
pages = "65--76",
booktitle = "ASPLOS XV - 15th International Conference on Architectural Support for Programming Languages and Operating Systems",

}

Raman, A, Kim, H, Mason, TR, Jablin, TB & August, DI 2010, Speculative parallelization using software multi-threaded transactions. in ASPLOS XV - 15th International Conference on Architectural Support for Programming Languages and Operating Systems. pp. 65-76, 15th International Conference on Architectural Support for Programming Languages and Operating Systems, ASPLOS XV, Pittsburgh, PA, United States, 10/3/13. https://doi.org/10.1145/1736020.1736030

Speculative parallelization using software multi-threaded transactions. / Raman, Arun; Kim, Hanjun; Mason, Thomas R.; Jablin, Thomas B.; August, David I.

ASPLOS XV - 15th International Conference on Architectural Support for Programming Languages and Operating Systems. 2010. p. 65-76.

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

TY - GEN

T1 - Speculative parallelization using software multi-threaded transactions

AU - Raman, Arun

AU - Kim, Hanjun

AU - Mason, Thomas R.

AU - Jablin, Thomas B.

AU - August, David I.

PY - 2010/5/19

Y1 - 2010/5/19

N2 - With the right techniques, multicore architectures may be able to continue the exponential performance trend that elevated the performance of applications of all types for decades. While many scientific programs can be parallelized without speculative techniques, speculative parallelism appears to be the key to continuing this trend for general-purpose applications. Recently-proposed code parallelization techniques, such as those by Bridges et al. and by Thies et al., demonstrate scalable performance on multiple cores by using speculation to divide code into atomic units (transactions) that span multiple threads in order to expose data parallelism. Unfortunately, most software and hardware Thread-Level Speculation (TLS) memory systems and transactional memories are not sufficient because they only support single-threaded atomic units. Multi-threaded Transactions (MTXs) address this problem, but they require expensive hardware support as currently proposed in the literature. This paper proposes a Software MTX (SMTX) system that captures the applicability and performance of hardware MTX, but on existing multicore machines. The SMTX system yields a harmonic mean speedup of 13.36x on native hardware with four 6-core processors (24 cores in total) running speculatively parallelized applications.

AB - With the right techniques, multicore architectures may be able to continue the exponential performance trend that elevated the performance of applications of all types for decades. While many scientific programs can be parallelized without speculative techniques, speculative parallelism appears to be the key to continuing this trend for general-purpose applications. Recently-proposed code parallelization techniques, such as those by Bridges et al. and by Thies et al., demonstrate scalable performance on multiple cores by using speculation to divide code into atomic units (transactions) that span multiple threads in order to expose data parallelism. Unfortunately, most software and hardware Thread-Level Speculation (TLS) memory systems and transactional memories are not sufficient because they only support single-threaded atomic units. Multi-threaded Transactions (MTXs) address this problem, but they require expensive hardware support as currently proposed in the literature. This paper proposes a Software MTX (SMTX) system that captures the applicability and performance of hardware MTX, but on existing multicore machines. The SMTX system yields a harmonic mean speedup of 13.36x on native hardware with four 6-core processors (24 cores in total) running speculatively parallelized applications.

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

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

U2 - 10.1145/1736020.1736030

DO - 10.1145/1736020.1736030

M3 - Conference contribution

SN - 9781605588391

SP - 65

EP - 76

BT - ASPLOS XV - 15th International Conference on Architectural Support for Programming Languages and Operating Systems

ER -

Raman A, Kim H, Mason TR, Jablin TB, August DI. Speculative parallelization using software multi-threaded transactions. In ASPLOS XV - 15th International Conference on Architectural Support for Programming Languages and Operating Systems. 2010. p. 65-76 https://doi.org/10.1145/1736020.1736030