# vectorization techniques

Vectorization techniques are techniques for converting scalar operations into SIMD vector operations that process multiple data elements in parallel, including compiler-assisted methods such as data alignment and compiler directives.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## NetWasm 0.10 Speeds Up C# on WebAssembly, Now Faster Than Mono AOT

DevFeed: [NetWasm 0.10 Speeds Up C# on WebAssembly, Now Faster Than Mono AOT](<https://devfeed.tech/articles/netwasm-0-10-speeds-up-c-on-webassembly-now-faster-than-mono-aot-142922.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/11/NetWasm-0-10-Faster/>)

Author: Edin Kapić

Published: 2026-11-19T09:00:00Z

Content type: news

Language: en

Sources: [InfoQ](<https://devfeed.tech/sources/infoq.md>)

Topics: [WebAssembly](<https://devfeed.tech/topics/web-assembly.md>), [inlining](<https://devfeed.tech/topics/inlining.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [Exception](<https://devfeed.tech/topics/exception.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>)

Tags: [aot](<https://devfeed.tech/tags/aot.md>), [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [c-sharp](<https://devfeed.tech/tags/c-sharp.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [desktop](<https://devfeed.tech/tags/desktop.md>), [development](<https://devfeed.tech/tags/development.md>), [dotnet](<https://devfeed.tech/tags/dotnet.md>), [exception-handling](<https://devfeed.tech/tags/exception-handling.md>), [faster](<https://devfeed.tech/tags/faster.md>), [mono](<https://devfeed.tech/tags/mono.md>), [net](<https://devfeed.tech/tags/net.md>), [net-11](<https://devfeed.tech/tags/net-11.md>), [netwasm-0-10-faster](<https://devfeed.tech/tags/netwasm-0-10-faster.md>), [news](<https://devfeed.tech/tags/news.md>), [simd](<https://devfeed.tech/tags/simd.md>), [wasi](<https://devfeed.tech/tags/wasi.md>), [webassembly](<https://devfeed.tech/tags/webassembly.md>)

### AI overview

NetWasm 0.10's compiler optimizations made it faster than Mono AOT on the project's benchmark set: across 2,213 cases, version 0.10.8 at O3 with NetWasmGC took 0.41 times Mono AOT's time as a geometric mean, excluding five cases where Mono's LLVM removed the work. Changes across releases 0.10.1-0.10.8 included shared exception handling, inlining and redundant bounds-check removal, 128-bit WebAssembly SIMD with scalar fallback, and reuse of division results for remainder and range checks. The excerpt reports gains on quicksort, DoomSharp, and a vectorized fluid-equation solver, while desktop .NET 11 RC3 remained faster overall at 0.87 times NetWasm's time. Results used Wasmtime 49.0.3 on one Apple M1 Max; the authors note measurement sensitivity to function alignment, slower vector performance than desktop .NET, specific slow operations, and a NewtR regression.

### Source excerpt

Summary: NetWasm, an ahead-of-time compiler from C# to WebAssembly, has reworked exception handling, bounds-check elimination, SIMD and division in its 0.10 series. Across more than 2000 benchmark cases, the project reports running in 0.41 times the time of Mono AOT's WASI build. By Edin Kapić

## PMKPIR: Parallel Multi-Keyword PIR with Interleaved Batching for Private Boolean Retrieval

DevFeed: [PMKPIR: Parallel Multi-Keyword PIR with Interleaved Batching for Private Boolean Retrieval](<https://devfeed.tech/articles/pmkpir-parallel-multi-keyword-pir-with-interleaved-batching-for-private-boolean-retrieval-143148.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.24248>)

Author: Rongxi Wang, Guanxiong Ha, Chunfu Jia, Minfen Gao, Hanmiaomiao Wang

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [homomorphic encryption](<https://devfeed.tech/topics/homomorphic-encryption.md>), [information retrieval](<https://devfeed.tech/topics/information-retrieval.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>)

Tags: [batching](<https://devfeed.tech/tags/batching.md>), [boolean](<https://devfeed.tech/tags/boolean.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [homomorphic-encryption](<https://devfeed.tech/tags/homomorphic-encryption.md>), [matching](<https://devfeed.tech/tags/matching.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [pir](<https://devfeed.tech/tags/pir.md>), [private](<https://devfeed.tech/tags/private.md>), [query-processing](<https://devfeed.tech/tags/query-processing.md>), [retrieval](<https://devfeed.tech/tags/retrieval.md>), [security](<https://devfeed.tech/tags/security.md>), [security-analysis](<https://devfeed.tech/tags/security-analysis.md>), [simd](<https://devfeed.tech/tags/simd.md>), [storage](<https://devfeed.tech/tags/storage.md>), [time](<https://devfeed.tech/tags/time.md>), [traversal](<https://devfeed.tech/tags/traversal.md>)

### AI overview

PMKPIR combines interleaved batching with BFV homomorphic encryption to support parallel multi-keyword matching and universal Boolean computation while preserving the core security guarantees of classic PIR, according to the authors' analysis. Its IBPIR component matches multiple keywords in one database traversal; a Boolean query method extends that parallelism to Boolean operations. Against state-of-the-art schemes, the authors report reductions of up to 79.06% in query time, 75.00% in communication overhead, 97.92% in storage overhead, and 80.26% in peak memory. These are maximum reported reductions; the excerpt gives no benchmark conditions or per-scheme results.

### Source excerpt

arXiv:2611.24248v1 Announce Type: new Abstract: Keyword Private Information Retrieval (Keyword PIR) allows users to retrieve data associated with specific keywords from a database while protecting query privacy. However, existing Keyword PIR schemes supporting boolean retrieval either incur high computational overhead due to multiple database traversals, or fail to support universal boolean computation. We propose PMKPIR, a novel keyword PIR scheme supporting both parallel multi-keyword queries and universal boolean computation. We utilize the single instruction multiple data (SIMD) capability of BFV homomorphic encryption to propose an interleaved batching method, and design IBPIR based on this method, achieving the private matching of multiple keywords in a single database traversal. Furthermore, we design a boolean query processing method, extending the parallel capability of interleaved batching from keyword querying to boolean query computation, to support universal boolean computation and accelerate boolean operations. Building upon IBPIR, we integrate this method to further design PMKPIR. To the best of our knowledge, PMKPIR is the first Keyword PIR scheme to support multi-keyword batch matching within boolean queries. Security analysis demonstrates that, consistent with existing PIR schemes supporting boolean retrieval, PMKPIR preserves the core security guarantees of classic PIR. Compared with state-of-the-art schemes, PMKPIR reduces query time, communication overhead, storage overhead, and peak memory by up to 79.06%, 75.00%, 97.92%, and 80.26%, respectively.

## C++ Optimizations in MSVC Build Tools 14.52

DevFeed: [C++ Optimizations in MSVC Build Tools 14.52](<https://devfeed.tech/articles/c-optimizations-in-msvc-build-tools-14-52-138345.md>)

Original publisher: [Read original article](<https://devblogs.microsoft.com/cppblog/c-optimizations-in-msvc-build-tools-14-52/>)

Author: Troy Johnson

Published: 2026-11-17T18:23:46Z

Content type: article

Language: en

Sources: [C++ Team Blog](<https://devfeed.tech/sources/c-team-blog.md>)

Topics: [MSVC](<https://devfeed.tech/topics/msvc.md>), [c/c++](<https://devfeed.tech/topics/c-c-plus-plus.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [Compilers and Linkers](<https://devfeed.tech/topics/compilers-and-linkers.md>), [inlining](<https://devfeed.tech/topics/inlining.md>)

Tags: [build-tools](<https://devfeed.tech/tags/build-tools.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [inlining](<https://devfeed.tech/tags/inlining.md>), [msvc](<https://devfeed.tech/tags/msvc.md>), [optimizations](<https://devfeed.tech/tags/optimizations.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [performance](<https://devfeed.tech/tags/performance.md>), [simd](<https://devfeed.tech/tags/simd.md>)

### AI overview

MSVC Build Tools 14.52 improves optimization across arithmetic reassociation, loops, ARM64 code generation, inlining, and expression patterns. Reassociation can expose shared calculations for hoisting and common-subexpression elimination; loop passes can replace repeated induction updates with final-value calculations and hoist eligible pure operations. ARM64 address analysis can share bases for indexed accesses and enable paired loads. SIMD changes include broader SLP recognition, NEON pattern simplification, and removal of work in unused lanes. Inlining heuristics now consider certain single-call helpers, slightly larger functions, and calls that enable scalar replacement of local aggregates. Pattern optimizations simplify Boolean expressions and equivalent comparisons or selections. Some changes originated in 14.51. The reciprocal-sharing transformation requires `/fp:fast` and is cost-based; floating-point reassociation also requires `/fp:fast`, and examples describe opportunities rather than guarantees.

### Source excerpt

C++ Optimizations in MSVC Build Tools 14.52 The Microsoft C++ team implemented new optimizations in MSVC Build Tools 14.52. Let's walk through examples of some of these optimizations. We will focus on reassociation, loop optimizations, SIMD code generation, inlining, and patterns. Where noted, we'll also include a few optimizations that appeared in MSVC 14.51 but [...] The post C++ Optimizations in MSVC Build Tools 14.52 appeared first on C++ Team Blog.

## Vectorised Hashing Based on Bernstein-Rabin-Winograd Polynomials over Prime Order Fields

DevFeed: [Vectorised Hashing Based on Bernstein-Rabin-Winograd Polynomials over Prime Order Fields](<https://devfeed.tech/articles/vectorised-hashing-based-on-bernstein-rabin-winograd-polynomials-over-prime-order-fields-139222.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2507.06490>)

Author: Kaushik Nath, Palash Sarkar

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [hashing](<https://devfeed.tech/topics/hashing.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [polynomials](<https://devfeed.tech/topics/polynomials.md>), [primes](<https://devfeed.tech/topics/primes.md>)

Tags: [assembly](<https://devfeed.tech/tags/assembly.md>), [avx2](<https://devfeed.tech/tags/avx2.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [faster](<https://devfeed.tech/tags/faster.md>), [fields](<https://devfeed.tech/tags/fields.md>), [hashing](<https://devfeed.tech/tags/hashing.md>), [polynomials](<https://devfeed.tech/tags/polynomials.md>), [prime](<https://devfeed.tech/tags/prime.md>), [simd](<https://devfeed.tech/tags/simd.md>), [speed](<https://devfeed.tech/tags/speed.md>)

### AI overview

decBRWHash is an AXU hash based on Bernstein-Rabin-Winograd polynomials; choosing parameter c greater than 1 enables c-way SIMD implementation. The authors report hand-optimized AVX2 assembly for 4-decBRWHash and, for comparison, polyHash over the prime fields 2^127−1 and 2^130−5. For 2^130−5, their AVX2 4-decBRWHash implementation is faster than Poly1305 on messages of a few hundred bytes, with reported speedups of about 16% for a few kilobytes and 23% for a few megabytes. These are reported implementation results for the stated field and AVX2 setting.

### Source excerpt

arXiv:2507.06490v3 Announce Type: replace Abstract: We introduce the new AXU hash function decBRWHash, which is parameterised by the positive integer $c$ and is based on Bernstein-Rabin-Winograd (BRW) polynomials. Choosing $c>1$ gives a hash function which can be implemented using $c$-way single instruction multiple data (SIMD) instructions. We report a set of very comprehensive hand optimised assembly implementations of 4-decBRWHash using avx2 SIMD instructions available on modern Intel processors. For comparison, we also report similar carefully optimised avx2 assembly implementations of polyHash, an AXU hash function based on usual polynomials. Our implementations are over prime order fields, specifically the primes $2^{127}-1$ and $2^{130}-5$. For the prime $2^{130}-5$, for avx2 implementations, compared to the famous Poly1305 hash function, 4-decBRWHash is faster for messages which are a few hundred bytes long and achieves a speed-up of about 16% for message lengths in a few kilobytes range and improves to a speed-up of about 23% for message lengths in a few megabytes range.

## TorchCurves: Differentiable Parametric Curves

DevFeed: [TorchCurves: Differentiable Parametric Curves](<https://devfeed.tech/articles/torchcurves-differentiable-parametric-curves-128854.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.14516>)

Author: Alex Shtoff

Published: 2026-11-11T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [PyTorch](<https://devfeed.tech/topics/pytorch.md>), [procedural curves](<https://devfeed.tech/topics/procedural-curves.md>), [Library](<https://devfeed.tech/topics/library.md>), [Neural Network](<https://devfeed.tech/topics/neural-network.md>), [Embeddings](<https://devfeed.tech/topics/embeddings.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [Maintainability](<https://devfeed.tech/topics/maintainability.md>), [SciPy](<https://devfeed.tech/topics/scipy.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [applications](<https://devfeed.tech/tags/applications.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [batches](<https://devfeed.tech/tags/batches.md>), [can](<https://devfeed.tech/tags/can.md>), [central](<https://devfeed.tech/tags/central.md>), [combines](<https://devfeed.tech/tags/combines.md>), [compare](<https://devfeed.tech/tags/compare.md>), [continuous](<https://devfeed.tech/tags/continuous.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [custom](<https://devfeed.tech/tags/custom.md>), [embeddings](<https://devfeed.tech/tags/embeddings.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [feature](<https://devfeed.tech/tags/feature.md>), [functional](<https://devfeed.tech/tags/functional.md>), [github](<https://devfeed.tech/tags/github.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [https](<https://devfeed.tech/tags/https.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [stat-ml](<https://devfeed.tech/tags/stat-ml.md>)

### AI overview

TorchCurves makes vector-valued parametric curves learnable in PyTorch: it maps batches of scalar inputs to curve points using B-spline or Legendre bases and differentiates through both inputs and coefficients. Coefficients can be optimized with a model or generated by another network. The library offers trainable and reusable basis modules plus a functional interface, with applications including continuous feature embeddings, Kolmogorov-Arnold networks, and functional regression. Its vectorized implementation uses classical evaluation algorithms without custom hardware kernels. Timing experiments compare evaluation with NumPy and SciPy, and KAN training with EfficientKAN; the abstract says these show both practical cases and substantial overhead, but gives no specific results.

### Source excerpt

arXiv:2611.14516v1 Announce Type: new Abstract: We present TorchCurves, a PyTorch library that treats vector-valued parametric curves as learnable primitives. Its central operation maps batches of scalar inputs to points on curves represented in B-spline or Legendre polynomial bases, with differentiation through both inputs and coefficients. Curve coefficients can be optimized jointly with the surrounding model or produced by another network. The library provides trainable modules, reusable basis modules, and a functional interface, supporting applications ranging from continuous feature embeddings to Kolmogorov-Arnold networks and functional regression. Its implementation combines classical evaluation algorithms with vectorized PyTorch operations, emphasizing readability and maintainability without custom hardware kernels. Timing experiments compare curve evaluation against NumPy and SciPy and KAN training against EfficientKAN across a range of problem sizes. The results illustrate where this generality remains computationally practical and where overhead is substantial. Library is available on GitHub at https://github.com/alexshtf/torchcurves.

## Representing Tensors as Compositions for Efficient Computation on Sparse and Structured Data

DevFeed: [Representing Tensors as Compositions for Efficient Computation on Sparse and Structured Data](<https://devfeed.tech/articles/representing-tensors-as-compositions-for-efficient-computation-on-sparse-and-structured-data-125265.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.10855>)

Author: Val\\'erian Rey, Praneth Paruchuri

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [ggml](<https://devfeed.tech/topics/ggml.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [activation](<https://devfeed.tech/tags/activation.md>), [activation-function](<https://devfeed.tech/tags/activation-function.md>), [algebra](<https://devfeed.tech/tags/algebra.md>), [all](<https://devfeed.tech/tags/all.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [based](<https://devfeed.tech/tags/based.md>), [can](<https://devfeed.tech/tags/can.md>), [combined](<https://devfeed.tech/tags/combined.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [composition](<https://devfeed.tech/tags/composition.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-ms](<https://devfeed.tech/tags/cs-ms.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [data](<https://devfeed.tech/tags/data.md>), [draft](<https://devfeed.tech/tags/draft.md>), [element](<https://devfeed.tech/tags/element.md>), [engine](<https://devfeed.tech/tags/engine.md>), [focus](<https://devfeed.tech/tags/focus.md>), [structured](<https://devfeed.tech/tags/structured.md>), [structured-data](<https://devfeed.tech/tags/structured-data.md>), [tensors](<https://devfeed.tech/tags/tensors.md>)

### AI overview

The paper proposes representing tensors as index-to-value functions and tensor operations as compositions: value functions handle element-wise operations, index functions handle re-indexing, and combined index and reduction functions handle reductions. With tensor stacking, this is intended to cover dense, jagged, sparse, and factorized tensors, plus lazy forms of operations such as einsum. Algebraic identities can rewrite computations without evaluating them; for example, the product of two sparse matrices can be rewritten to compute only products of nonzero values. The authors propose using this algebra as a computation engine's intermediate representation, shifting implementation work toward index-function algebra. They project codebase complexity changing from O(mn²) to O(m + k²), where m is the number of binary tensor operations, n the number of tensor types, and k the number of index-function types. The supplied abstract mentions a draft implementation but gives no performance evaluation.

### Source excerpt

arXiv:2611.10855v1 Announce Type: new Abstract: We propose a new mathematical formalism in which all kinds of tensors and of operations on those tensors are represented as simple function compositions. Tensors are functions from indices to values. An element-wise operation (e.g. an activation function) is a composition with a function applied to values; re-indexing (e.g. reshape, transposition) is a composition with a function applied to indices; and a reduction is a composition with both an index function, mapping each index to several indices, and a reduction operation (e.g. product, sum, max). Combined with tensor stacking, these compositions can represent most interesting kinds of tensors (e.g. dense, jagged, all kinds of sparsity patterns, matrix factorizations), as well as lazy versions of almost every operation available in modern tensor computation frameworks, including einsums between tensors of any kind. Identities between compositions can then be used to rewrite such expressions into equivalent ones, without evaluating them. For instance, the product of two sparse matrices can be rewritten so that only products between non-zero values are computed, turning a sparse problem into a dense one. Using this algebra as the intermediate representation of a tensor computation engine would shift the focus from defining operations on tensors (e.g. einsum between sparse tensors) to defining an algebra on index functions. This should reduce the codebase complexity from $\mathcal{O}(mn^2)$, with $m$ the number of binary operations between tensors and $n$ the number of tensor types, to $\mathcal{O}(m + k^2)$, with $k$ the number of types of index functions. A draft implementation of a tensor computation framework based on this algebra is publicly available.

## To SIMD or Not to SIMD: Comparing RVV vs. CGRA SoCs for Non-Linear Functions in AI

DevFeed: [To SIMD or Not to SIMD: Comparing RVV vs. CGRA SoCs for Non-Linear Functions in AI](<https://devfeed.tech/articles/to-simd-or-not-to-simd-comparing-rvv-vs-cgra-socs-for-non-linear-functions-in-ai-126279.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.12435>)

Author: Sameer Deshmukh, Naoya Mizuki, Takumi Honda

Published: 2026-11-10T05:00:00Z

Content type: news

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [Workstation Motherboards](<https://devfeed.tech/topics/workstation-motherboards.md>)

Tags: [activation](<https://devfeed.tech/tags/activation.md>), [ai](<https://devfeed.tech/tags/ai.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [complex](<https://devfeed.tech/tags/complex.md>), [computing](<https://devfeed.tech/tags/computing.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [fpgas](<https://devfeed.tech/tags/fpgas.md>), [high-performance](<https://devfeed.tech/tags/high-performance.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [latency](<https://devfeed.tech/tags/latency.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [mmu](<https://devfeed.tech/tags/mmu.md>), [networks](<https://devfeed.tech/tags/networks.md>), [operations](<https://devfeed.tech/tags/operations.md>), [performance](<https://devfeed.tech/tags/performance.md>), [processor](<https://devfeed.tech/tags/processor.md>), [vector](<https://devfeed.tech/tags/vector.md>)

### AI overview

The comparison finds that RVV and an elastic CGRA excel on different nonlinear functions when paired with an MMU: the CGRA reaches up to 7.12x the RVV's clock-cycle performance for activation stages of simple point-wise functions such as SiLU, while RVV reaches up to 9.8x the CGRA's for complex functions such as softmax. Across the enclosing feed-forward block, the respective maximum speedups are 3.16x and 4.24x. The findings come from proposed mappings on two single-core-CPU-driven SoCs; the excerpt does not establish a universal winner.

### Source excerpt

arXiv:2611.12435v1 Announce Type: cross Abstract: Non-linear functions are an important class of operations in modern large language models. However, chip vendors building for AI have so far relied on traditional vector or scalar processing units for non-linear functions. The performance of these units has not kept pace with matrix multiplication units (MMUs), which can be found in both high-performance and edge-computing devices from almost every vendor. Reconfigurable units such as FPGAs and CGRAs have been proposed in the literature, but have not been systematically compared with traditional units backed by MMUs. In this paper, we build two SoCs: one using an RVV vector processor and the other using a latency-insensitive (\emph{elastic}) CGRA, both coupled with an MMU and driven by a single-core CPU. We then propose mappings for common feed-forward networks on our SoCs and find that the CGRA reaches a maximum speedup in clock cycles of 7.12x over RVV on the activation stage of simple point-wise non-linear functions like SiLU, whereas the RVV reaches a maximum speedup of \textbf{9.8x} over the CGRA on complex non-linear functions such as $\mathrm{softmax}$. Over the enclosing feed-forward block the corresponding maxima are 3.16x and 4.24x.

## Close and Sort: Exact Maximum-Likelihood Aggregation of Cyclic Rank-Two Preferences

DevFeed: [Close and Sort: Exact Maximum-Likelihood Aggregation of Cyclic Rank-Two Preferences](<https://devfeed.tech/articles/close-and-sort-exact-maximum-likelihood-aggregation-of-cyclic-rank-two-preferences-125212.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.10538>)

Author: Kehan Liu, Zhaoyun Chen, Xianquan Yan

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [recommendation systems](<https://devfeed.tech/topics/recommendation-systems.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [after](<https://devfeed.tech/tags/after.md>), [aggregation](<https://devfeed.tech/tags/aggregation.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [angular](<https://devfeed.tech/tags/angular.md>), [area](<https://devfeed.tech/tags/area.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [best](<https://devfeed.tech/tags/best.md>), [certificate](<https://devfeed.tech/tags/certificate.md>), [comparison](<https://devfeed.tech/tags/comparison.md>), [contain](<https://devfeed.tech/tags/contain.md>), [cs-ds](<https://devfeed.tech/tags/cs-ds.md>), [cs-ir](<https://devfeed.tech/tags/cs-ir.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [delta](<https://devfeed.tech/tags/delta.md>), [edge](<https://devfeed.tech/tags/edge.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [gap](<https://devfeed.tech/tags/gap.md>), [general](<https://devfeed.tech/tags/general.md>), [gives](<https://devfeed.tech/tags/gives.md>), [rank](<https://devfeed.tech/tags/rank.md>), [sort](<https://devfeed.tech/tags/sort.md>), [stat-ml](<https://devfeed.tech/tags/stat-ml.md>)

### AI overview

For pairwise log-odds matrices of rank two, CloseSort finds a global maximum-likelihood ranking in O(n log n) time from supplied factors, even when preferences form cycles. The method represents log-odds as determinants, adds a closing vector, and converts the ranking objective to the signed area of a closed polygon; polar-sorting its edges yields the order. The geometry also identifies the runner-up: when the minimum determinant δ between consecutive edges is positive, it equals the best-to-runner-up log-likelihood gap. The abstract says the method provides a stability certificate for approximate rank two, but the supplied excerpt truncates the full regret bound. Reported evaluations include 44% lower normalized regret than Borda on profiles with directed majority triangles and an 8,407x speed advantage over exact dynamic programming for 18-item rankings when factors are supplied.

### Source excerpt

arXiv:2611.10538v1 Announce Type: cross Abstract: Pairwise probabilities arise in rank aggregation, recommendation, and human or LLM evaluation, yet converting them into a maximum-likelihood list is a weighted Kemeny problem and is NP-hard in general. Known exact algorithms for rank-two tournaments use only comparison signs and do not optimize this likelihood. We show that the weighted problem is exactly solvable when the skew-symmetric log-odds matrix $W_{ij}=\log(p_{ij}/p_{ji})$ has rank two, including when the induced preferences contain cycles. Writing $W_{ij}=\det(h_i,h_j)$ and adding the closing vector $h_0=-\sum_i h_i$ turns the objective into twice the signed area of a closed polygon. This geometry yields CloseSort, which polar-sorts the $n+1$ edge vectors, cuts after $h_0$, and returns a global maximum-likelihood order in $O(n\log n)$ time from the factors. The same geometry identifies the runner-up and gives a stability certificate beyond exact rank two. When the smallest determinant $\delta$ of two consecutive edges in the closed angular cycle is positive, it is exactly the best-to-runner-up log-likelihood gap. For $W=W_0+E$, the CloseSort order of $W_0$ has regret at most $\sum_{i

## Go Turns 17

DevFeed: [Go Turns 17](<https://devfeed.tech/articles/go-turns-17-129378.md>)

Original publisher: [Read original article](<https://go.dev/blog/17years>)

Author: Austin Clements, for the Go team

Published: 2026-11-10T00:00:00Z

Content type: article

Language: en

Sources: [Go](<https://devfeed.tech/sources/the-go-blog.md>)

Topics: [Go Language](<https://devfeed.tech/topics/go-language.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [Visual Studio Code](<https://devfeed.tech/topics/visual-studio-code.md>)

Tags: [17](<https://devfeed.tech/tags/17.md>), [agentic-systems](<https://devfeed.tech/tags/agentic-systems.md>), [ai-assisted-development](<https://devfeed.tech/tags/ai-assisted-development.md>), [ai-coding-assistants](<https://devfeed.tech/tags/ai-coding-assistants.md>), [anniversary](<https://devfeed.tech/tags/anniversary.md>), [api](<https://devfeed.tech/tags/api.md>), [certificate](<https://devfeed.tech/tags/certificate.md>), [go](<https://devfeed.tech/tags/go.md>)

### AI overview

Go's past-year releases emphasize keeping the language simple and compatible while improving production safety, performance, security, and tooling for developers and coding agents. Go 1.26 and 1.27 add more expressive generics and syntax, plus `encoding/json/v2` for stricter defaults and streaming; the legacy JSON package now uses v2 internally, enabling gradual migration and faster unmarshaling for existing callers. Go 1.27 also adds a goroutine leak profiler and background draining of small unread HTTP/1 response bodies. Runtime and compiler work includes the Green Tea garbage collector, experimental SIMD APIs, and faster small allocations. Security changes extend post-quantum cryptography and support rapid vulnerability response. For code maintenance, `go fix` modernizers and `//go:fix inline` automate upgrades, while `gopls` and the `pkg.go.dev` API provide refactoring and authoritative package data for humans and AI tools. The article also outlines future work, including Go 1.28 language and tooling changes, broader SIMD support, lower memory use, and increased community participation in project governance.

### Source excerpt

Happy Birthday, Go!

## Writing a DSL for high performance parallel programming in OxCaml

DevFeed: [Writing a DSL for high performance parallel programming in OxCaml](<https://devfeed.tech/articles/writing-a-dsl-for-high-performance-parallel-programming-in-oxcaml-132544.md>)

Original publisher: [Read original article](<https://blog.janestreet.com/writing-a-dsl-for-high-performance-parallel-programming-in-oxcaml/>)

Author: Nicholas Yang

Published: 2026-11-06T00:00:00Z

Content type: article

Language: en

Sources: [Jane Street](<https://devfeed.tech/sources/jane-street.md>)

Topics: [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [iteration](<https://devfeed.tech/topics/iteration.md>), [GPU](<https://devfeed.tech/topics/gpu.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [architectures](<https://devfeed.tech/tags/architectures.md>), [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [assembly](<https://devfeed.tech/tags/assembly.md>), [avx2](<https://devfeed.tech/tags/avx2.md>), [avx512](<https://devfeed.tech/tags/avx512.md>), [backend](<https://devfeed.tech/tags/backend.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [c](<https://devfeed.tech/tags/c.md>), [dsl](<https://devfeed.tech/tags/dsl.md>), [high-performance](<https://devfeed.tech/tags/high-performance.md>), [intern](<https://devfeed.tech/tags/intern.md>), [internship](<https://devfeed.tech/tags/internship.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [performance](<https://devfeed.tech/tags/performance.md>), [programming](<https://devfeed.tech/tags/programming.md>), [writing](<https://devfeed.tech/tags/writing.md>)

### AI overview

The OxCaml DSL lets developers describe the computation for one output index in an SPMD kernel; its compiler builds a graph and uses runtime metaprogramming to specialize and compile OxCaml code for the chosen metric and target architecture. Kernels write each output entry once, enabling parallel execution. The compiler distinguishes uniform and per-lane values, and offers `if_`, `if_var` and `select`; unlike `select`, which evaluates both branches, `if_var` can skip an untaken branch. An A-normal-form IR makes transformations such as hoisting loop-invariant loads and processing four elements per loop iteration easier to represent and optimize. The initial JIT was much faster than the interpreter, about as fast as or slightly slower than manual OxCaml, and significantly slower than C AVX2/AVX512. The IR backend initially performed about the same as that JIT. Preliminary vectorization and constant-hoisting work brought results on par with C AVX2; scheduling improvements were still in progress, and the excerpt reports no final results for them.

### Source excerpt

The following is part of a series of posts about 2026 summer intern projects--for more, see "What the interns have wrought, special jumbo 2026 edition"

## Turning Conv2D Into A Practical GPU Compute Pattern

DevFeed: [Turning Conv2D Into A Practical GPU Compute Pattern](<https://devfeed.tech/articles/turning-conv2d-into-a-practical-gpu-compute-pattern-118755.md>)

Original publisher: [Read original article](<https://semiengineering.com/turning-conv2d-into-a-practical-gpu-compute-pattern/>)

Author: Mario Florea

Published: 2026-11-05T08:05:35Z

Content type: article

Language: en

Sources: [Semiconductor Engineering](<https://devfeed.tech/sources/semiconductor-engineering.md>)

Topics: [kernels](<https://devfeed.tech/topics/kernels.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>)

Tags: [acceleration](<https://devfeed.tech/tags/acceleration.md>), [ai](<https://devfeed.tech/tags/ai.md>), [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [article](<https://devfeed.tech/tags/article.md>), [bandwidth](<https://devfeed.tech/tags/bandwidth.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [blogs-security](<https://devfeed.tech/tags/blogs-security.md>), [boundary](<https://devfeed.tech/tags/boundary.md>), [branch](<https://devfeed.tech/tags/branch.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [cache](<https://devfeed.tech/tags/cache.md>), [challenge](<https://devfeed.tech/tags/challenge.md>), [cnns](<https://devfeed.tech/tags/cnns.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [convolution](<https://devfeed.tech/tags/convolution.md>), [convolutional-neural-networks](<https://devfeed.tech/tags/convolutional-neural-networks.md>), [critical](<https://devfeed.tech/tags/critical.md>), [data-movement](<https://devfeed.tech/tags/data-movement.md>), [deep-learning](<https://devfeed.tech/tags/deep-learning.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [gpu-compute](<https://devfeed.tech/tags/gpu-compute.md>), [gpus](<https://devfeed.tech/tags/gpus.md>), [imagination-technologies](<https://devfeed.tech/tags/imagination-technologies.md>), [iot-and-security](<https://devfeed.tech/tags/iot-and-security.md>), [kernels](<https://devfeed.tech/tags/kernels.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [ml](<https://devfeed.tech/tags/ml.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [sharpening-your-edge](<https://devfeed.tech/tags/sharpening-your-edge.md>)

### AI overview

The excerpt presents Conv2D as structured matrix multiplication with accumulation across filter positions. With NHWC input, a 1x1 convolution maps each C_in feature vector to C_out directly, avoiding a transposition. Larger filters require repeated matrix-like contributions, so loop order matters: processing filter positions separately may refetch input through L1 or L2, while reordering can improve locality and cache reuse. The implementation also must handle padding, stride and dilation. Boundary checks are straightforward but can add cost in a hot loop; redirecting invalid reads to a zero-filled buffer moves that work into setup and may be worth testing. The guidance is to address data reuse and memory traffic before low-level instruction tuning, while recognizing that performance depends on execution and layout as well as the mathematics. The supplied text is an excerpt.

### Source excerpt

A reusable optimization mindset for engineers building GPU compute kernels. The post Turning Conv2D Into A Practical GPU Compute Pattern appeared first on Semiconductor Engineering.

## Easy Multi-Precision Acceleration via Vectorization

DevFeed: [Easy Multi-Precision Acceleration via Vectorization](<https://devfeed.tech/articles/easy-multi-precision-acceleration-via-vectorization-119096.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.05558>)

Author: Chansup Byun, Piotr Luszczek, Jeremy Kepner, LaToya Anderson, William Arcand, David Bestor, William Bergeron, Alex Bonn, Daniel Burrill, Vijay Gadepally, Michael Houle, Matthew Hubbell, Hayden Jananth

Published: 2026-11-05T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [floating-point](<https://devfeed.tech/topics/floating-point.md>)

Tags: [acceleration](<https://devfeed.tech/tags/acceleration.md>), [accelerators](<https://devfeed.tech/tags/accelerators.md>), [bandwidth](<https://devfeed.tech/tags/bandwidth.md>), [complex](<https://devfeed.tech/tags/complex.md>), [compute](<https://devfeed.tech/tags/compute.md>), [computing](<https://devfeed.tech/tags/computing.md>), [convolution](<https://devfeed.tech/tags/convolution.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-pf](<https://devfeed.tech/tags/cs-pf.md>), [fft](<https://devfeed.tech/tags/fft.md>), [half](<https://devfeed.tech/tags/half.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-bandwidth](<https://devfeed.tech/tags/memory-bandwidth.md>), [performance](<https://devfeed.tech/tags/performance.md>), [portable](<https://devfeed.tech/tags/portable.md>), [precision](<https://devfeed.tech/tags/precision.md>), [productivity](<https://devfeed.tech/tags/productivity.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>), [range](<https://devfeed.tech/tags/range.md>), [vectorization](<https://devfeed.tech/tags/vectorization.md>)

### AI overview

The paper evaluates simple vectorized coding that expresses operations as high-level matrix mathematics across hardware spanning nearly a decade. Its examples cover memory bandwidth, real and complex matrix multiplication in double, single, and half precision, and 2D convolution using the Fast Fourier Transform. The authors report that high-level programming environments can reach near-peak hardware performance for these workloads and suggest that algorithms trading lower compute intensity for higher memory intensity have significant potential. The supplied text does not specify particular languages, accelerators, or measured performance figures.

### Source excerpt

arXiv:2611.05558v1 Announce Type: cross Abstract: High level programming languages and accelerators are powerful enablers for a wide range of applications. Accelerators offer significant performance via diverse numeric precision and increased memory bandwidth and capacity. These enable new algorithms to be explored. Construction of these algorithms can be enabled by the ready accessibility of these performance features in high-level languages. Achieving scalable vertical (within a compute node), precision (over various numeric precisions), and temporal (over different generations of hardware) performance while retaining productivity requires effective abstractions. Vectorized coding that expresses operations as high-level matrix mathematics has historically been an important method for achieving portable performance. This paper examines the performance availability across a wide range of precisions and hardware using simple vectorized coding techniques applied to several example programs that highlight bandwidth, real and complex matrix multiplication, and 2D convolution. The systems evaluated span nearly a decade of computing hardware, enabling direct comparison of performance gains over this period. This work demonstrates that near hardware peak performance is readily accessible from high-level programming environments. In particular for memory bandwidth, real and complex matrix multiplication in double/single/half precision, and 2D convolutions using the Fast Fourier Transform (FFT). Furthermore, algorithms that trade decreased compute intensity for increased memory intensity have significant potential.

## GCC 17 Compiler Merges Support For AVX10V1AUX

DevFeed: [GCC 17 Compiler Merges Support For AVX10V1AUX](<https://devfeed.tech/articles/gcc-17-compiler-merges-support-for-avx10v1aux-113666.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/GCC-17-Merges-AVX10V1AUX>)

Author: Michael Larabel

Published: 2026-11-03T10:22:12Z

Content type: news

Language: en

Sources: [Phoronix](<https://devfeed.tech/sources/phoronix.md>)

Topics: [gcc](<https://devfeed.tech/topics/gcc.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>)

Tags: [ace](<https://devfeed.tech/tags/ace.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-compute](<https://devfeed.tech/tags/ai-compute.md>), [amd](<https://devfeed.tech/tags/amd.md>), [borrowing](<https://devfeed.tech/tags/borrowing.md>), [bridge](<https://devfeed.tech/tags/bridge.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [changes](<https://devfeed.tech/tags/changes.md>), [commit](<https://devfeed.tech/tags/commit.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compute](<https://devfeed.tech/tags/compute.md>), [cross](<https://devfeed.tech/tags/cross.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [engineers](<https://devfeed.tech/tags/engineers.md>), [exposed](<https://devfeed.tech/tags/exposed.md>), [extensions](<https://devfeed.tech/tags/extensions.md>), [gcc](<https://devfeed.tech/tags/gcc.md>), [git](<https://devfeed.tech/tags/git.md>), [initiative](<https://devfeed.tech/tags/initiative.md>), [intel](<https://devfeed.tech/tags/intel.md>), [linux-benchmarking](<https://devfeed.tech/tags/linux-benchmarking.md>), [linux-hardware-benchmarks](<https://devfeed.tech/tags/linux-hardware-benchmarks.md>), [linux-hardware-reviews](<https://devfeed.tech/tags/linux-hardware-reviews.md>), [linux-how-to](<https://devfeed.tech/tags/linux-how-to.md>), [linux-performance](<https://devfeed.tech/tags/linux-performance.md>), [linux-server-benchmarks](<https://devfeed.tech/tags/linux-server-benchmarks.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>), [updates](<https://devfeed.tech/tags/updates.md>)

### AI overview

GCC 17 has merged initial support for AVX10V1AUX, exposed through the -mavx10v1aux compiler switch. The excerpt says the extension adds native VNNI INT8 and INT16 support, instruction borrowing, and other incremental updates that bridge early AVX10 hardware and later AVX10.2 capabilities. It is not yet tied to specific Intel or AMD processor generations in GCC targeting.

### Source excerpt

Landing today into the GCC 17 compiler codebase is initial support for AVX10V1AUX as the auxillary updates to AVX10.1 that are out of the cross-vendor AI Compute Extensions "ACE" initiative between AMD and Intel...

## Investigating ET-SoC-1 Vector and Parallel Performance with sGEMM

DevFeed: [Investigating ET-SoC-1 Vector and Parallel Performance with sGEMM](<https://devfeed.tech/articles/investigating-et-soc-1-vector-and-parallel-performance-with-sgemm-113786.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.01045>)

Author: Richard Neale, Nick Brown

Published: 2026-11-03T05:00:00Z

Content type: comparison

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [Memory Heirarchy](<https://devfeed.tech/topics/memory-heirarchy.md>), [Intel Core](<https://devfeed.tech/topics/intel-core.md>)

Tags: [amd](<https://devfeed.tech/tags/amd.md>), [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [arm](<https://devfeed.tech/tags/arm.md>), [array](<https://devfeed.tech/tags/array.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [blackwell](<https://devfeed.tech/tags/blackwell.md>), [comparison](<https://devfeed.tech/tags/comparison.md>), [compute](<https://devfeed.tech/tags/compute.md>), [core](<https://devfeed.tech/tags/core.md>), [cortex](<https://devfeed.tech/tags/cortex.md>), [cortex-x925](<https://devfeed.tech/tags/cortex-x925.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [delivery](<https://devfeed.tech/tags/delivery.md>), [device](<https://devfeed.tech/tags/device.md>), [dgx](<https://devfeed.tech/tags/dgx.md>), [dgx-spark](<https://devfeed.tech/tags/dgx-spark.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [performance](<https://devfeed.tech/tags/performance.md>), [soc](<https://devfeed.tech/tags/soc.md>), [vector](<https://devfeed.tech/tags/vector.md>)

### AI overview

The paper investigates single-precision matrix multiplication on the ET-SoC-1, a 1024-core RISC-V accelerator with a shared eight-lane packed-single SIMD datapath per core. It compares a register-blocked SIMD kernel using two-step software pipelining with a TensorFMA32 kernel that uses the same FMA datapath through a per-core tensor micro-operation sequencer and double-buffered A-scratchpad loading. Since both kernels share the same arithmetic peak, the comparison is designed to isolate the effect of operand delivery rather than arithmetic width. The abstract says results are compared with several CPU references and two GPUs, but gives no performance outcomes.

### Source excerpt

arXiv:2611.01045v1 Announce Type: new Abstract: The Ainekko (formerly Esperanto) ET-SoC-1 is a massively parallel RISC-V accelerator. Its compute array comprises 1024 dual-threaded in-order ET-Minion cores (2048 harts) operating at 600 MHz, each core providing an eight-lane 256-bit packed-single (PS) SIMD datapath shared by its two harts, with access to LPDDR4X memory at a nominal 133 GiB/s. This paper presents a performance investigation using single-precision general matrix multiplication (sGEMM) as the benchmark kernel. Two device kernels are implemented and evaluated on the ET-SoC-1, these are a register-blocked PS SIMD baseline with two-step software pipelining, and a TensorFMA32 kernel that drives the same FMA datapath through the per-core tensor micro-operation sequencer, with double-buffered A scratchpad loading. Because both kernels are bounded by the same arithmetic peak, the comparison isolates the effect of operand delivery from that of arithmetic width. Performance is compared against CPU references (SpacemiT K3, Intel i5-11600, AMD Ryzen 9 9950X and the Arm Cortex-X925/A725 CPU of an NVIDIA DGX Spark) and two GPUs (NVIDIA GB10 Blackwell and AMD RDNA4 RX 9060 XT).

## Accelerating QUIC Encryption in WebAssembly Using WASM-SIMD

DevFeed: [Accelerating QUIC Encryption in WebAssembly Using WASM-SIMD](<https://devfeed.tech/articles/accelerating-quic-encryption-in-webassembly-using-wasm-simd-113868.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.01989>)

Author: Sota Yamawaki, Yasuo Okabe

Published: 2026-11-03T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>), [arXiv: Networking](<https://devfeed.tech/sources/arxiv-networking.md>)

Topics: [QUIC](<https://devfeed.tech/topics/quic.md>), [WebAssembly](<https://devfeed.tech/topics/web-assembly.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Encryption](<https://devfeed.tech/topics/encryption.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>)

Tags: [acceleration](<https://devfeed.tech/tags/acceleration.md>), [aes](<https://devfeed.tech/tags/aes.md>), [amdahl-s-law](<https://devfeed.tech/tags/amdahl-s-law.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [cryptography](<https://devfeed.tech/tags/cryptography.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-ni](<https://devfeed.tech/tags/cs-ni.md>), [edge](<https://devfeed.tech/tags/edge.md>), [encryption](<https://devfeed.tech/tags/encryption.md>), [gigabit-ethernet](<https://devfeed.tech/tags/gigabit-ethernet.md>), [limits](<https://devfeed.tech/tags/limits.md>), [memory](<https://devfeed.tech/tags/memory.md>), [native](<https://devfeed.tech/tags/native.md>), [network](<https://devfeed.tech/tags/network.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [quic](<https://devfeed.tech/tags/quic.md>), [simd](<https://devfeed.tech/tags/simd.md>), [wasm](<https://devfeed.tech/tags/wasm.md>), [webassembly](<https://devfeed.tech/tags/webassembly.md>)

### AI overview

Explicit WASM-SIMD kernels substantially improve QUIC encryption performance in WebAssembly, but shift the main limits to other parts of the stack. On two hosts connected by 10-Gigabit Ethernet, kernels processing eight AES blocks or four ChaCha20 blocks per pass increased receiver goodput over a non-SIMD baseline by 61.34% for AES-128-GCM and 31.55% for ChaCha20-Poly1305; compiler auto-vectorization improved AES-128-GCM by only 1.28%. ChaCha20-Poly1305 achieved 1.99 times the goodput of AES-128-GCM. Profiling and Amdahl's law suggest that even native-speed cryptography would leave the Wasm stack at roughly one third the goodput of the fastest native stack. Memory allocation, runtime overhead, and per-datagram UDP I/O remain constraints, so cryptographic acceleration alone is insufficient.

### Source excerpt

arXiv:2611.01989v1 Announce Type: cross Abstract: WebAssembly (Wasm) runs untrusted code in a portable, lightweight sandbox and is increasingly used to host services on shared servers and edge platforms. Running the QUIC transport protocol inside Wasm would let each application choose and update its own transport without changing the host. QUIC, however, encrypts every packet, and Wasm offers neither dedicated AES instructions nor carry-less multiplication; a Wasm QUIC stack has been reported to reach only 17.6% of native goodput, with cryptography as its largest cost. Whether the 128-bit SIMD extension of Wasm (WASM-SIMD) can recover this cost, and what limits a pure-Wasm stack once it does, has remained unclear. Here we show that explicit WASM-SIMD kernels recover much of the cryptographic cost, after which non-cryptographic costs become the limit. On two hosts connected by 10-Gigabit Ethernet, kernels that process eight AES blocks or four ChaCha20 blocks per pass raise receiver goodput over a non-SIMD baseline by 61.34% for AES-128-GCM and 31.55% for ChaCha20-Poly1305, whereas compiler auto-vectorization gains only 1.28% for AES-128-GCM. ChaCha20-Poly1305 still delivers 1.99 times the goodput of AES-128-GCM, confirming end to end the preference that stand-alone cipher benchmarks suggest. Receiver-side profiling combined with Amdahl's law predicts that even native-speed cryptography would leave Wasm at roughly one third of the goodput of the fastest native stack. Cryptographic acceleration is therefore necessary but not sufficient: memory allocation, runtime overhead and per-datagram UDP I/O now bound pure-Wasm transports. We anticipate that this per-category cost breakdown will guide further optimization of Wasm network stacks and the design of system interfaces for batched I/O.

## 10 Billion-Dollar Startup Ideas Generated by Gemini 4 Argon

DevFeed: [10 Billion-Dollar Startup Ideas Generated by Gemini 4 Argon](<https://devfeed.tech/articles/10-billion-dollar-startup-ideas-generated-by-gemini-4-argon-113684.md>)

Original publisher: [Read original article](<https://hackernoon.com/10-billion-dollar-startup-ideas-generated-by-gemini-4-argon?source=rss>)

Author: Thomas Cherickal

Published: 2026-11-03T04:45:28Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [AI Integration Strategies](<https://devfeed.tech/topics/ai-integration-strategies.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [AI Sandbox](<https://devfeed.tech/topics/ai-sandbox.md>), [3D](<https://devfeed.tech/topics/3d.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [OpenTelemetry](<https://devfeed.tech/topics/opentelemetry.md>), [Tree-sitter](<https://devfeed.tech/topics/tree-sitter.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>)

Tags: [ai-sre-agent](<https://devfeed.tech/tags/ai-sre-agent.md>), [argon](<https://devfeed.tech/tags/argon.md>), [autonomous-loops](<https://devfeed.tech/tags/autonomous-loops.md>), [billion-dollar-startups](<https://devfeed.tech/tags/billion-dollar-startups.md>), [cybersecurity](<https://devfeed.tech/tags/cybersecurity.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [gemini-4-argon](<https://devfeed.tech/tags/gemini-4-argon.md>), [ideas](<https://devfeed.tech/tags/ideas.md>), [legacy-monolith-migration](<https://devfeed.tech/tags/legacy-monolith-migration.md>), [products](<https://devfeed.tech/tags/products.md>), [real-product-ideas](<https://devfeed.tech/tags/real-product-ideas.md>), [startup](<https://devfeed.tech/tags/startup.md>), [ten-startup-ideas](<https://devfeed.tech/tags/ten-startup-ideas.md>)

### AI overview

The article proposes ten enterprise software products built around Gemini 4 Argon's claimed long output, cached context, multimodal input, and software reasoning capabilities: vulnerability patching, legacy code migration, M&A diligence, tax credit analysis, robot programming from video, medical claim appeals, CAD and BOM generation, compliance automation, incident response, and patent analysis. For each, it sketches a customer problem, a technical workflow, and a revenue model. Its common design principle is to pair the model with deterministic checks such as compilers, sandboxes, financial scripts, or simulation tools, then deliver a verified artifact that fits an existing workflow. The author presents these as product concepts and gives illustrative pricing and revenue projections; the text does not provide validation that the products, performance claims, or projections have been independently tested.

### Source excerpt

I asked Gemini 4 Argon for 10 Billion-Dollar Products that I could build with it. It Blew My Mind, the products are insane and solve huge problems!

## Falcons: Pushing the Speed-Ratio Limits of Lossy Compression for Parallel Scientific Applications

DevFeed: [Falcons: Pushing the Speed-Ratio Limits of Lossy Compression for Parallel Scientific Applications](<https://devfeed.tech/articles/falcons-pushing-the-speed-ratio-limits-of-lossy-compression-for-parallel-scientific-applications-111751.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.41209>)

Author: Bing Lu, Jinyang Liu, Xinyang Ma, Quantong Fu, Chenwei Hou, Zedong Liu, Wenjing Huang, Yida Gu, Xingchen Liu, Zheng Wei, Anbang Wu, Xiaofeng Hou, Chao Li, Guangming Tan, Minyi Guo, Dingwen Tao

Published: 2026-11-02T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Compression](<https://devfeed.tech/topics/compression.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [Supercomputing](<https://devfeed.tech/topics/supercomputing.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [compression](<https://devfeed.tech/tags/compression.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [evaluations](<https://devfeed.tech/tags/evaluations.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [remote](<https://devfeed.tech/tags/remote.md>), [research](<https://devfeed.tech/tags/research.md>), [simd](<https://devfeed.tech/tags/simd.md>), [supercomputers](<https://devfeed.tech/tags/supercomputers.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [weather](<https://devfeed.tech/tags/weather.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

Falcons is an error-bounded lossy compressor designed to reduce the runtime overhead of compression in parallel scientific applications while retaining high compression ratios. It combines memory-regularized interpolation with SIMD vectorization, distribution-adaptive lossless coding, and optimizations for multiple parallelization schemes. The abstract reports up to 29% better compression ratios and 255% higher throughput than state-of-the-art compressors in evaluations on supercomputers. In application case studies, it improved parallel data I/O by up to 44.6%, remote transfer by up to 51.5%, and end-to-end performance of the full WRF workflow by 1.55x. These are reported maxima; the excerpt does not provide evaluation details or conditions.

### Source excerpt

arXiv:2610.41209v1 Announce Type: new Abstract: The extreme volume of scientific data has become a critical challenge for modern exa-scale scientific computing applications, and error-bounded lossy compression remains indispensable for scientific data management due to its high data reduction rate and controllable data fidelity. However, to ensure sufficient data reduction, existing compressors incur prohibitive computational overheads in real-world parallel scientific computing applications. To overcome the performance bottlenecks of error-bounded lossy compression, we present \textbf{Falcons}, a broadly deployable error-bounded lossy compressor that simultaneously achieves \textbf{high compression ratios with ultra-fast throughput, minimizing the overhead in parallel scientific applications}. Falcons integrates three key designs: memory-regularized interpolation with SIMD (Single Instruction Multiple Data) vectorization, distribution-adaptive lossless coding, and application-oriented optimizations for multiple parallelization schemes. Across our evaluations on cutting-edge supercomputers, Falcons clearly outperforms state-of-the-art compressors, simultaneously achieving up to 29\% compression ratio improvement and 255\% throughput improvement. In case studies of real-world applications, Falcons accelerates large-scale parallel data I/O and remote transfer by up to 44.6\% and 51.5\%, and provides 1.55$\times$ end-to-end speedup for the full WRF (Weather Research \& Forecasting) application workflow.

## SIMD-accelerated machine vision on an ESP32-S3

DevFeed: [SIMD-accelerated machine vision on an ESP32-S3](<https://devfeed.tech/articles/simd-accelerated-machine-vision-on-an-esp32-s3-104536.md>)

Original publisher: [Read original article](<https://blog.adafruit.com/2026/10/28/simd-accelerated-machine-vision-on-an-esp32-s3/>)

Author: Anne Barela

Published: 2026-10-28T14:10:01Z

Content type: article

Language: en

Sources: [Adafruit Industries](<https://devfeed.tech/sources/adafruit-industries-makers-hackers-artists-designers-and-engineers.md>)

Topics: [ESP32-S3](<https://devfeed.tech/topics/esp32-s3.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [image recognition](<https://devfeed.tech/topics/image-recognition.md>)

Tags: [accelerated](<https://devfeed.tech/tags/accelerated.md>), [cameras](<https://devfeed.tech/tags/cameras.md>), [esp32](<https://devfeed.tech/tags/esp32.md>), [esp32-s3](<https://devfeed.tech/tags/esp32-s3.md>), [espressif](<https://devfeed.tech/tags/espressif.md>), [fast](<https://devfeed.tech/tags/fast.md>), [machine-vision](<https://devfeed.tech/tags/machine-vision.md>), [simd](<https://devfeed.tech/tags/simd.md>), [video](<https://devfeed.tech/tags/video.md>)

### AI overview

shranav's ESP32-S3 FAST detector uses the chip's 128-bit SIMD instructions to raise throughput from 5.1 to 11.2 MP/s--about twice the reference speed, with a QVGA frame taking roughly 6 ms. The implementation works around missing misaligned reads by extracting pixel slices from concatenated registers. Because comparisons use signed 8-bit values and arithmetic saturates, it XORs values with 0x80 to flip the top bit rather than subtracting 128. The reported throughput is enough for a 30 fps VGA stream. The excerpt also notes that shranav wrote basm, a basic register allocator.

### Source excerpt

shranav wrote an accelerated FAST feature detector for the ESP32-S3 that uses the chip's 128-bit SIMD instructions, and posted the writeup on shraiwi.com. It runs about twice as fast as the reference implementation and processes a QVGA 320x240 frame in roughly 6ms. The ESP32-S3 supports a small set of SIMD instructions that are documented but [...]

## SIMD-accelerated Machine Vision on an ESP32-S3

DevFeed: [SIMD-accelerated Machine Vision on an ESP32-S3](<https://devfeed.tech/articles/simd-accelerated-machine-vision-on-an-esp32-s3-101998.md>)

Original publisher: [Read original article](<https://hackaday.com/2026/10/27/simd-accelerated-machine-vision-on-an-esp32-s3/>)

Author: Maya Posch

Published: 2026-10-27T11:00:12Z

Content type: article

Language: en

Sources: [Hackaday](<https://devfeed.tech/sources/hackaday.md>)

Topics: [ESP32-S3](<https://devfeed.tech/topics/esp32-s3.md>), [Computer vision](<https://devfeed.tech/topics/computer-vision.md>), [Assembly](<https://devfeed.tech/topics/assembly.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [image recognition](<https://devfeed.tech/topics/image-recognition.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>)

Tags: [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [esp32-s3](<https://devfeed.tech/tags/esp32-s3.md>), [machine-vision](<https://devfeed.tech/tags/machine-vision.md>), [microcontrollers](<https://devfeed.tech/tags/microcontrollers.md>), [simd](<https://devfeed.tech/tags/simd.md>)

### AI overview

An ESP32-S3 running at 240 MHz processed VGA video with the FAST corner-detection algorithm in real time at 30 FPS, about twice the speed of a naive non-SIMD implementation. The implementation uses the MCU's Xtensa LX7 SIMD assembly, working around missing unsigned-byte comparisons and direct misaligned reads through custom coding. The excerpt says the PlatformIO project is available on GitHub.

### Source excerpt

Recently [shraiwi] decided to have a bit of good nerdy fun and implement the FAST machine vision algorithm on an ESP32-S3 using its SIMD ISA. This involves using the assembly ...read more

## NumPy Tutorial: Your First Steps Into Data Science in Python

DevFeed: [NumPy Tutorial: Your First Steps Into Data Science in Python](<https://devfeed.tech/articles/numpy-tutorial-your-first-steps-into-data-science-in-python-97820.md>)

Original publisher: [Read original article](<https://realpython.com/numpy-tutorial/>)

Author: Ryan Palo

Published: 2026-10-23T14:00:00Z

Content type: tutorial

Language: en

Sources: [Real Python](<https://devfeed.tech/sources/real-python.md>)

Topics: [Data Science](<https://devfeed.tech/topics/data-science.md>), [Python](<https://devfeed.tech/topics/python.md>), [Tutorial](<https://devfeed.tech/topics/tutorial.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [pandas](<https://devfeed.tech/topics/pandas.md>), [scikit-learn](<https://devfeed.tech/topics/scikit-learn.md>), [IPython](<https://devfeed.tech/topics/ipython.md>), [Image](<https://devfeed.tech/topics/image.md>), [Tool](<https://devfeed.tech/topics/tool.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [2019](<https://devfeed.tech/tags/2019.md>), [22](<https://devfeed.tech/tags/22.md>), [3](<https://devfeed.tech/tags/3.md>), [64-bit](<https://devfeed.tech/tags/64-bit.md>), [about](<https://devfeed.tech/tags/about.md>), [arrays](<https://devfeed.tech/tags/arrays.md>), [data](<https://devfeed.tech/tags/data.md>), [data-science](<https://devfeed.tech/tags/data-science.md>), [first](<https://devfeed.tech/tags/first.md>), [follow](<https://devfeed.tech/tags/follow.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [learn](<https://devfeed.tech/tags/learn.md>), [manipulate](<https://devfeed.tech/tags/manipulate.md>), [numpy](<https://devfeed.tech/tags/numpy.md>), [python](<https://devfeed.tech/tags/python.md>), [science](<https://devfeed.tech/tags/science.md>), [take](<https://devfeed.tech/tags/take.md>), [this](<https://devfeed.tech/tags/this.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

NumPy arrays let Python data science code apply calculations across whole datasets, often with fewer loops and code that more closely resembles the underlying math. The tutorial walks through array creation and shape, axes and broadcasting, then indexing, Boolean masks, sorting, aggregation, and structured arrays. Examples include curving grades with vectorized arithmetic and clipping, filtering values with masks, and approximating e^x with a Maclaurin series; it notes that `np.vectorize()` improves readability for factorials but does not provide a performance benefit. It also shows using NumPy with Matplotlib to manipulate RGB image arrays and create grayscale images. Readers should know basic Python; the setup guidance presents conda for new data science environments and pip or uv for existing workflows, with IPython and notebook tools as optional aids. The text highlights fixed array data types and the risk of truncating strings when assigning values longer than an array's capacity.

### Source excerpt

Follow this NumPy tutorial to learn how to create and manipulate arrays in Python and take your first steps into data science.

## Reorienting the Vector Axis: Restructuring FlashAttention for Long-Vector Processors

DevFeed: [Reorienting the Vector Axis: Restructuring FlashAttention for Long-Vector Processors](<https://devfeed.tech/articles/reorienting-the-vector-axis-restructuring-flashattention-for-long-vector-processors-95164.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.29489>)

Author: Emmanuel Irabor, Marc Casas

Published: 2026-10-22T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [RISC-V](<https://devfeed.tech/topics/riscv.md>)

Tags: [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-ar](<https://devfeed.tech/tags/cs-ar.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-pf](<https://devfeed.tech/tags/cs-pf.md>), [flashattention](<https://devfeed.tech/tags/flashattention.md>), [floating-point](<https://devfeed.tech/tags/floating-point.md>), [fpga](<https://devfeed.tech/tags/fpga.md>), [gpus](<https://devfeed.tech/tags/gpus.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [memory](<https://devfeed.tech/tags/memory.md>), [processors](<https://devfeed.tech/tags/processors.md>), [pytorch](<https://devfeed.tech/tags/pytorch.md>), [risc-v](<https://devfeed.tech/tags/risc-v.md>), [tiling](<https://devfeed.tech/tags/tiling.md>), [vector](<https://devfeed.tech/tags/vector.md>), [vectorize](<https://devfeed.tech/tags/vectorize.md>)

### AI overview

Porting PyTorch's CPU FlashAttention kernel to a RISC-V long-vector CPU achieved 16.2% of peak floating-point throughput. The authors attribute bottlenecks to per-row softmax reductions and exponential-polynomial coefficients that spill from vector registers. They transpose the score tile and running output so queries occupy the contiguous axis, making tile query count control vector length and eliminating both reductions. They also place polynomial coefficients in scalar registers, removing spills and reducing softmax vector memory instructions by 78.7%. Together, the changes cut kernel cycles by 1.84-2.08x at head dimension 64 and raise utilization to 29.7% of peak on silicon; an FPGA of the same design reports a 2.71x speedup.

### Source excerpt

arXiv:2610.29489v1 Announce Type: cross Abstract: A Transformer is built around attention, whose cost grows with the square of the sequence length and dominates the layer on long sequences. FlashAttention made that cost manageable by tiling the attention matrix and updating the softmax as it goes, but almost all work since has targeted GPUs. On long-vector processors one vector register can hold up to 512 single-precision numbers. The savings of a vector instruction are proportional to how much of the register it uses, so the choice of which loop to vectorize is a first-order decision. We port PyTorch's CPU FlashAttention kernel to a RISC-V CPU with 2KB vector registers and find that it reaches 16.2% of peak floating-point throughput. The kernel walks each tile one query row at a time: the product against V is vectorized along the 64-element head dimension, the softmax's per-row maximum and sum are reductions that collapse a full register to a scalar, and the software exponential's polynomial coefficients compete with tile data for vector registers and cause spilling. We propose two techniques. The first transposes the score tile and the running output so that queries lie along the contiguous axis. The algorithm and its values are unchanged. A single parameter, the number of queries in a tile, now sets the vector length of every part of the kernel and can be matched to the machine. Both reductions also disappear. The second moves the polynomial's coefficients into scalar registers, removing the spills and cutting the softmax's vector memory instructions by 78.7%. On silicon the two together cut whole-kernel cycles by 1.84 to 2.08x at a head dimension of 64, raising floating-point utilization from 16.2% to 29.7% of peak. An FPGA of the same design ranks the changes identically and scores them higher, at 2.71x.

## Federated Community Detection in Bipartite Networks

DevFeed: [Federated Community Detection in Bipartite Networks](<https://devfeed.tech/articles/federated-community-detection-in-bipartite-networks-93582.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.25997>)

Author: Wanjie Wang

Published: 2026-10-21T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [clustering](<https://devfeed.tech/topics/clustering.md>), [iteration](<https://devfeed.tech/topics/iteration.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>)

Tags: [clustering](<https://devfeed.tech/tags/clustering.md>), [communities](<https://devfeed.tech/tags/communities.md>), [community-detection](<https://devfeed.tech/tags/community-detection.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [federated](<https://devfeed.tech/tags/federated.md>), [networks](<https://devfeed.tech/tags/networks.md>), [stat-co](<https://devfeed.tech/tags/stat-co.md>), [stat-me](<https://devfeed.tech/tags/stat-me.md>), [stat-ml](<https://devfeed.tech/tags/stat-ml.md>)

### AI overview

FLICKER estimates a specified singular direction in horizontally partitioned data using local matrix-vector products, so servers need not share raw data; target directions can be computed in parallel. Its extension, BiFLICKER, supports community detection in bipartite networks, while Sequential BiFLICKER handles nearby or repeated singular directions. The abstract reports non-asymptotic convergence guarantees and, under a sparse bipartite stochastic block model, vanishing misclustering and exact recovery under stronger sparsity conditions. Simulations find BiFLICKER close to centralized spectral clustering and more robust than federated baselines when local samples are small. On a country-partitioned LastFM user-artist network, Sequential BiFLICKER achieves ARI 0.94 against centralized clustering. These results are reported in the abstract; it does not provide implementation details.

### Source excerpt

arXiv:2610.25997v1 Announce Type: cross Abstract: We study federated spectral estimation when a large matrix is horizontally partitioned across servers that cannot share raw data. We propose FLICKER, a target-specific gradient-based power iteration that recovers a singular direction associated with a prescribed spectral target using only matrix-vector products on local blocks. Different target directions can be recovered independently and in parallel. We establish non-asymptotic convergence guarantees and provide a recursive grid-search procedure for spectral target selection. Building on FLICKER, we develop BiFLICKER for federated community detection in bipartite networks, together with a sequential projected variant for nearby or repeated singular directions. Under a sparse bipartite stochastic block model, we show that properly rescaled leading singular values from a reference server provide valid global targets, and that Sequential BiFLICKER achieves a vanishing misclustering rate and exact recovery under stronger sparsity conditions. Simulations show that BiFLICKER remains close to centralized spectral clustering and is more robust than existing federated spectral baselines when local sample sizes are small. On a LastFM user-artist network naturally partitioned by country, Sequential BiFLICKER attains an overall ARI of 0.94 against centralized clustering while revealing cross-country communities with distinct listening profiles.

## Multifidelity Monte Carlo Estimator for High-Dimensional Quantities of Interest

DevFeed: [Multifidelity Monte Carlo Estimator for High-Dimensional Quantities of Interest](<https://devfeed.tech/articles/multifidelity-monte-carlo-estimator-for-high-dimensional-quantities-of-interest-93405.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.25016>)

Author: Zhibo Dai, Hamdi A. Tchelepi, Daniel M. Tartakovsky

Published: 2026-10-21T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Data science and engineering](<https://devfeed.tech/topics/data-science-and-engineering.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>)

Tags: [block](<https://devfeed.tech/tags/block.md>), [control](<https://devfeed.tech/tags/control.md>), [cost](<https://devfeed.tech/tags/cost.md>), [covariance](<https://devfeed.tech/tags/covariance.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [diffusion](<https://devfeed.tech/tags/diffusion.md>), [estimator](<https://devfeed.tech/tags/estimator.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [flow](<https://devfeed.tech/tags/flow.md>), [gaussian](<https://devfeed.tech/tags/gaussian.md>), [hierarchy](<https://devfeed.tech/tags/hierarchy.md>), [monte-carlo](<https://devfeed.tech/tags/monte-carlo.md>), [pilot](<https://devfeed.tech/tags/pilot.md>), [variance](<https://devfeed.tech/tags/variance.md>), [vector](<https://devfeed.tech/tags/vector.md>)

### AI overview

The paper extends multifidelity Monte Carlo (MFMC) to vector-valued quantities of interest by using matrix control-variate coefficients and minimizing weighted mean-squared error. Full-matrix coefficients have a closed-form solution, with variance reduction described by an effective correlation. Block-diagonal, diagonal, and scalar coefficient restrictions form a hierarchy: more flexible classes can reduce variance further but require more pilot data. For a scalar quantity formed by linearly projecting a state, correcting the full state before projection is never worse at the population level. Experiments on Gaussian, advection-diffusion, and two-phase flow problems find that the best coefficient class depends on pilot size relative to the covariance quantities it must estimate; reusing pilot samples lowers mean-squared error.

### Source excerpt

arXiv:2610.25016v1 Announce Type: new Abstract: Multifidelity Monte Carlo (MFMC) reduces the cost of estimating the statistics of quantities of interest (QoIs) computed via expensive high-fidelity model by using cheaper low-fidelity models as control variates. We extend MFMC to vector-valued QoIs by replacing the scalar control-variate coefficients with matrices and minimizing a weighted mean-squared error. The optimal full-matrix coefficients are available in closed form, and their variance reduction is summarized by an effective correlation that takes the place of the squared Pearson correlation in the closed-form MFMC design. Restricting the coefficients to block-diagonal, diagonal, and scalar classes gives a nested hierarchy of estimators with increasing variance reduction and increasing pilot-data demand, with closed-form coefficients for compatible weightings. For a scalar QoI obtained by linearly projecting the state, correcting the full state before projecting is never worse at the population level. Experiments on a Gaussian problem, a reduced-order model of an advection--diffusion problem, and a coarse-grid two-phase flow problem show that the best class depends on the pilot size relative to the number of covariance quantities it must estimate, and that reusing the pilot samples lowers the mean-squared error.

## CAFS: A Cache-Aware Frequency Sort for Low-Cardinality Integer Data on x86-64

DevFeed: [CAFS: A Cache-Aware Frequency Sort for Low-Cardinality Integer Data on x86-64](<https://devfeed.tech/articles/cafs-a-cache-aware-frequency-sort-for-low-cardinality-integer-data-on-x86-64-93870.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2605.25040>)

Author: Vasiliy S. Shlyk

Published: 2026-10-21T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>)

Topics: [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [Cache](<https://devfeed.tech/topics/cache.md>), [CPU Cache](<https://devfeed.tech/topics/cpu-cache.md>), [x86](<https://devfeed.tech/topics/x86.md>), [olap](<https://devfeed.tech/topics/olap.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [array](<https://devfeed.tech/tags/array.md>), [avx2](<https://devfeed.tech/tags/avx2.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cardinality](<https://devfeed.tech/tags/cardinality.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [cs-ds](<https://devfeed.tech/tags/cs-ds.md>), [olap](<https://devfeed.tech/tags/olap.md>), [open-addressing](<https://devfeed.tech/tags/open-addressing.md>), [operational](<https://devfeed.tech/tags/operational.md>), [pdqsort](<https://devfeed.tech/tags/pdqsort.md>), [radix-sort](<https://devfeed.tech/tags/radix-sort.md>), [simd](<https://devfeed.tech/tags/simd.md>), [ska-sort](<https://devfeed.tech/tags/ska-sort.md>), [sort](<https://devfeed.tech/tags/sort.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [x86-64](<https://devfeed.tech/tags/x86-64.md>)

### AI overview

CAFS targets integer arrays with many values but low cardinality, common in OLAP workloads. On x86-64 with AVX2, it combines a cache-line-sized SIMD bucket, a Chao1 estimator using 1,024 strided samples, and an adaptive dispatcher with a spill safety guard; its branchless hot loop uses cmpeq, movemask, and tzcnt. Across 592,770 benchmark runs, CAFS reached 1.7-3.1x pdqsort, 1.7-3.5x IPS4o, and 1.2-2.3x vqsort throughput when K was much smaller than N. The reported crossover is about K=130,000 for pdqsort and 670,000 for vqsort; only vqsort overtook CAFS beyond its crossover, making that threshold the stated limit of CAFS's operational range. The evidence is an abstract-level summary of benchmarks, not full paper coverage.

### Source excerpt

arXiv:2605.25040v2 Announce Type: replace-cross Abstract: Integer sorts in OLAP engines often run on columns whose cardinality $K$ is much smaller than the array length $N$. After a group-by stage the intermediate key column has $K$ bounded by the number of distinct group keys, and even a column-store scan typically operates on dictionary-encoded categorical fields where $K$ never exceeds a few thousand. A comparison sort on such a column still pays $\Theta(N \log N)$ comparisons, and a radix sort still pays $\Theta(N \cdot B/b)$ byte passes, irrespective of $K$. This paper describes CAFS, an integer sort that does exploit it on x86-64 with AVX2. The algorithm combines a SIMD bucket sized to one cache line, a Chao1 cardinality estimator over 1024 strided samples (kept in a heap-allocated 40 KB open-addressing table), and an adaptive dispatcher backed by a spill safety guard. The hot loop is branchless and uses AVX2 cmpeq together with movemask and tzcnt to locate the matching lane. We benchmarked CAFS on a full-factorial grid of 58 array sizes $N$ from $10^3$ to $3 \cdot 10^7$ with dense $K$ schedules per $N$, producing 592770 timed runs against pdqsort, IPS4o, vqsort, ska_sort, and std::sort. In the $K \ll N$ band the throughput is 1.7 to 3.1x that of pdqsort, 1.7 to 3.5x IPS4o, and 1.2 to 2.3x vqsort. The operational crossover against pdqsort is at $K \approx 1.3 \cdot 10^5$; against ska_sort, $K \approx 8.14 \cdot 10^5$; against vqsort, $K \approx 6.7 \cdot 10^5$; and against IPS4o the curves only converge near $K = N$. Of the five baselines, only vqsort actually overtakes CAFS once the crossover is passed, which makes the vqsort threshold at $K \approx 6.7 \cdot 10^5$ the binding constraint on the operational range of CAFS.

[Next page](<https://devfeed.tech/topics/vectorization-techniques.md?cursor=WyIyMDI2LTEwLTIxVDA0OjAwOjAwKzAwOjAwIiwgIjgyMTc3OWRlLTMyZTAtNDI3ZS04ZjVkLWNjMWI3YmFkZDRhMyJd>)