Most modern microprocessors support some form of vector operations that allow the same operation to be applied to small vectors of arguments simultaneously. Studies have shown that use of these instructions can improve the performance of many scientific codes by a factor of 2 or more. Unfortunately, the state of the art in autovectorization falls far short of this goal, only achieving improvements of 20-30% on the same codes.
While studies have shown that current autovectorizing compilers do not identify all of the opportunities for vectorization, little is known about why they fail to do so. Specifically, the project will focus on identifying weaknesses in compiler analyses that cause failures to vectorize. The goal of this research is to identify a list of causes that are responsible for the vast majority of these failures. This research will make it possible to develop better compiler analysis algorithms that will result in better autovectorizing compilers. The performance benefits of such compilers will improve the performance of applications ranging from multimedia software to scientific computing.
Our objective in this project was to develop strategies to overcome the limitations of compilers when carrying out a translation known as vectorization. Compilers are the computer system components that translate high level languages, such as C or Fortran, onto machine language, the language that machines execute. The way compilers are implemented is of great importance since, when they do a good job, the machine code generated is faster, more efficient. For today’s machines, an important part of this process of translation is vectorization, which is the agglomeration of operations to create vector instructions that execute a single operations on multiple pairs of operands. Generating, whenever possible, these vector instructions, instead of a single instruction for each operation, not only makes programs faster but also save energy. Although techniques for vectorization have been studied since the 1970s, recent studies show that compilers today still miss many opportunities to agglomerate operations. It is therefore important to work on improving compilers. In this project, we developed a tool, called VectorSeeker, to analyze programs looking for vectorization opportunities missed by compilers. The tool works by creating a trace (a list of the memory locations accessed by the program) and then analyze the trace seeking sets of operations that could be agglomerated. We expect VectorSeeker to help not only in the study of the effectiveness of compilers but also make it easier for programmers to overcome the limitations of compilers by manually translating their codes. Work on VectorSeeker continues under the sponsorship from the Department of Energy. Furthermore, what was learned in this project helped us put together an NSF proposal to the XPS program which was recently submitted.
