Cache-aware Performance Modeling and Prediction for Dense Linear Algebra

TL;DR

This paper introduces a cache-aware performance modeling approach for dense linear algebra routines that predicts the best implementation and tuning parameters without executing the algorithms, significantly aiding optimization.

Contribution

It presents a novel methodology for predicting optimal dense linear algebra performance by modeling kernels and tracking cache contents, eliminating the need for runtime execution.

Findings

Performance predictions are within a few percent of the optimal results.

The methodology effectively identifies the best algorithm among alternatives.

It enables efficient tuning of linear algebra routines without actual execution.

Abstract

Countless applications cast their computational core in terms of dense linear algebra operations. These operations can usually be implemented by combining the routines offered by standard linear algebra libraries such as BLAS and LAPACK, and typically each operation can be obtained in many alternative ways. Interestingly, identifying the fastest implementation -- without executing it -- is a challenging task even for experts. An equally challenging task is that of tuning each routine to performance-optimal configurations. Indeed, the problem is so difficult that even the default values provided by the libraries are often considerably suboptimal; as a solution, normally one has to resort to executing and timing the routines, driven by some form of parameter search. In this paper, we discuss a methodology to solve both problems: identifying the best performing algorithm within a family of alternatives, and tuning algorithmic parameters for maximum performance; in both cases, we do not execute the algorithms themselves. Instead, our methodology relies on timing and modeling the computational kernels underlying the algorithms, and on a technique for tracking the contents of the CPU cache. In general, our performance predictions allow us to tune dense linear algebra algorithms within few percents from the best attainable results, thus allowing computational scientists and code developers alike to efficiently optimize their linear algebra routines and codes.