Fast Clifford Neural Layers

Lin Xiao; Max Neuwinger; Tianxiang Xia

REVIEW 3 major objections 5 minor 16 references

Fast Clifford Neural Layers

T0 review · 3 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Hand-tuned C kernels bring 2D and 3D Clifford convolution to the CPU's arithmetic peak, cutting inference time by 30%.

desk verdict Solid, carefully benchmarked engineering report on CPU optimization for Clifford layers; the speedups are plausible but the paper never checks that the fast kernels compute the same thing as the PyTorch reference, which is the one real gap. read the letter →

arxiv 2507.01040 v1 pith:2ZJDTGLN submitted 2025-06-22 cs.LG cs.AIcs.NEcs.PF

Tianxiang Xia , Max Neuwinger , Lin Xiao This is my paper

classification cs.LGcs.AIcs.NEcs.PF

keywords CliffordneurallayersCPUoptimizationAVX2convolutionmultivectoractivationcodegenerationinferencespeedupFLOPs/cycle

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Clifford neural layers are neural-network building blocks whose activations and weights are multivectors in a Clifford algebra; they are used in PDE and scientific-learning models. This paper claims those layers can be made dramatically cheaper to run on a single CPU core by restructuring memory layout, vectorizing with AVX2, and compiling the algebra's sign structure into fused-multiply-add kernels. The authors report 31 of 32 FLOPs/cycle for 2D and 3D Clifford convolution, up to 50x speedup for multivector activation, and a 30% (2D) or 7% (3D) end-to-end inference speedup over the reference implementation in large, cache-exceeding workloads. If right, the result means Clifford-network inference is not inherently computation-bound in practice; careful single-core kernels can approach the hardware's arithmetic ceiling.

What carries the argument

The load-bearing mechanism is the package-tensor layout: batch elements are grouped into packages of length $L$, giving arrays shaped $(C_{\text{in}}, d_{\text{image}}^k, B/L, N_B, L)$ with blade and batch dimensions adjacent. Around this layout, the paper builds a Python code generator that emits C kernels specialized to each concrete Clifford signature, so every blade-product contribution becomes a fused multiply-add or fused negated multiply-add with no branching, no data duplication, and no kernel construction. The package layout is what makes a Clifford product between one filter element and many multivectors a dense block of independent vector FMAs; the signature specialization is what lets the emitted code run at the AVX2 arithmetic peak.

What would settle it

Run the released kernels and the reference implementation on identical random inputs for a 2D Clifford convolution with a fixed signature and compare the outputs element-wise at single-precision tolerance; the paper includes no equivalence test, so any mismatch beyond rounding would show that the 30% speedup is not a drop-in improvement.

Watch

Extended reading notes

Core claim

On its own terms, the central discovery is that Clifford convolution can be expressed as a dense block of vectorized fused multiply-adds rather than as scalar multiplication over blades. The paper groups batch elements into 'packages' of length $L$ and arranges the data so that blade and batch indices are contiguous, making a single Clifford product between a filter element and a package a compact set of independent FMAs. Because the Clifford signature entries are only $-1$, $0$, or $+1$, every blade-pair contribution collapses to an FMA or negated FMA, so a code generator emits a specialized AVX2 kernel for each signature combination. On the test CPU this reaches 31 FLOPs/cycle for 2/3D convolution, effectively the single-precision compute bound, and the accompanying multivector-activation kernels achieve up to 50x speedup over a direct C baseline.

Load-bearing premise

The load-bearing premise is that the optimized C kernels produce outputs numerically identical to the reference implementation, because the paper reports only timing and never compares outputs; if the kernels compute something slightly different, the speedups would not transfer to real use.

Editorial extensions

If this is right

If the kernels are correct, 2D and 3D Clifford convolution on single-core AVX2 CPUs has essentially hit its arithmetic floor; no further instruction-level optimization can make it faster.
The end-to-end speedups (30% in 2D, 7% in 3D) are smaller than the kernel speedups because activation layers were already not the bottleneck; future work should target the convolutional and memory-rearrangement parts.
The fastest kernels assume batch sizes divisible by 8 and, for activation layers, that all blades participate in the gating scalar, so the gains apply to batched inference with full gating rather than to arbitrary layer configurations.
For 1D convolution the reported throughput stays below the compute bound (~24-25 FLOPs/cycle), so the same technique does not fully saturate that operator.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If the missing numerical-equivalence test is supplied and passes, the same package-and-codegen recipe could be ported to other SIMD widths or to GPUs, where Clifford products could be treated as small matrix multiplications instead of FMA blocks.
The signature-specialized code generation generalizes beyond Clifford algebras: any layer whose structure constants are sparse and signed could be compiled into FMAs in the same way, which might benefit other geometric algebras or quaternion/octonion layers.
The reported speedups are tied to one CPU and compiler; reproducing the 30% figure on other AVX2 machines or with a different compiler would strengthen the claim, and the paper itself notes unrolling behavior differs on a less superscalar core.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

I read this as a thorough optimization report rather than a research breakthrough, and that's fine—it does what it sets out to do. The genuinely new pieces are the signature-specialized C kernels for Clifford convolution, linear, and activation layers, plus the measured speedups. The authors get credit for careful benchmarking: single P-core, locked frequency, ASLR off, detailed cache/bandwidth specs, VTune profiling, and honest reporting of negative results (e.g., unrolling not helping on their CPU, the unexplained peak in filter-size sweeps). Hitting ~31 FLOPs/cycle for 2D/3D convolution on an AVX2 core is a real achievement, and the open-source repo is a plus.

The main soft spot is exactly what the stress test flags: there are no numerical equivalence tests anywhere in the paper. The network-level speedup claims (30% for 2D, 7% for 3D) are wall-clock timings only, and the optimized kernels are compiled with -ffast-math and hand-specialized FMA/FNMAD forms that can change rounding, or in edge cases with sign cancellations, produce materially different outputs. The authors may well have verified correctness informally, but it's not in the paper and no commit hash is pinned, so the reader cannot check. Given that the entire practical value rests on these kernels being drop-in replacements for the PyTorch layer, a tolerance-based output comparison against the reference should be a required addition, not an optional nicety.

Also softer: the activation "up to 50x" speedup is against their own direct C baseline, so it's less informative than the external comparison; the 2D/3D network comparison is a single block, no error bars or run-to-run variance; and all results are on one CPU (i7-12700KF) plus one NEON comment, so architecture-specificity is mostly unquantified. None of these kill the contribution—the 30%/7% network numbers are modest but real—but they do limit generalizability.

Who this is for: anyone doing CPU inference with Clifford neural layers, or looking for a worked example of vectorizing a niche tensor algebra on AVX2. It is an engineering contribution, not a conceptual one, and that's acceptable.

My recommendation: this deserves peer review, but at a workshop or systems-oriented venue, and it should be conditionally accepted only after the authors add equivalence tests, a pinned repo state, and a few repeated-run statistics. The benchmarks look careful enough that the speedups are probably real; I just can't verify correctness from the text, and the fix is easy.

Referee Report

3 major / 5 minor

Summary. The paper presents optimized C kernels, with ctypes-based Python interfaces, for Clifford convolutional, multivector activation, and Clifford linear layers, and benchmarks them on a single core of an Intel i7-12700KF against the Microsoft cliffordlayers PyTorch library. The main reported results are: up to 31 FLOPs/cycle for 2/3D Clifford convolution (close to the AVX2 single-precision peak of 32 FLOPs/cycle), up to 50x speedup for the multivector activation layer relative to a direct C baseline, and 30% (2D) / 7% (3D) average inference-time speedups for a realistic network block compared with the reference PyTorch implementation. The paper also documents a sequence of optimization steps (memory layout, vectorization, unrolling, code generation for signature-specific arithmetic) and includes microarchitectural profiling with VTune and compiler reports. The code is open source.

Significance. If the reported speedups correspond to numerically correct implementations, this is a useful engineering contribution: it shows that the high operation intensity of Clifford convolution can be exploited to approach the AVX2 arithmetic peak on a specific CPU, and it provides an open-source code generator that makes the optimization process reproducible. The benchmark discipline is a genuine strength: single P-core, locked frequency, ASLR disabled, detailed hardware description, and compiler/VTune evidence are all reported. However, the central claim depends on two currently unverified assumptions: that the optimized C kernels compute the same mathematical function as the PyTorch reference, and that the small 7% 3D speedup is outside measurement noise. Both are fixable with additional experiments, so the paper merits revision rather than rejection.

major comments (3)

[Section 4, Table 2] The paper reports only timings and never reports numerical equivalence or unit tests for the optimized C kernels against the PyTorch reference. Since the C kernels are compiled with -ffast-math (Fig. 3 caption) and use signature-specialized FMA/FNMAD arithmetic with reassociation, they could in principle compute outputs that differ from the reference, and in pathological Clifford products with sign cancellations the difference could be material. The speedup claims in Table 2 are only meaningful if both implementations compute the same layer. Please add a tolerance-based numerical comparison (e.g., maximum absolute and relative error on random inputs, across signatures, batch sizes, K=4 and K=8 activations, and the actual network block) and report a commit hash of the tested code.
[Section 4, Table 2] No run-to-run variance, repeat count, or error bars are reported for the network-level timings. The 2D speedup of about 30% is likely robust, but the 3D speedup of about 7% (3479 ms vs. 3238 ms; 3487 ms vs. 3270 ms) is small enough that it could be within run-to-run or measurement noise. Please report the number of repeated runs and the mean plus standard deviation (or min/max) for each configuration, and state whether the same runs are used for all rows.
[Section 3, 'Clifford convolutional layers' and Fig. 3] The FLOPs/cycle numbers that support the near-peak claim are not fully reproducible because the paper does not specify how FLOPs are counted or how cycles are measured. In particular, state whether each FMA counts as one or two FLOPs, whether the simplified signature-specific arithmetic reduces the FLOP count relative to the generic Clifford product, whether memory-rearrangement overhead is included, and whether cycles are read from hardware performance counters. Without this methodology, '31 FLOPs/cycle' and 'hit the 32 FLOPs/cycle compute bound' cannot be independently verified.

minor comments (5)

[Abstract and Introduction] The footnote marker in 'hard compute bound 1' is easy to misread as a numerical bound; please write '(hard compute bound of 32 FLOPs/cycle on this CPU)' or use a conventional footnote notation.
[Section 3, 'Multivector activation layers'] The 'up to 50x speedup' for the activation layer is measured against the authors' own direct C baseline, not against the PyTorch reference. The paper should state this explicitly in the abstract or contribution list so that readers do not interpret it as a PyTorch-relative speedup.
[Section 4, 'Experimental setup'] The sentence 'icx/gcc specs are in plot/caption' is too vague for Table 2; please give the exact compiler versions, flags, and CPU frequency for the network benchmarks in the table caption or text.
[Section 4, 'Comparison with PyTorch'] The statement 'our C implementations improve only the performance in 2D by a small amount' is confusing in light of Table 2, where replacing the activation changes the 2D time from 3051 ms to 3042 ms and the 3D time from 3479 ms to 3487 ms; consider rewording to 'replacing only the activation layer has a small effect'.
[Throughout] The paper reports that unrolling hurts 2D/3D performance on the i7 but helps on an i5; this is a useful caveat, but the manuscript would benefit from a sentence explaining that the reported 'most optimized' versions are tied to the i7-12700KF and may not transfer to other microarchitectures.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the headline speedup is benchmarked against the external Microsoft cliffordlayers library, and no load-bearing claim reduces to its own input.

full rationale

The paper's core claims are measured performance results, not derivations from fitted parameters or self-referential definitions. The headline claim, 'our implementation is 30% faster than standard PyTorch implementation,' is evaluated against the external Microsoft cliffordlayers PyTorch library [1], which is independent of the authors' own code and not fitted to the reported numbers. The reported 31 FLOPs/cycle for 2/3D Clifford convolutional layers is compared with the hardware peak of 32 FLOPs/cycle; it is a measured throughput figure, not a parameter fitted so that the speedup claim becomes true by construction. The activation-layer speedup 'up to x50 performance of direct C baseline' is explicitly measured against the authors' own direct C baseline, which is an internal reference rather than an external one; however, it is clearly labeled as such, does not feed into the headline 30% claim, and no equation equates the speedup to a fitted input. There is also no load-bearing self-citation: [1] is the external reference implementation, [2] and [3] are background, and no 'uniqueness theorem' or prior-work premise is imported to force the authors' choices. The absence of reported numerical equivalence tests against the PyTorch reference is a validation gap concerning correctness, not a circularity in the performance claim; it does not make the measured speedup definitionally equal to its input. Therefore no specific circular step can be quoted, and the appropriate score is 0.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

There are no scientific free parameters fitted to experimental data, but several implementation choices (batch size 8, no unrolling for 2/3D, package length) are hand-tuned and condition the benchmark results. The main assumptions are standard Clifford algebra background, the CPU's theoretical 32 FLOPs/cycle peak, benchmark-environment stability, and the fairness of the PyTorch baseline.

free parameters (3)

batch_size_multiple = 8
The most optimized convolutional and activation kernels assume batch size divisible by 8; the 30%/7% network speedups are measured with this constraint, so the claim is conditional on it.
unrolling_factor = 1 for 2/3D final benchmarks; benchmarked per configuration for 1D
Unrolling did not help on the i7-12700KF; the final 2/3D results use no unrolling and batch size 8.
package_length_L = decomposed as vector length 8 times unrolling factor
Opt2 decomposes L into vector length and unrolling factor; performance is sensitive to L, and the exact value is not reported.

assumptions (4)

standard math Clifford algebra multiplication obeys the stated relations e_i^2 = g_i and e_i e_j = -e_j e_i for i != j.
This is the algebraic background from [3] that defines the operations being optimized.
domain assumption The Intel i7-12700KF can execute at most 32 FLOPs/cycle for single-precision AVX2 FMA operations.
This is the compute-bound ceiling used to interpret the 31 FLOPs/cycle result; it comes from microarchitecture references, not from measurements in this paper.
domain assumption The benchmark environment (locked 3.6 GHz, single core, SMT disabled, ASLR off) yields stable and representative measurements.
The paper reports average times without standard deviations or run counts, so the stability of the environment is assumed rather than demonstrated.
domain assumption The Microsoft cliffordlayers PyTorch implementation is a fair and representative baseline for the standard implementation.
The headline speedup is measured against this library as used by default; if the library has a faster configuration not tested, the speedup could be overstated.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Fast Clifford Neural Layers." pith.science (2026). https://pith.science/paper/2ZJDTGLN

@misc{pith2026250701040,
  author       = {Pith},
  title        = {Pith review of: Fast Clifford Neural Layers},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2ZJDTGLN}},
  note         = {Machine review of arXiv:2507.01040}
}

read the original abstract

Clifford Neural Layers improve PDE modeling by introducing Clifford Algebra into neural networks. In this project we focus on optimizing the inference of 2/3D Clifford convolutional layers and multivector activation layers for one core CPU performance. Overall, by testing on a real network block involving Clifford convolutional layers and multivector activation layers, we observe that our implementation is 30% faster than standard PyTorch implementation in relatively large data + network size (>L2 cache). We open source our code base at https://github.com/egretwAlker/c-opt-clifford-layers

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

16 extracted references · 15 canonical work pages

[1]

[2] [3] However, the exist- ing implementation by Microsoft researchers [1] is limited in computation and memory efficiency

INTRODUCTION Motivation.Clifford Neural Layers have various applica- tion fields in modeling dynamic systems eg fluid dynamic simulation, weather forecasting. [2] [3] However, the exist- ing implementation by Microsoft researchers [1] is limited in computation and memory efficiency. Among the Clifford neural layers, Clifford convolutional and linear layer...

work page
[2]

BACKGROUND ON THE ALGORITHM/APPLICA TION Clifford Algebra.Ak-dimensional real Clifford algebra

work page
[3]

Fast Clifford Neural Layers

withsignatureg= (g 1, . . . , gk)∈ {±1,0}k is defined as a Ring(Cℓ g Rk ,+,∗), generated by a basis{e 1, . . . , ek} subject to the relations: e2 i =g i ande iej =−e jei (i̸=j) The set of all algebraic elements (calledmultivectors) is: Cℓg Rk =    X I⊆{1,...,k} cI ·e I |c I ∈R, eI = Y i∈I ei    ≃R 2k where the producte I is taken in increasing order...

work page Pith review arXiv 2025
[4]

local operation intensity

OPTIMIZA TION PERFORMED Clifford convolutional layers.The baseline and all the optimizations follow the same input and output protocol: input.shape=(B,C in,d k image,N B),filters.shape=(N B,C in, Cout,d k filter),bias.shape=(N B,C out),output.shape=(B, Cout,d k out,N B) wherekis both the dimension of the im- ages and Clifford Algebra in consideration, in ...

work page
[5]

The architecture supports A VX2 and SSE2, and its Performance-cores feature a 48 KB L1 data cache, 1 MB L2 cache, and a shared 25 MB L3 cache[5][6]

EXPERIMENTAL RESULTS Experimental setup.All benchmarks were conducted on a 12th Gen Intel® Core™ i7-12700KF processor with 32 GB of DDR4-3200 memory. The architecture supports A VX2 and SSE2, and its Performance-cores feature a 48 KB L1 data cache, 1 MB L2 cache, and a shared 25 MB L3 cache[5][6]. The read bandwidths of L1, L2, L3 caches and RAM are resp....

work page
[6]

Plotted for those layers

CONTRIBUTIONS OF TEAM MEMBERS (MANDA TORY) Tianxiang Xia.Designed and implemented baseline and optimizations for Clifford linear layers and Clifford convo- lutional layers. Plotted for those layers. Wrote script for comparison with PyTorch. Max Neuwinger .Designed and implemented baseline and optimizations for multivector activation layers. Wrote benchmar...

work page
[7]

CONCLUSIONS This project presents comprehensive optimization, perfor- mance analysis and profiling of Clifford neural layers tar- geting our specific i7-12700KF CPU. It demonstrates how to release the high operation intensity of Clifford convolu- tional layers and achieve one core maximum performance (2/3D), how to reduce a Clifford linear layer to multip...

work page
[8]

6 (K= 4) show the performance gains of our optimizations

and Fig. 6 (K= 4) show the performance gains of our optimizations. The plots depict FLOPs/cycle vs. problem size (B×C, i.e., batch size×channels) across all three aggregation modes, with a clear progression explained by microarchitectural profiling and compiler analysis. Our analysis begins with theBaseline, which exhibits very low, constant performance.O...

work page

Show all 16 references

[9]

Clifford layers: A pytorch library for geometric deep learning with clifford algebras,

Microsoft Research, “Clifford layers: A pytorch library for geometric deep learning with clifford algebras,”https://github.com/microsoft/ cliffordlayers, 2023, GitHub repository

2023
[10]

Clifford neural layers for pde modeling,

J. Brandstetter, R. van den Berg, M. Welling, and J.K. Gupta, “Clifford neural layers for pde modeling,” https://arxiv.org/abs/2209.04934, 2022, arXiv preprint arXiv:2209.04934

2022 arXiv
[11]

Geometric clifford algebra networks,

D. Ruhe, J.K. Gupta, S. De Keninck, M. Welling, and J. Brandstetter, “Geometric clifford algebra networks,” inProc. Int. Conf. Machine Learning (ICML). July 2023, pp. 29306–29337, PMLR

2023
[12]

Basic linear algebra subprograms (blas),

Netlib, “Basic linear algebra subprograms (blas),” https://www.netlib.org/blas/, 2024, Ac- cessed via Netlib

2024
[13]

Intel core i7-12700kf,

Performance Databases, “Intel core i7-12700kf,” https://performancedatabases.com/ Content/Database/CPU/Info.php? CPUName=Intel+Core+i7+12700KF, Jan- uary 2022, Performance and benchmark aggregation for i7-12700KF

2022
[14]

Intel core i7-12700kf pro- cessor (25m cache, up to 5.00 ghz) specifica- tions,

Intel Corporation, “Intel core i7-12700kf pro- cessor (25m cache, up to 5.00 ghz) specifica- tions,”https://www.intel.com/content/ www/us/en/products/sku/134595/ intel-core-i712700kf-processor-25m-cache-up-to-5-00-ghz/ specifications.html, December 2021, Intel official process...

2021
[15]

Popping the hood on golden cove,

Chips and Cheese, “Popping the hood on golden cove,”https://old. chipsandcheese.com/2021/12/02/ popping-the-hood-on-golden-cove/, December 2021, In-depth technical analysis of Intel’s Golden Cove architecture

2021
[16]

Golden cove,

Wikipedia contributors, “Golden cove,”https:// en.wikipedia.org/wiki/Golden_Cove, June 2024, Wikipedia entry on Intel’s Golden Cove CPU mi- croarchitecture

2024

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.

[1] [1]

[2] [3] However, the exist- ing implementation by Microsoft researchers [1] is limited in computation and memory efficiency

INTRODUCTION Motivation.Clifford Neural Layers have various applica- tion fields in modeling dynamic systems eg fluid dynamic simulation, weather forecasting. [2] [3] However, the exist- ing implementation by Microsoft researchers [1] is limited in computation and memory efficiency. Among the Clifford neural layers, Clifford convolutional and linear layer...

work page

[2] [2]

BACKGROUND ON THE ALGORITHM/APPLICA TION Clifford Algebra.Ak-dimensional real Clifford algebra

work page

[3] [3]

Fast Clifford Neural Layers

withsignatureg= (g 1, . . . , gk)∈ {±1,0}k is defined as a Ring(Cℓ g Rk ,+,∗), generated by a basis{e 1, . . . , ek} subject to the relations: e2 i =g i ande iej =−e jei (i̸=j) The set of all algebraic elements (calledmultivectors) is: Cℓg Rk =    X I⊆{1,...,k} cI ·e I |c I ∈R, eI = Y i∈I ei    ≃R 2k where the producte I is taken in increasing order...

work page Pith review arXiv 2025

[4] [4]

local operation intensity

OPTIMIZA TION PERFORMED Clifford convolutional layers.The baseline and all the optimizations follow the same input and output protocol: input.shape=(B,C in,d k image,N B),filters.shape=(N B,C in, Cout,d k filter),bias.shape=(N B,C out),output.shape=(B, Cout,d k out,N B) wherekis both the dimension of the im- ages and Clifford Algebra in consideration, in ...

work page

[5] [5]

The architecture supports A VX2 and SSE2, and its Performance-cores feature a 48 KB L1 data cache, 1 MB L2 cache, and a shared 25 MB L3 cache[5][6]

EXPERIMENTAL RESULTS Experimental setup.All benchmarks were conducted on a 12th Gen Intel® Core™ i7-12700KF processor with 32 GB of DDR4-3200 memory. The architecture supports A VX2 and SSE2, and its Performance-cores feature a 48 KB L1 data cache, 1 MB L2 cache, and a shared 25 MB L3 cache[5][6]. The read bandwidths of L1, L2, L3 caches and RAM are resp....

work page

[6] [6]

Plotted for those layers

CONTRIBUTIONS OF TEAM MEMBERS (MANDA TORY) Tianxiang Xia.Designed and implemented baseline and optimizations for Clifford linear layers and Clifford convo- lutional layers. Plotted for those layers. Wrote script for comparison with PyTorch. Max Neuwinger .Designed and implemented baseline and optimizations for multivector activation layers. Wrote benchmar...

work page

[7] [7]

CONCLUSIONS This project presents comprehensive optimization, perfor- mance analysis and profiling of Clifford neural layers tar- geting our specific i7-12700KF CPU. It demonstrates how to release the high operation intensity of Clifford convolu- tional layers and achieve one core maximum performance (2/3D), how to reduce a Clifford linear layer to multip...

work page

[8] [8]

6 (K= 4) show the performance gains of our optimizations

and Fig. 6 (K= 4) show the performance gains of our optimizations. The plots depict FLOPs/cycle vs. problem size (B×C, i.e., batch size×channels) across all three aggregation modes, with a clear progression explained by microarchitectural profiling and compiler analysis. Our analysis begins with theBaseline, which exhibits very low, constant performance.O...

work page