Compiler analysis of irregular memory accesses

Research output: Contribution to conferencePaper

Abstract

Irregular array accesses are array accesses whose array subscripts do not have closed-form expressions in terms of loop indices. Traditional array analysis and loop transformation techniques cannot handle irregular array accesses. In this paper, we study two kinds of simple and common cases of irregular array accesses: single-indexed access and indirect array access. We present techniques to analyze these two cases at compile-time, and we provide experimental results showing the effectiveness of these techniques in finding more implicit loop parallelism at compile-time and improved speedups.

Original languageEnglish (US)
Pages157-168
Number of pages12
StatePublished - Dec 1 2000
EventACM SIGPLAN 2000 Conference on Programming Language Design and Implementation (PLDI) - Vancouver, BC, Canada
Duration: Jun 18 2000Jun 21 2000

Other

OtherACM SIGPLAN 2000 Conference on Programming Language Design and Implementation (PLDI)
CountryCanada
CityVancouver, BC
Period6/18/006/21/00

Fingerprint

Data storage equipment

ASJC Scopus subject areas

  • Software

Cite this

Lin, Y., & Padua, D. A. (2000). Compiler analysis of irregular memory accesses. 157-168. Paper presented at ACM SIGPLAN 2000 Conference on Programming Language Design and Implementation (PLDI), Vancouver, BC, Canada.

Compiler analysis of irregular memory accesses. / Lin, Y.; Padua, David A.

2000. 157-168 Paper presented at ACM SIGPLAN 2000 Conference on Programming Language Design and Implementation (PLDI), Vancouver, BC, Canada.

Research output: Contribution to conferencePaper

Lin, Y & Padua, DA 2000, 'Compiler analysis of irregular memory accesses', Paper presented at ACM SIGPLAN 2000 Conference on Programming Language Design and Implementation (PLDI), Vancouver, BC, Canada, 6/18/00 - 6/21/00 pp. 157-168.
Lin Y, Padua DA. Compiler analysis of irregular memory accesses. 2000. Paper presented at ACM SIGPLAN 2000 Conference on Programming Language Design and Implementation (PLDI), Vancouver, BC, Canada.
Lin, Y. ; Padua, David A. / Compiler analysis of irregular memory accesses. Paper presented at ACM SIGPLAN 2000 Conference on Programming Language Design and Implementation (PLDI), Vancouver, BC, Canada.12 p.
@conference{cfdc7e3d50c64544afc10cbc201f4439,
title = "Compiler analysis of irregular memory accesses",
abstract = "Irregular array accesses are array accesses whose array subscripts do not have closed-form expressions in terms of loop indices. Traditional array analysis and loop transformation techniques cannot handle irregular array accesses. In this paper, we study two kinds of simple and common cases of irregular array accesses: single-indexed access and indirect array access. We present techniques to analyze these two cases at compile-time, and we provide experimental results showing the effectiveness of these techniques in finding more implicit loop parallelism at compile-time and improved speedups.",
author = "Y. Lin and Padua, {David A}",
year = "2000",
month = "12",
day = "1",
language = "English (US)",
pages = "157--168",
note = "ACM SIGPLAN 2000 Conference on Programming Language Design and Implementation (PLDI) ; Conference date: 18-06-2000 Through 21-06-2000",

}

TY - CONF

T1 - Compiler analysis of irregular memory accesses

AU - Lin, Y.

AU - Padua, David A

PY - 2000/12/1

Y1 - 2000/12/1

N2 - Irregular array accesses are array accesses whose array subscripts do not have closed-form expressions in terms of loop indices. Traditional array analysis and loop transformation techniques cannot handle irregular array accesses. In this paper, we study two kinds of simple and common cases of irregular array accesses: single-indexed access and indirect array access. We present techniques to analyze these two cases at compile-time, and we provide experimental results showing the effectiveness of these techniques in finding more implicit loop parallelism at compile-time and improved speedups.

AB - Irregular array accesses are array accesses whose array subscripts do not have closed-form expressions in terms of loop indices. Traditional array analysis and loop transformation techniques cannot handle irregular array accesses. In this paper, we study two kinds of simple and common cases of irregular array accesses: single-indexed access and indirect array access. We present techniques to analyze these two cases at compile-time, and we provide experimental results showing the effectiveness of these techniques in finding more implicit loop parallelism at compile-time and improved speedups.

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

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

M3 - Paper

AN - SCOPUS:0034449442

SP - 157

EP - 168

ER -