Array unification: A locality optimization technique

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

3 Citations (Scopus)

Abstract

One of the key challenges facing computer architects and compiler writers is the increasing discrepancy between processor cycle times and main memory access times. To alleviate this problem for a class of array-dominated codes, compilers may employ either control- centric transformations that change data access patterns of nested loops or data-centric transformations that modify the memory layouts of multidimensional arrays. Most of the layout optimizations proposed so far either modify the layout of each array independently or are based on explicit data reorganizations at runtime. This paper describes a compiler technique, called array unification, that automatically maps multiple arrays into a single data (array) space to improve data locality. We present a mathematical framework that enables us to systematically derive suitable mappings for a given program. The framework divides the arrays accessed by the program into several groups and each group is transformed to improve spatial locality and reduce the number of conflict misses. As compared to the previous approaches, the proposed technique works on a larger scope and makes use of independent layout transformations as well whenever necessary. Preliminary results on two benchmark codes show significant improvements in cache miss rates and execution time.

Original languageEnglish (US)
Title of host publicationCompiler Construction - 10th International Conference, CC 2001 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2001, Proceedings
EditorsReinhard Wilhelm
PublisherSpringer Verlag
Pages259-273
Number of pages15
ISBN (Print)354041861X, 9783540418610
DOIs
StatePublished - Jan 1 2001
Event10th International Conference on Compiler Construction, CC 2001 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2001 - Genova, Italy
Duration: Apr 2 2001Apr 6 2001

Publication series

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

Other

Other10th International Conference on Compiler Construction, CC 2001 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2001
CountryItaly
CityGenova
Period4/2/014/6/01

Fingerprint

Unification
Locality
Optimization Techniques
Data storage equipment
Layout
Compiler
Multidimensional Arrays
Data Locality
Data Transformation
Cache
Execution Time
Discrepancy
Divides
Benchmark
Necessary
Optimization

All Science Journal Classification (ASJC) codes

  • Theoretical Computer Science
  • Computer Science(all)

Cite this

Kandemir, M. T. (2001). Array unification: A locality optimization technique. In R. Wilhelm (Ed.), Compiler Construction - 10th International Conference, CC 2001 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2001, Proceedings (pp. 259-273). (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 2027). Springer Verlag. https://doi.org/10.1007/3-540-45306-7_18
Kandemir, Mahmut Taylan. / Array unification : A locality optimization technique. Compiler Construction - 10th International Conference, CC 2001 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2001, Proceedings. editor / Reinhard Wilhelm. Springer Verlag, 2001. pp. 259-273 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)).
@inproceedings{9478a43996f94dd8bc04e5995b3d817f,
title = "Array unification: A locality optimization technique",
abstract = "One of the key challenges facing computer architects and compiler writers is the increasing discrepancy between processor cycle times and main memory access times. To alleviate this problem for a class of array-dominated codes, compilers may employ either control- centric transformations that change data access patterns of nested loops or data-centric transformations that modify the memory layouts of multidimensional arrays. Most of the layout optimizations proposed so far either modify the layout of each array independently or are based on explicit data reorganizations at runtime. This paper describes a compiler technique, called array unification, that automatically maps multiple arrays into a single data (array) space to improve data locality. We present a mathematical framework that enables us to systematically derive suitable mappings for a given program. The framework divides the arrays accessed by the program into several groups and each group is transformed to improve spatial locality and reduce the number of conflict misses. As compared to the previous approaches, the proposed technique works on a larger scope and makes use of independent layout transformations as well whenever necessary. Preliminary results on two benchmark codes show significant improvements in cache miss rates and execution time.",
author = "Kandemir, {Mahmut Taylan}",
year = "2001",
month = "1",
day = "1",
doi = "10.1007/3-540-45306-7_18",
language = "English (US)",
isbn = "354041861X",
series = "Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)",
publisher = "Springer Verlag",
pages = "259--273",
editor = "Reinhard Wilhelm",
booktitle = "Compiler Construction - 10th International Conference, CC 2001 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2001, Proceedings",
address = "Germany",

}

Kandemir, MT 2001, Array unification: A locality optimization technique. in R Wilhelm (ed.), Compiler Construction - 10th International Conference, CC 2001 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2001, Proceedings. Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), vol. 2027, Springer Verlag, pp. 259-273, 10th International Conference on Compiler Construction, CC 2001 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2001, Genova, Italy, 4/2/01. https://doi.org/10.1007/3-540-45306-7_18

Array unification : A locality optimization technique. / Kandemir, Mahmut Taylan.

Compiler Construction - 10th International Conference, CC 2001 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2001, Proceedings. ed. / Reinhard Wilhelm. Springer Verlag, 2001. p. 259-273 (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics); Vol. 2027).

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

TY - GEN

T1 - Array unification

T2 - A locality optimization technique

AU - Kandemir, Mahmut Taylan

PY - 2001/1/1

Y1 - 2001/1/1

N2 - One of the key challenges facing computer architects and compiler writers is the increasing discrepancy between processor cycle times and main memory access times. To alleviate this problem for a class of array-dominated codes, compilers may employ either control- centric transformations that change data access patterns of nested loops or data-centric transformations that modify the memory layouts of multidimensional arrays. Most of the layout optimizations proposed so far either modify the layout of each array independently or are based on explicit data reorganizations at runtime. This paper describes a compiler technique, called array unification, that automatically maps multiple arrays into a single data (array) space to improve data locality. We present a mathematical framework that enables us to systematically derive suitable mappings for a given program. The framework divides the arrays accessed by the program into several groups and each group is transformed to improve spatial locality and reduce the number of conflict misses. As compared to the previous approaches, the proposed technique works on a larger scope and makes use of independent layout transformations as well whenever necessary. Preliminary results on two benchmark codes show significant improvements in cache miss rates and execution time.

AB - One of the key challenges facing computer architects and compiler writers is the increasing discrepancy between processor cycle times and main memory access times. To alleviate this problem for a class of array-dominated codes, compilers may employ either control- centric transformations that change data access patterns of nested loops or data-centric transformations that modify the memory layouts of multidimensional arrays. Most of the layout optimizations proposed so far either modify the layout of each array independently or are based on explicit data reorganizations at runtime. This paper describes a compiler technique, called array unification, that automatically maps multiple arrays into a single data (array) space to improve data locality. We present a mathematical framework that enables us to systematically derive suitable mappings for a given program. The framework divides the arrays accessed by the program into several groups and each group is transformed to improve spatial locality and reduce the number of conflict misses. As compared to the previous approaches, the proposed technique works on a larger scope and makes use of independent layout transformations as well whenever necessary. Preliminary results on two benchmark codes show significant improvements in cache miss rates and execution time.

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

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

U2 - 10.1007/3-540-45306-7_18

DO - 10.1007/3-540-45306-7_18

M3 - Conference contribution

AN - SCOPUS:84958967330

SN - 354041861X

SN - 9783540418610

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

SP - 259

EP - 273

BT - Compiler Construction - 10th International Conference, CC 2001 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2001, Proceedings

A2 - Wilhelm, Reinhard

PB - Springer Verlag

ER -

Kandemir MT. Array unification: A locality optimization technique. In Wilhelm R, editor, Compiler Construction - 10th International Conference, CC 2001 Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2001, Proceedings. Springer Verlag. 2001. p. 259-273. (Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)). https://doi.org/10.1007/3-540-45306-7_18