English (United Kingdom)

https://curated-unify.zendy.io/wp-json/zendy-region/v1/featured_content/oa?rat=en

https://curated-unify.zendy.io/wp-json/zendy-region/v1/highlighted_journal/

Global: Zendy Plus annual

Presents the access of premium content as premium feature

Premium Content

Presents the keyphrase highlighting as premium feature

Keyphrase Highlighting

Presents the summarisation as premium feature

Summarisation

Insights

Presents the pdf analysis as premium feature

PDF Analysis

Presents the zaia usage as premium feature

ZAIA

Global: Zendy Plus monthly

Global: Zendy Tools annual

Global: Zendy Tools monthly

Global: Zendy Free Plan

Linear algebra expressions, which play a central role in countless scientificcomputations, are often computed via a sequence of calls to existing librariesof building blocks (such as those provided by BLAS and LAPACK). A sequenceidentifies a computing strategy, i.e., an algorithm, and normally for onelinear algebra expression many alternative algorithms exist. Althoughmathematically equivalent, those algorithms might exhibit significantdifferences in terms of performance. Several high-level languages and tools formatrix computations such as Julia, Armadillo, Linnea, etc., make algorithmicchoices by minimizing the number of Floating Point Operations (FLOPs). However,there can be several algorithms that share the same (or have nearly identical)number of FLOPs; in many cases, these algorithms exhibit execution times whichare statistically equivalent and one could arbitrarily select one of them asthe best algorithm. It is however not unlikely to find cases where theexecution times are significantly different from one another (despite the FLOPcount being almost the same). It is also possible that the algorithm thatminimizes FLOPs is not the one that minimizes execution time. In this work, wedevelop a methodology to test the reliability of FLOPs as discriminant forlinear algebra algorithms. Given a set of algorithms (for an instance of alinear algebra expression) as input, the methodology ranks them intoperformance classes; i.e., multiple algorithms are allowed to share the samerank. To this end, we measure the algorithms iteratively until the changes inthe ranks converge to a value close to zero. FLOPs are a valid discriminant foran instance if all the algorithms with minimum FLOPs are assigned the bestrank; otherwise, the instance is regarded as an anomaly, which can then be usedin the investigation of the root cause of performance differences.

A Test for FLOPs as a Discriminant for Linear Algebra Algorithms