Fast Array Multiplication Methods for Large Datasets

Tiling in Matrix Multiplication for GPU Efficiency ⚙️ Matrix multiplication at GPU scale is not computed element by element. The matrices are divided into tiles so data can be reused efficiently in fast on-chip memory rather than being repeatedly fetched from HBM or GDDR. Tiling reduces global memory traffic and makes matrix multiplication bandwidth-efficient instead of memory-bound. Each output tile is produced by combining corresponding tiles from matrix A and B across the reduction dimension. These tiles fit in shared memory and registers so that each block of work can operate locally with minimal memory stalls. This is why most high-performance GPU kernels, including cuBLAS and CUTLASS, are built around block-level tiling strategies. On Tensor Core-based GPUs, these tiles are further broken down into 4×4 subtiles. Each subtile is executed by a Tensor Core using fused matrix multiply-accumulate instructions. One warp drives multiple Tensor Cores and computes a larger output tile by accumulating results from many of these 4×4 operations. Without tiling, Tensor Cores would remain underutilized because memory could not supply data fast enough.

While matrix multiplication is the most basic linear algebra operation, this is still deep enough that many technical careers can be devoted to it – especially when matrices are large and sparse. And ‘sparsity’ and ‘locality’ are normally an oxymoron together. Hence, I am pleased and proud to share this recent work from our lab, accepted for publication at, ICS’25, called MAGNUS: Matrix Algebra for Gigantic NUmerical Systems, a novel algorithm that maximizes data locality in SpGEMM. MAGNUS reorders the intermediate product into discrete cache-friendly chunks using a two-level hierarchical approach, a hybrid accumulation strategy, using two accumulators: an AVX-512 vectorized bitonic sorting algorithm and classical dense accumulation. For matrices from the SuiteSparse, MAGNUS is faster than all the baselines in most cases, up to an order of magnitude faster. For massive random matrices, MAGNUS scales to the largest matrix sizes, while the baselines do not. MAGNUS is also close to the optimal bound for these matrices, regardless of the matrix size, structure, and density. https://lnkd.in/gd7ZSBpM Jordi Wolfson-Pou Fabrizio Petrini Jan Laukemann

⚡️ Advanced Algorithms 101...FFT – The Magic Behind Fast Multiplications in CP Ever wondered how to multiply two huge polynomials or strings efficiently — when brute force just won't cut it? That’s where Fast Fourier Transform (FFT) comes in. 🧠 What is FFT? FFT computes the Discrete Fourier Transform (DFT) in O(n log n) time. In CP terms: > It lets you multiply two polynomials in O(n log n) instead of O(n²). It’s especially useful when handling large inputs that need convolution-based operations. ✨ But how does it work? The core idea: Instead of multiplying coefficients directly (which is slow), FFT: 1. Evaluates both polynomials at special complex roots of unity 2. Multiplies pointwise in that form (easy!) 3. Interpolates the result back to get the actual coefficients This transform-evaluate-interpolate pipeline makes FFT incredibly fast and efficient. 🧩 Where Is It Used? 1. Polynomial Multiplication – Count combinations in combinatorics 2. Large Integer Multiplication – Multiply digit arrays in log time 3. Pattern Matching – Use convolution to match strings or masks 4. Subset/XOR Convolutions – For advanced counting problems 5. NTT – Modular FFT alternative (common mod: 998244353) ✅ TL;DR: If your problem involves combining sequences, multiplying polynomials, or matching patterns with large input — FFT is likely your silver bullet. Feels like black magic at first. Then becomes one of your most elegant tools. Learn more about it here: https://lnkd.in/gCQsuJkG #FFT #CompetitiveProgramming #AlgorithmDesign #Polynomials #Codeforces #CPTricks #XORConvolution #NTT #DSA #SDEPrep #TimeComplexityWins