# I/O

Published articles for I/O.

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

## Linux Seeing Driver Work For MSI Mystic Light On Latest Ryzen Motherboards

DevFeed: [Linux Seeing Driver Work For MSI Mystic Light On Latest Ryzen Motherboards](<https://devfeed.tech/articles/linux-seeing-driver-work-for-msi-mystic-light-on-latest-ryzen-motherboards-123498.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/MSI-Mystic-Light-Linux>)

Author: Michael Larabel

Published: 2026-11-09T11:20:49Z

Content type: news

Language: en

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

Topics: [Linux Kernel](<https://devfeed.tech/topics/linux-kernel.md>), [Linux](<https://devfeed.tech/topics/linux.md>)

Tags: [chip](<https://devfeed.tech/tags/chip.md>), [controller](<https://devfeed.tech/tags/controller.md>), [core](<https://devfeed.tech/tags/core.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [driver](<https://devfeed.tech/tags/driver.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [lighting](<https://devfeed.tech/tags/lighting.md>), [linux](<https://devfeed.tech/tags/linux.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>), [misc](<https://devfeed.tech/tags/misc.md>), [motherboard](<https://devfeed.tech/tags/motherboard.md>), [msi](<https://devfeed.tech/tags/msi.md>), [open](<https://devfeed.tech/tags/open.md>), [open-source](<https://devfeed.tech/tags/open-source.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>), [rails](<https://devfeed.tech/tags/rails.md>), [rgb](<https://devfeed.tech/tags/rgb.md>), [sensors](<https://devfeed.tech/tags/sensors.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>), [usb](<https://devfeed.tech/tags/usb.md>)

### AI overview

Initial Linux driver patches for MSI Mystic Light focus on exposing voltage readings, rather than RGB controls. On tested motherboards, the USB microcontroller monitors the CPU 1P8, CHIP Core, and VDD MISC rails, which the Super I/O chip does not monitor. Linux RGB control may come in a later patch iteration; the excerpt does not establish that it is implemented.

### Source excerpt

MSI's latest Ryzen motherboards with AMD 800 series chipsets feature a new capability marked as Mystic Light for RGB lighting controls of the motherboard as well as compatible graphics cards and cases. MSI Mystic Light control software is only offered for Microsoft Windows but thanks to an open-source developer with the help of Claude Code, a Mystic Light open-source driver is being worked on for the Linux kernel...

## Unveiled at ROSCon: the easiest way to bring Arduino I/O into ROS 2

DevFeed: [Unveiled at ROSCon: the easiest way to bring Arduino I/O into ROS 2](<https://devfeed.tech/articles/unveiled-at-roscon-the-easiest-way-to-bring-arduino-i-o-into-ros-2-121832.md>)

Original publisher: [Read original article](<https://blog.arduino.cc/2026/11/06/unveiled-at-roscon-the-easiest-way-to-bring-arduino-i-o-into-ros-2/>)

Author: Arduino Team

Published: 2026-11-06T13:32:19Z

Content type: article

Language: en

Sources: [Arduino Blog](<https://devfeed.tech/sources/arduino-blog.md>)

Topics: [VENTUNO Q](<https://devfeed.tech/topics/ventuno-q.md>), [Arduino](<https://devfeed.tech/topics/arduino.md>), [software-architecture](<https://devfeed.tech/topics/software-architecture.md>), [Robot Navigation](<https://devfeed.tech/topics/robot-navigation.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [arduino](<https://devfeed.tech/tags/arduino.md>), [arduino-routerbridge](<https://devfeed.tech/tags/arduino-routerbridge.md>), [computer](<https://devfeed.tech/tags/computer.md>), [driving](<https://devfeed.tech/tags/driving.md>), [external](<https://devfeed.tech/tags/external.md>), [featured](<https://devfeed.tech/tags/featured.md>), [first](<https://devfeed.tech/tags/first.md>), [getting](<https://devfeed.tech/tags/getting.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [job](<https://devfeed.tech/tags/job.md>), [know](<https://devfeed.tech/tags/know.md>), [linux](<https://devfeed.tech/tags/linux.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [means](<https://devfeed.tech/tags/means.md>), [microcontroller](<https://devfeed.tech/tags/microcontroller.md>), [motors](<https://devfeed.tech/tags/motors.md>), [navigation](<https://devfeed.tech/tags/navigation.md>), [other](<https://devfeed.tech/tags/other.md>), [robotics](<https://devfeed.tech/tags/robotics.md>), [ros](<https://devfeed.tech/tags/ros.md>), [ros-2](<https://devfeed.tech/tags/ros-2.md>), [roscon](<https://devfeed.tech/tags/roscon.md>), [roscon-2026](<https://devfeed.tech/tags/roscon-2026.md>), [roscon-global-2026](<https://devfeed.tech/tags/roscon-global-2026.md>), [uncategorized](<https://devfeed.tech/tags/uncategorized.md>), [ventuno-q](<https://devfeed.tech/tags/ventuno-q.md>)

### AI overview

Arduino_RouterBridge_ROS connects an Arduino VENTUNO Q's Linux MPU and real-time microcontroller to a ROS 2 graph, allowing microcontroller firmware to create nodes, publishers, subscribers, services, and actions without additional bridge nodes. It builds on Arduino_RouterBridge, which uses MsgPackRPC: Bridge.provide() registers callable functions and Bridge.call() invokes them across the Python/Linux and Zephyr-based microcontroller sides. The ROS library uses a lightweight RouterBridge transport, is described as independent of the Linux-side RMW vendor, and offers a C++ interface modeled on rclcpp. The article gives streaming IMU data to /imu/data and receiving motor commands on /cmd_vel as examples. The source points to UNO Q getting-started guides and a first-project guide; the excerpt does not provide setup details or measured performance.

### Source excerpt

If you've ever built a robot with ROS 2, you know the classic architectural split: a powerful computer running Linux handles high-level navigation, mapping, and planning, while an external microcontroller handles the deterministic, real-time job of toggling GPIOs, reading sensors, and driving motors. Getting those two worlds to talk to each other usually means wrestling [...] The post Unveiled at ROSCon: the easiest way to bring Arduino I/O into ROS 2 appeared first on Arduino Blog.

## Demystifying Linux Cgroups: The Hidden Engine Powering Docker and Kubernetes

DevFeed: [Demystifying Linux Cgroups: The Hidden Engine Powering Docker and Kubernetes](<https://devfeed.tech/articles/demystifying-linux-cgroups-the-hidden-engine-powering-docker-and-kubernetes-121431.md>)

Original publisher: [Read original article](<https://blog.devops.dev/demystifying-linux-cgroups-the-hidden-engine-powering-docker-and-kubernetes-e6627f9fe75d?source=rss----33f8b2d9a328---4>)

Author: Techie Crow

Published: 2026-11-06T09:45:56Z

Content type: article

Language: en

Sources: [DevOps.dev](<https://devfeed.tech/sources/devops-dev.md>)

Topics: [cgroups](<https://devfeed.tech/topics/cgroups.md>), [Linux Kernel](<https://devfeed.tech/topics/linux-kernel.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [Docker](<https://devfeed.tech/topics/docker.md>)

Tags: [cgroup](<https://devfeed.tech/tags/cgroup.md>), [cgroups](<https://devfeed.tech/tags/cgroups.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [containers](<https://devfeed.tech/tags/containers.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [devops](<https://devfeed.tech/tags/devops.md>), [devops-engineer](<https://devfeed.tech/tags/devops-engineer.md>), [docker](<https://devfeed.tech/tags/docker.md>), [google](<https://devfeed.tech/tags/google.md>), [groups](<https://devfeed.tech/tags/groups.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [kubernetes](<https://devfeed.tech/tags/kubernetes.md>), [kubernetes-yaml-manifests](<https://devfeed.tech/tags/kubernetes-yaml-manifests.md>), [linux](<https://devfeed.tech/tags/linux.md>), [linux-kernel](<https://devfeed.tech/tags/linux-kernel.md>), [memory](<https://devfeed.tech/tags/memory.md>), [node](<https://devfeed.tech/tags/node.md>), [performance](<https://devfeed.tech/tags/performance.md>), [pod](<https://devfeed.tech/tags/pod.md>)

### AI overview

Linux cgroups are kernel controls for allocating, restricting, prioritizing, and monitoring resources used by groups of processes. The excerpt identifies memory, CPU, and disk I/O as resources that can be capped, and says cgroups can prioritize CPU or disk throughput under system pressure. It frames cgroups as underlying resource controls relevant to containers, but the excerpt does not explain how they map to Kubernetes settings or determine pod priority.

### Source excerpt

Ever wondered how your server handles hundreds of isolated containers without losing its mind? Or how Kubernetes ensures that a single... Continue reading on DevOps.dev "

## LeanStream: A Speculate-and-Refine Streaming Framework for Efficient on-Device LLM Inference

DevFeed: [LeanStream: A Speculate-and-Refine Streaming Framework for Efficient on-Device LLM Inference](<https://devfeed.tech/articles/leanstream-a-speculate-and-refine-streaming-framework-for-efficient-on-device-llm-inference-120480.md>)

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

Author: Renyuan Liu (Richard), Yuyang Leng (Richard), Kaiyan Liu (Richard), Yuzhou Zhong (Richard), Shaohan Hu (Richard), Chun-Fu (Richard), Chen, Peijun Zhao, Heechul Yun, Shuochao Yao

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

Content type: article

Language: en

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

Topics: [On-device AI](<https://devfeed.tech/topics/on-device-ai.md>), [Local AI](<https://devfeed.tech/topics/local-ai.md>), [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>)

Tags: [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [device](<https://devfeed.tech/tags/device.md>), [embedded](<https://devfeed.tech/tags/embedded.md>), [embedded-devices](<https://devfeed.tech/tags/embedded-devices.md>), [framework](<https://devfeed.tech/tags/framework.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [inference](<https://devfeed.tech/tags/inference.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-inference](<https://devfeed.tech/tags/llm-inference.md>), [memory](<https://devfeed.tech/tags/memory.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [model](<https://devfeed.tech/tags/model.md>), [on-device](<https://devfeed.tech/tags/on-device.md>), [overlap](<https://devfeed.tech/tags/overlap.md>), [storage](<https://devfeed.tech/tags/storage.md>), [streaming](<https://devfeed.tech/tags/streaming.md>), [systems](<https://devfeed.tech/tags/systems.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [token](<https://devfeed.tech/tags/token.md>), [trade](<https://devfeed.tech/tags/trade.md>)

### AI overview

LeanStream targets on-device LLM inference when model weights exceed available DRAM. Earlier sparse-execution systems face a trade-off: accurate execution choices need recent context, while overlapping computation with storage I/O requires early prediction. LeanStream progressively updates computation, loading, and cache-retention priorities from partial GPU results, allowing finer overlap between GPU execution and SSD or flash I/O. Implemented on mobile and embedded platforms, it reports 4.8x-7.5x lower memory use than prior systems at their best throughput, while increasing token generation throughput by 1.6x-2.1x. These figures are abstract-level comparisons; the excerpt does not provide evaluation details.

### Source excerpt

arXiv:2609.03079v2 Announce Type: replace Abstract: On-device LLM inference is attractive for privacy and responsiveness, but remains challenging on mobile and embedded devices because model weights far exceed available DRAM. Prior systems exploit activation sparsity and offload weights to SSD or flash storage, but face a fundamental systems trade-off: accurate sparse execution decisions require the latest context, whereas efficient computation-I/O overlap requires early prediction. As a result, existing designs either serialize execution or incur redundant weight fetches, extra computation, and large cache overheads. We present LeanStream, a streaming speculate-and-refine framework for efficient on-device LLM inference. LeanStream progressively refines computation, loading, and cache-retention priorities using partial GPU results, enabling fine-grained overlap between GPU execution and storage I/O. We implement LeanStream on both mobile and embedded platforms. Compared with prior on-device LLM inference systems, LeanStream reduces memory usage by 4.8$\times$ to 7.5$\times$ at the best throughput achieved by prior work, while further improving token generation throughput by 1.6$\times$ to 2.1$\times$. Source code is available at https://github.com/RenyuanLIU/LeanStream.

## Linux's RAID6 Check Tool Sees 3x Performance Via Batching

DevFeed: [Linux's RAID6 Check Tool Sees 3x Performance Via Batching](<https://devfeed.tech/articles/linux-s-raid6-check-tool-sees-3x-performance-via-batching-119361.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/Linux-3x-Faster-raid6check>)

Author: Michael Larabel

Published: 2026-11-05T17:09:10Z

Content type: news

Language: en

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

Topics: [RAID](<https://devfeed.tech/topics/raid.md>), [Mdadm](<https://devfeed.tech/topics/mdadm.md>), [Linux](<https://devfeed.tech/topics/linux.md>)

Tags: [array](<https://devfeed.tech/tags/array.md>), [batching](<https://devfeed.tech/tags/batching.md>), [command](<https://devfeed.tech/tags/command.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [developer](<https://devfeed.tech/tags/developer.md>), [device](<https://devfeed.tech/tags/device.md>), [errors](<https://devfeed.tech/tags/errors.md>), [git](<https://devfeed.tech/tags/git.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [improvement](<https://devfeed.tech/tags/improvement.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [linux](<https://devfeed.tech/tags/linux.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>), [mdadm](<https://devfeed.tech/tags/mdadm.md>), [memory](<https://devfeed.tech/tags/memory.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [patch](<https://devfeed.tech/tags/patch.md>), [performance](<https://devfeed.tech/tags/performance.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [raid](<https://devfeed.tech/tags/raid.md>), [repair](<https://devfeed.tech/tags/repair.md>), [repository](<https://devfeed.tech/tags/repository.md>), [software](<https://devfeed.tech/tags/software.md>), [tool](<https://devfeed.tech/tags/tool.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

raid6check checks and repairs Linux MD RAID6 arrays using their double parity. It previously processed one stripe per disk at a time, leaving it not I/O-bound; a merged mdadm change batches I/O to improve performance, at a memory cost. The developer reports a 3x speedup on a six-disk, 4 TB-per-disk RAID6 setup with spinning disks, ample memory, and a modern kernel, using 512 MB as a reasonable batch-memory amount. The speedup is reported for that setup; similar gains are only assumed for similar configurations.

### Source excerpt

For those that use Linux's raid6check command for checking/repairing an MD RAID6 software RAID array's device for errors, newly-merged code is showing up to a 3x performance improvement...

## Reinforcement Learning in GUI Agents: A Survey Toward Digital Inhabitants

DevFeed: [Reinforcement Learning in GUI Agents: A Survey Toward Digital Inhabitants](<https://devfeed.tech/articles/reinforcement-learning-in-gui-agents-a-survey-toward-digital-inhabitants-118210.md>)

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

Author: Junan Hu, Jian Liu, Jingxiang Lai, Jiarui Hu, Yiwei Sheng, Shuang Chen, Jian Li, Dazhao Du, Song Guo

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

Content type: article

Language: en

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

Topics: [Reinforcement learning](<https://devfeed.tech/topics/reinforcement-learning.md>), [World models](<https://devfeed.tech/topics/world-models.md>), [GUI](<https://devfeed.tech/topics/gui.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [automation](<https://devfeed.tech/tags/automation.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cv](<https://devfeed.tech/tags/cs-cv.md>), [data-efficiency](<https://devfeed.tech/tags/data-efficiency.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [exploration](<https://devfeed.tech/tags/exploration.md>), [fine-tuning](<https://devfeed.tech/tags/fine-tuning.md>), [gui](<https://devfeed.tech/tags/gui.md>), [gui-agents](<https://devfeed.tech/tags/gui-agents.md>), [hybrid](<https://devfeed.tech/tags/hybrid.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [interface](<https://devfeed.tech/tags/interface.md>), [key](<https://devfeed.tech/tags/key.md>), [latency](<https://devfeed.tech/tags/latency.md>), [methodology](<https://devfeed.tech/tags/methodology.md>), [model](<https://devfeed.tech/tags/model.md>), [offline](<https://devfeed.tech/tags/offline.md>), [online](<https://devfeed.tech/tags/online.md>), [reinforcement-learning](<https://devfeed.tech/tags/reinforcement-learning.md>), [survey](<https://devfeed.tech/tags/survey.md>)

### AI overview

The survey organizes reinforcement learning for GUI agents into Offline RL, Online RL, and Hybrid Strategies, and examines reward engineering, data efficiency, and technical innovations. It identifies a reliability-scalability tension behind composite, multi-tier reward architectures; GUI input/output latency as a driver of world-model-based training; and evidence that System-2-style deliberation can emerge without explicit reasoning supervision when reward signals are sufficiently rich. Its proposed roadmap covers process rewards, continual RL, cognitive architectures, and safe deployment. These are findings and directions reported in the abstract; the supplied text does not provide detailed comparisons of individual methods.

### Source excerpt

arXiv:2604.27955v2 Announce Type: replace Abstract: Graphical User Interface (GUI) agents have emerged as a promising paradigm for intelligent systems that perceive and interact with graphical interfaces visually. Yet supervised fine-tuning alone cannot handle long-horizon credit assignment, distribution shifts, and safe exploration in irreversible environments, making Reinforcement Learning (RL) a central methodology for advancing automation. In this work, we present the first comprehensive overview of the intersection between RL and GUI agents, and examine how this research direction may evolve toward digital inhabitants. We propose a principled taxonomy that organizes existing methods into Offline RL, Online RL, and Hybrid Strategies, and complement it with analyses of reward engineering, data efficiency, and key technical innovations. Our analysis reveals several emerging trends: the tension between reliability and scalability is motivating the adoption of composite, multi-tier reward architectures; GUI I/O latency bottlenecks are accelerating the shift toward world-model-based training, which can yield substantial performance gains; and the spontaneous emergence of System-2-style deliberation suggests that explicit reasoning supervision may not be necessary when sufficiently rich reward signals are available. We distill these findings into a roadmap covering process rewards, continual RL, cognitive architectures, and safe deployment, aiming to guide the next generation of robust GUI automation and its agent-native infrastructure.

## Fast and Memory-Efficient Wavelet Convolutions via I/O-Aware Reformulation

DevFeed: [Fast and Memory-Efficient Wavelet Convolutions via I/O-Aware Reformulation](<https://devfeed.tech/articles/fast-and-memory-efficient-wavelet-convolutions-via-i-o-aware-reformulation-118256.md>)

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

Author: Amit Aflalo, Shahaf E. Finder, Roy Amoyal, Eran Treister, Oren Freifeld

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

Content type: article

Language: en

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

Topics: [GPU optimization](<https://devfeed.tech/topics/gpu-optimization.md>), [Neural Network](<https://devfeed.tech/topics/neural-network.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [arithmetic](<https://devfeed.tech/tags/arithmetic.md>), [bits](<https://devfeed.tech/tags/bits.md>), [butterfly](<https://devfeed.tech/tags/butterfly.md>), [cascade](<https://devfeed.tech/tags/cascade.md>), [channel](<https://devfeed.tech/tags/channel.md>), [chip](<https://devfeed.tech/tags/chip.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [convolution](<https://devfeed.tech/tags/convolution.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-cv](<https://devfeed.tech/tags/cs-cv.md>), [data-movement](<https://devfeed.tech/tags/data-movement.md>), [drop-in](<https://devfeed.tech/tags/drop-in.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [execution](<https://devfeed.tech/tags/execution.md>), [fast](<https://devfeed.tech/tags/fast.md>), [folding](<https://devfeed.tech/tags/folding.md>), [hbm](<https://devfeed.tech/tags/hbm.md>), [high-bandwidth-memory](<https://devfeed.tech/tags/high-bandwidth-memory.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [memory](<https://devfeed.tech/tags/memory.md>)

### AI overview

The reference WTConv implementation is memory-bound: despite comparable arithmetic, it runs substantially slower than the depthwise convolution it replaces. The authors use an I/O model to guide three reformulations: recompute the inexpensive Haar analysis butterfly on chip, collapse the multi-level synthesis cascade into one pass indexed by output-coordinate bits, and fold learned per-channel scales into convolution weights. In WTConvNeXt evaluations across decomposition levels and tensor shapes, these changes reduce modeled HBM traffic by about 2.55x and deliver up to 4.35x training speedup over the reference, while roughly halving peak memory usage. The evidence describes results for the evaluated configuration and shapes.

### Source excerpt

arXiv:2608.10805v3 Announce Type: replace-cross Abstract: Wavelet convolution (WTConv) has emerged as an increasingly popular drop-in replacement for standard convolutions, expanding a network's receptive field exponentially with the number of decomposition levels while keeping the parameter count linear. However, its reference implementation is severely memory-bound due to excessive data movement through high-bandwidth memory (HBM). We develop an I/O model of WTConv to characterize this bottleneck and use it to guide three algebraic reformulations: (1) recomputing the inexpensive Haar analysis butterfly on chip, (2) collapsing the multi-level synthesis cascade into a single closed-form pass indexed by output-coordinate bits, and (3) folding learned per-channel scales into the convolution weights. Together, these reformulations enable an I/O-aware fused implementation that substantially reduces HBM traffic. We evaluate the WTConvNeXt configuration across decomposition levels and a broad range of tensor shapes. Despite performing comparable arithmetic, the reference WTConv is substantially slower than the depthwise convolution it replaces. Our reformulation reduces modeled HBM traffic by approximately $2.55\times$, yielding up to a $4.35\times$ training speedup over the reference while roughly halving peak memory usage. Thus, our reformulation preserves the benefits of WTConv while substantially reducing its execution time and memory footprint, removing the systems overhead that previously limited its practical efficiency.

## Retrieval Supersedes Scale: Efficient Log Level Prediction via Multiplex Socio-Technical Context

DevFeed: [Retrieval Supersedes Scale: Efficient Log Level Prediction via Multiplex Socio-Technical Context](<https://devfeed.tech/articles/retrieval-supersedes-scale-efficient-log-level-prediction-via-multiplex-socio-technical-context-118062.md>)

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

Author: Youssef Esseddiq Ouatiti, Mohammed Sayagh, Bram Adams, Ahmed E. Hassan

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

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Retrieval Augmented Generation (RAG)](<https://devfeed.tech/topics/retrieval-augmented-generation-rag.md>), [Enhancing AI model performance](<https://devfeed.tech/topics/enhancing-ai-model-performance.md>), [LLM Techniques](<https://devfeed.tech/topics/llm-techniques.md>)

Tags: [ablation](<https://devfeed.tech/tags/ablation.md>), [approach](<https://devfeed.tech/tags/approach.md>), [code](<https://devfeed.tech/tags/code.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [error](<https://devfeed.tech/tags/error.md>), [functionality](<https://devfeed.tech/tags/functionality.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [info](<https://devfeed.tech/tags/info.md>), [java](<https://devfeed.tech/tags/java.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [llms](<https://devfeed.tech/tags/llms.md>), [logging](<https://devfeed.tech/tags/logging.md>), [median](<https://devfeed.tech/tags/median.md>), [ownership](<https://devfeed.tech/tags/ownership.md>), [prediction](<https://devfeed.tech/tags/prediction.md>), [production](<https://devfeed.tech/tags/production.md>), [prompt](<https://devfeed.tech/tags/prompt.md>), [random](<https://devfeed.tech/tags/random.md>), [relevance](<https://devfeed.tech/tags/relevance.md>), [retrieval](<https://devfeed.tech/tags/retrieval.md>)

### AI overview

The paper reports that retrieving logging examples by both code functionality and developer ownership improves LLM log-level prediction over randomly sampled examples. Across four LLMs and ten Java projects, the combined signals achieved median AUCs of 0.83-0.97, improved median AUC by 0.07 over random baselines, and outperformed the stronger individual retrieval signal on every project. The approach also exceeded supervised predictors such as DeepLV by a median AUC of 0.12-0.19. The reported results are from the evaluated projects and models; the abstract does not provide implementation details.

### Source excerpt

arXiv:2611.05901v1 Announce Type: new Abstract: Developers insert logging statements in source code to record its execution, and the resulting logs are essential for detecting and troubleshooting system anomalies. A key part of these statements is the log level (e.g., DEBUG, INFO, WARN, ERROR), which determines whether a message is recorded. Choosing it is a trade-off: levels set too low mask important information in production, while levels set too high create noisy logs and extra I/O and storage overhead. Recent work uses Large Language Models (LLMs) with In-Context Learning (ICL) to predict log levels, but typically augments the prompt with randomly sampled examples. We argue that this overlooks the socio-technical nature of logging, where conventions vary by component and development team. Off-the-shelf LLMs using random examples are reported to achieve median AUCs of only 0.56 to 0.76, leaving room for improvement without fine-tuning. In this paper, we propose a retrieval approach for LLM-powered log level prediction that prioritizes context relevance over random selection and basic similarity. Our method retrieves logging examples relevant along two socio-technical dimensions: (i) functionality (code performing similar operations) and (ii) ownership (code maintained by the same developers). Evaluating four LLMs across ten popular Java projects, we find that this retrieval improves AUC over random baselines by 0.07 (median), and combining both signals yields median AUCs of 0.83 to 0.97. Our ablation studies show that each signal improves on random retrieval, and that combining them outperforms the stronger of the two on all ten projects. Our results also significantly exceed state-of-the-art supervised predictors (e.g., DeepLV) by a median AUC of 0.12 to 0.19. Our findings highlight the importance of socio-technical signals such as code functionality and ownership for LLM-powered log level prediction.

## Your .NET parallel loop can become serial in a one-CPU container

DevFeed: [Your .NET parallel loop can become serial in a one-CPU container](<https://devfeed.tech/articles/your-net-parallel-loop-can-become-serial-in-a-one-cpu-container-118939.md>)

Original publisher: [Read original article](<https://stackoverflow.blog/2026/11/04/your-net-parallel-loop-can-become-serial-in-a-one-cpu-container/>)

Author: Guilherme Appel

Published: 2026-11-04T16:34:13Z

Content type: opinion

Language: en

Sources: [Stack Overflow](<https://devfeed.tech/sources/stack-overflow-blog.md>)

Topics: [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [rate-limiting](<https://devfeed.tech/topics/rate-limiting.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [api](<https://devfeed.tech/tags/api.md>), [backpressure](<https://devfeed.tech/tags/backpressure.md>), [budget](<https://devfeed.tech/tags/budget.md>), [building-software](<https://devfeed.tech/tags/building-software.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [cc-by-sa](<https://devfeed.tech/tags/cc-by-sa.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [container](<https://devfeed.tech/tags/container.md>), [contributed](<https://devfeed.tech/tags/contributed.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [net](<https://devfeed.tech/tags/net.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [serial](<https://devfeed.tech/tags/serial.md>), [service](<https://devfeed.tech/tags/service.md>)

### AI overview

In the lab, a one-CPU container cut the default Parallel.ForEachAsync concurrency from two records to one, nearly doubling the median time for 200 records from 42.1 to 83.6 seconds. The CPU-based default can constrain I/O work because it waits on a CPU-derived limit even while records await services. Raising the loop limit can restore concurrency but may overload downstream systems; a shared semaphore also cannot reserve capacity for a more fragile dependency, and it does not enforce rate quotas. The article recommends shared, explicit per-dependency concurrency budgets, configured to service capacity, with enough records in flight to meet throughput goals. In simulated tests, a six-write-permit budget eliminated HTTP 503 rejections when the write service slowed, while shared or absent limits produced 57-64; the per-dependency setup was slower in healthy runs and achieved about 0.82 of shared-pool throughput when enrichment slowed. These results describe simulated services. The article also recommends startup validation, per-service in-flight monitoring, separate call and permit-wait deadlines, and measurements under actual container CPU limits.

### Source excerpt

CPU-based defaults can leave an I/O-heavy loop processing one record at a time. Raising the limit helps, but each downstream service still needs a concurrency budget it can handle.

## There are things with ranks, but it's not always clear what the ranks mean

DevFeed: [There are things with ranks, but it's not always clear what the ranks mean](<https://devfeed.tech/articles/there-are-things-with-ranks-but-it-s-not-always-clear-what-the-ranks-mean-118976.md>)

Original publisher: [Read original article](<https://devblogs.microsoft.com/oldnewthing/20261104-00/?p=112830/>)

Author: Raymond Chen

Published: 2026-11-04T15:00:00Z

Content type: article

Language: en

Sources: [Raymond Chen](<https://devfeed.tech/sources/raymond-chen.md>)

Topics: [Documentation](<https://devfeed.tech/topics/documentation.md>), [Query (disambiguation)](<https://devfeed.tech/topics/query.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [api](<https://devfeed.tech/tags/api.md>), [code](<https://devfeed.tech/tags/code.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [documentation](<https://devfeed.tech/tags/documentation.md>), [driver](<https://devfeed.tech/tags/driver.md>), [feature](<https://devfeed.tech/tags/feature.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [old-new-thing](<https://devfeed.tech/tags/old-new-thing.md>)

### AI overview

The post shows how documentation can leave "rank" undefined, then explains the Windows package graph's actual ordering: packages are searched in ascending rank, so lower ranks have precedence. A process's graph starts empty; declared dependencies are added at rank zero in static resolution order. `AddPackageDependency` inserts a package after lower-ranked packages and before higher-ranked ones. By default, it follows packages with the same rank; `AddPackageDependencyOptions_PrependIfRankCollision` places it before them. Because rank is a signed integer, a negative rank can place a package ahead of the static dependencies. The post contrasts this unclear documentation with SQL Server full-text search, where higher rank explicitly means a more relevant match, and filter-driver altitude, where lower numerical altitude means loading lower in the I/O stack.

### Source excerpt

The problem with documentation written by people who know the feature too well. The post There are things with ranks, but it's not always clear what the ranks mean appeared first on The Old New Thing.

## PhotonZip: Lifecycle-Aware Compression for HDF5-Based Synchrotron Workflows

DevFeed: [PhotonZip: Lifecycle-Aware Compression for HDF5-Based Synchrotron Workflows](<https://devfeed.tech/articles/photonzip-lifecycle-aware-compression-for-hdf5-based-synchrotron-workflows-116483.md>)

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

Author: Haoxu Li, Wenjing Huang, Chengyu Liu, Shiyuan Fu, Hao Hu, Guangming Tan, Dingwen Tao

Published: 2026-11-04T05: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>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>)

Tags: [compression](<https://devfeed.tech/tags/compression.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [framework](<https://devfeed.tech/tags/framework.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [latency](<https://devfeed.tech/tags/latency.md>), [lifecycle](<https://devfeed.tech/tags/lifecycle.md>), [preview](<https://devfeed.tech/tags/preview.md>), [ratio](<https://devfeed.tech/tags/ratio.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [workflows](<https://devfeed.tech/tags/workflows.md>), [write](<https://devfeed.tech/tags/write.md>)

### AI overview

PhotonZip measures candidate compression modes through a shared HDF5 workflow, then selects eligible configurations for compression ratio or round-trip throughput. Its modular filters retain standard HDF5 access when the required plugin is available. Across four beamline-derived datasets, the authors report lossless compression up to 1.629x and HDF5 throughput up to 3.40 GB/s for writes and 7.75 GB/s for reads. A throughput-oriented configuration delivers 1.529x lossless data reduction while increasing write and read throughput by 21.2% and 15.0%. Lossy preview modes reach up to 16x data reduction and cut preview latency by up to 8.35 seconds in the evaluated file-per-rank setup.

### Source excerpt

arXiv:2611.04138v1 Announce Type: new Abstract: Synchrotron detectors generate data at rates that challenge storage and I/O systems. Compression can reduce data movement, but codec-only measurements do not capture the end-to-end behavior of HDF5 workflows. We present PhotonZip, a lifecycle-aware compression framework that tests candidate modes through a common HDF5 path and selects among eligible measured configurations according to either compression ratio or round-trip throughput. Its modular filters preserve standard HDF5 access when the required plugin is available. Across four beamline-derived datasets, PhotonZip reaches lossless compression ratios up to 1.629$\times$ and HDF5 write throughput up to 3.40GB/s write and 7.75GB/s read. The throughput-oriented configuration achieves 1.529$\times$ lossless data reduction while improving HDF5 write and read throughput by 21.2\% and 15.0\%, respectively. Lossy preview modes provide up to 16$\times$ data reduction and reduce preview latency by up to 8.35~s in the evaluated file-per-rank HDF5 configuration.

## How to run I/O workloads on OpenShift Virtualization VMs

DevFeed: [How to run I/O workloads on OpenShift Virtualization VMs](<https://devfeed.tech/articles/how-to-run-i-o-workloads-on-openshift-virtualization-vms-115666.md>)

Original publisher: [Read original article](<https://developers.redhat.com/articles/2026/11/03/how-run-io-workloads-openshift-virtualization-vms>)

Author: Elvir Kuric

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

Content type: tutorial

Language: en

Sources: [Red Hat](<https://devfeed.tech/sources/red-hat.md>), [Red Hat Developer](<https://devfeed.tech/sources/red-hat-developer.md>)

Topics: [virtualization](<https://devfeed.tech/topics/virtualization.md>), [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>), [systems](<https://devfeed.tech/topics/systems.md>), [container images](<https://devfeed.tech/topics/container-images.md>)

Tags: [automated](<https://devfeed.tech/tags/automated.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [ci](<https://devfeed.tech/tags/ci.md>), [containerized](<https://devfeed.tech/tags/containerized.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [linux](<https://devfeed.tech/tags/linux.md>), [openshift](<https://devfeed.tech/tags/openshift.md>), [performance-and-scale-engineering](<https://devfeed.tech/tags/performance-and-scale-engineering.md>), [provisioning](<https://devfeed.tech/tags/provisioning.md>), [virtualization](<https://devfeed.tech/tags/virtualization.md>)

### AI overview

The `fio-container` harness makes Linux FIO testing repeatable across OpenShift Virtualization VMs: configure a workload matrix once, run it in parallel through `virtctl`, and collect per-VM JSON results in a shared directory for cross-run analysis. You can target pre-created VMs or set `CREATE_VMS=true` to provision Linux guests in the same job. YAML suits complex runs; environment variables support quick or CI runs. Storage modes cover a formatted and mounted data disk, raw block-device I/O, or a writable test directory on the OS disk. The harness prepares storage, installs FIO when needed, pre-writes data, runs the workload combinations, and gathers results. A bastion needs cluster access, Podman, and passwordless guest SSH; provisioning also requires a namespace and storage class. The article's detailed examples cover Linux. It also describes SSH-only use with bare-metal, KVM, and VMware Linux hosts; Windows guidance is deferred to `README-container.md`.

### Source excerpt

Editor's note This post was originally published in October 2025 and has been updated to reflect the latest containerized FIO test harness and automated VM provisioning workflows. The post How to run I/O workloads on OpenShift Virtualization VMs appeared first on Red Hat Developer.

## Linux Preparing Faster FAT32 Performance In 2027 With Up To 4.06x Improvement

DevFeed: [Linux Preparing Faster FAT32 Performance In 2027 With Up To 4.06x Improvement](<https://devfeed.tech/articles/linux-preparing-faster-fat32-performance-in-2027-with-up-to-4-06x-improvement-114146.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/Faster-FAT32-Linux-In-2027>)

Author: Michael Larabel

Published: 2026-11-03T13:23:29Z

Content type: news

Language: en

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

Topics: [Linux](<https://devfeed.tech/topics/linux.md>), [Linux Kernel](<https://devfeed.tech/topics/linux-kernel.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>)

Tags: [batching](<https://devfeed.tech/tags/batching.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [branch](<https://devfeed.tech/tags/branch.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [code](<https://devfeed.tech/tags/code.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [developer](<https://devfeed.tech/tags/developer.md>), [driver](<https://devfeed.tech/tags/driver.md>), [fat](<https://devfeed.tech/tags/fat.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [linux](<https://devfeed.tech/tags/linux.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>), [mirror](<https://devfeed.tech/tags/mirror.md>), [mount](<https://devfeed.tech/tags/mount.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [patch](<https://devfeed.tech/tags/patch.md>), [performance](<https://devfeed.tech/tags/performance.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [process](<https://devfeed.tech/tags/process.md>), [submission](<https://devfeed.tech/tags/submission.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

A Linux FAT driver change aims to speed up FAT32 on synchronous mounts by batching mirror writes and improving I/O submission. The current buffer-by-buffer synchronization serializes I/O; benchmarks reported up to a 4.06x improvement with the patch. It is in Andrew Morton's mm-everything branch and may land in Linux 7.5, subject to the MM process.

### Source excerpt

In addition to some significant performance improvements for FAT32 in Linux 7.4, more performance improvements are on the way. For what will likely land in Linux 7.5 is up to a 4.06x improvement demonstrated for this aging file-system...

## Speculative Ad-hoc Querying

DevFeed: [Speculative Ad-hoc Querying](<https://devfeed.tech/articles/speculative-ad-hoc-querying-113623.md>)

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

Author: Haoyu Li, Srikanth Kandula, Maria Angels de Luis Balaguer, Aditya Akella, Venkat Arun

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

Content type: article

Language: en

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

Topics: [Tool](<https://devfeed.tech/topics/tool.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>)

Tags: [agent-workflows](<https://devfeed.tech/tags/agent-workflows.md>), [agentic-systems](<https://devfeed.tech/tags/agentic-systems.md>), [api](<https://devfeed.tech/tags/api.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [cs-hc](<https://devfeed.tech/tags/cs-hc.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-ma](<https://devfeed.tech/tags/cs-ma.md>), [database](<https://devfeed.tech/tags/database.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [latency](<https://devfeed.tech/tags/latency.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llms](<https://devfeed.tech/tags/llms.md>), [productivity](<https://devfeed.tech/tags/productivity.md>), [queries](<https://devfeed.tech/tags/queries.md>), [query](<https://devfeed.tech/tags/query.md>), [querying](<https://devfeed.tech/tags/querying.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [scheduler](<https://devfeed.tech/tags/scheduler.md>), [sql](<https://devfeed.tech/tags/sql.md>), [tables](<https://devfeed.tech/tags/tables.md>)

### AI overview

Wonder uses a small auxiliary LLM to prepare analytical SQL work while a primary agent reasons. Rather than predict an exact next query, it anticipates shared query shapes and data needs, materializes reusable superset results, then rewrites later queries to use them. Its scheduler gives foreground queries priority and uses reasoning intervals for speculation; people writing SQL can also guide preparation with incomplete queries and see intermediate results. In replayed agent workflows, Wonder reduced SQL execution time by up to 31.8% and combined reasoning and active SQL time by up to 22.6%, alongside about 6% higher recorded API cost and 10% more read I/O on the full dataset. A separate 24-person study reported lower latency on both analytical tasks, faster answers on one, and increased productivity for 87.5% of participants.

### Source excerpt

arXiv:2503.00714v2 Announce Type: replace Abstract: Large language models (LLMs) invite substantial effort and investment, yet agentic systems can spend much of their time waiting for tools. This paper explores how a small auxiliary LLM can reduce these waits by speculatively preparing a database while the primary LLM reasons. The challenge is that the auxiliary model must anticipate the primary model's actions before the primary model takes them. Our key insight is that database systems give the speculator a structural advantage: it need not predict the exact next query. Instead, it can prepare work shared by many plausible queries. Predicting query shapes enables advance compilation, predicting data access warms caches, and predicting broader data requirements enables precomputation of superset results that subsequent queries can refine. We present Wonder, a system that exploits this advantage for analytical SQL workloads. Wonder constructs reusable superset queries, materializes their components, and rewrites subsequent queries against the resulting temporary tables. Its scheduler prioritizes foreground queries while using reasoning intervals for speculative preparation. The same engine supports humans writing SQL, using incomplete queries to guide speculation and displaying intermediate results as they type. In a replay-based evaluation of agent workflows, Wonder reduces SQL execution time by up to 31.8% and combined primary-agent reasoning and active SQL time by up to 22.6%, with approximately 6% higher recorded main-agent and prediction API cost and 10% more read I/O on the full dataset. A separate 24-participant study finds significantly lower query latency on both analytical tasks and improved time-to-answer on one, with 87.5% of participants reporting increased productivity.

## Hierarchical Residuals: A Minimalist Decoupling of Residual Width from Compute Width

DevFeed: [Hierarchical Residuals: A Minimalist Decoupling of Residual Width from Compute Width](<https://devfeed.tech/articles/hierarchical-residuals-a-minimalist-decoupling-of-residual-width-from-compute-width-111615.md>)

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

Author: Ziteng Wang, Jianqiao Lu, Xinyu Ma, Jintao Zhang, Jun Zhu, Yiyuan Ma, Jianfei Chen

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

Content type: article

Language: en

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

Topics: [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [scaling laws](<https://devfeed.tech/topics/scaling-laws.md>)

Tags: [compute](<https://devfeed.tech/tags/compute.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [decoupling](<https://devfeed.tech/tags/decoupling.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [memory](<https://devfeed.tech/tags/memory.md>), [model](<https://devfeed.tech/tags/model.md>), [operators](<https://devfeed.tech/tags/operators.md>), [pretraining](<https://devfeed.tech/tags/pretraining.md>), [scaling-laws](<https://devfeed.tech/tags/scaling-laws.md>), [transformers](<https://devfeed.tech/tags/transformers.md>)

### AI overview

HiRes decouples Transformer residual width from per-layer compute width: standard d-dimensional PreNorm layers run within blocks, while a wider D-dimensional PostNorm residual connects blocks through learned read/write projections. Across tested model sizes and depths, it reportedly outperforms vanilla residual addition, with fitted scaling laws indicating 1.30x FLOPs efficiency. In OLMoE-1B-7B pretraining for 500B tokens, it reports 0.0208 lower training loss and 1.14-point higher downstream accuracy. The abstract says HiRes is competitive with VWN, mHC and AttnRes while using less activation memory and I/O, and uses dense projections and normalizations without specialized kernels or infrastructure-level optimizations.

### Source excerpt

arXiv:2610.41711v1 Announce Type: new Abstract: Residual connections underpin Transformers, but they implicitly tie the residual width carried through depth to the compute width used inside each layer. We introduce Hierarchical Residuals (HiRes), a minimalist architectural change that decouples these dimensions, widening the residual state while keeping per-layer compute width fixed. HiRes groups layers into blocks: standard d-dimensional PreNorm layers operate inside each block, while a wider D-dimensional PostNorm outer residual connects blocks. Learned read/write projections bridge the two spaces at block boundaries, leaving individual Transformer layers unchanged. Across different model sizes and depths, HiRes consistently outperforms vanilla residual addition, with fitted scaling laws indicating a 1.30-fold improvement in FLOPs efficiency. On OLMoE-1B-7B pretraining for 500B tokens, HiRes achieves 0.0208 lower training loss and 1.14-point higher downstream accuracy. HiRes is also competitive with other residual expansion methods such as VWN, mHC and AttnRes with less activation memory and I/O costs. Built from only dense projections and normalizations, it requires neither specialized kernels nor infrastructure-level optimizations. HiRes thus exposes residual width as a practical scaling variable using only standard operators.

## 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.

## Ceph In Linux 7.4 Adds Global Mount Option For Lazy I/O

DevFeed: [Ceph In Linux 7.4 Adds Global Mount Option For Lazy I/O](<https://devfeed.tech/articles/ceph-in-linux-7-4-adds-global-mount-option-for-lazy-i-o-109836.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/Linux-7.4-Ceph>)

Author: Michael Larabel

Published: 2026-10-31T10:30:00Z

Content type: news

Language: en

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

Topics: [ceph](<https://devfeed.tech/topics/ceph.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [Linux Kernel](<https://devfeed.tech/topics/linux-kernel.md>), [mount](<https://devfeed.tech/topics/mount.md>)

Tags: [2014](<https://devfeed.tech/tags/2014.md>), [bug-fixes](<https://devfeed.tech/tags/bug-fixes.md>), [cache](<https://devfeed.tech/tags/cache.md>), [ceph](<https://devfeed.tech/tags/ceph.md>), [deprecated](<https://devfeed.tech/tags/deprecated.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [experimental](<https://devfeed.tech/tags/experimental.md>), [hpc](<https://devfeed.tech/tags/hpc.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [lazy](<https://devfeed.tech/tags/lazy.md>), [linux](<https://devfeed.tech/tags/linux.md>), [linux-7-4](<https://devfeed.tech/tags/linux-7-4.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>), [mount](<https://devfeed.tech/tags/mount.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [page-cache](<https://devfeed.tech/tags/page-cache.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [rados](<https://devfeed.tech/tags/rados.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

Linux 7.4 adds Ceph's `lazyio` mount option to enable lazy I/O globally for regular files at open time; previously, Ceph offered an ioctl to enable it per file. Lazy I/O permits page-cache buffered I/O even when multiple clients have a file open for writing, for workloads such as HPC that can tolerate relaxed cache coherency. Linux 7.4 also makes the deprecated Ceph inline-data feature opt-in through `CEPH_FS_INLINE_DATA`, which defaults off. Users relying on inline data must set `CEPH_FS_INLINE_DATA=Y`; the excerpt says removal of the deprecated code is planned for a future release. The pull request also includes bug fixes and cleanup.

### Source excerpt

The Ceph kernel client changes have been submitted for Linux 7.4 ahead of its merge window expected to wrap up on Sunday...

## PDScope: Breaking the Prefill-Decode Seesaw for Memory-Bound MoE Inference

DevFeed: [PDScope: Breaking the Prefill-Decode Seesaw for Memory-Bound MoE Inference](<https://devfeed.tech/articles/pdscope-breaking-the-prefill-decode-seesaw-for-memory-bound-moe-inference-107581.md>)

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

Author: Enda Yu, Dezun Dong, Zhaoning Zhang, Xiaojian Yang, Weiling Yang, Shaonan Ma, Dongsheng Li, Yongwei Wu, Xiangke Liao

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

Content type: article

Language: en

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

Topics: [Mixture of Experts (MoE)](<https://devfeed.tech/topics/mixture-of-experts-moe.md>), [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>), [Local AI](<https://devfeed.tech/topics/local-ai.md>), [Memory Heirarchy](<https://devfeed.tech/topics/memory-heirarchy.md>), [On-device AI](<https://devfeed.tech/topics/on-device-ai.md>)

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [batch](<https://devfeed.tech/tags/batch.md>), [batching](<https://devfeed.tech/tags/batching.md>), [cache](<https://devfeed.tech/tags/cache.md>), [co-design](<https://devfeed.tech/tags/co-design.md>), [compute](<https://devfeed.tech/tags/compute.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [decode](<https://devfeed.tech/tags/decode.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [execution](<https://devfeed.tech/tags/execution.md>), [experts](<https://devfeed.tech/tags/experts.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [gpu-memory](<https://devfeed.tech/tags/gpu-memory.md>), [graph](<https://devfeed.tech/tags/graph.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [inference](<https://devfeed.tech/tags/inference.md>), [memory](<https://devfeed.tech/tags/memory.md>), [moe](<https://devfeed.tech/tags/moe.md>), [prefill](<https://devfeed.tech/tags/prefill.md>)

### AI overview

PDScope addresses the conflict between prefill and decode in MoE inference when limited GPU memory keeps most experts in CPU memory: prefill benefits from aggressive GPU loading, while decode needs conservative PCIe transfers, and low batching prevents these demands from being amortized. It predicts expert activations and uses phase-specific cost modeling to guide placement, prefetching, and scheduling. A static computation graph, cache prefetching, and zero-copy asynchronous I/O compile these decisions into pipelines. The abstract reports 2.5-10.3x higher prefill throughput and 2.1-6.1x higher decode throughput than existing systems on mainstream MoE models; it provides no further evaluation details.

### Source excerpt

arXiv:2610.39216v1 Announce Type: new Abstract: Local deployment of MoE-based LLMs on CPU-GPU nodes is attractive for cost and privacy reasons, yet limited GPU memory forces most experts into CPU memory. Prefill is then compute-bound and benefits from aggressive GPU loading, while decode is I/O-bound and requires conservative PCIe transfers. These demands cannot be amortized under low batching---typical of local assistants and document tools---forcing phase-agnostic schedulers into a seesaw: favoring prefill's aggressive loading injects unmaskable I/O that stalls decode, while favoring decode's conservative transfers starves prefill's GPU of work. We observe that expert routing is predictable in phase-specific ways, allowing us to decouple the two phases and optimize prediction, scheduling, and execution independently for each phase. PDScope predicts expert activations to guide placement and prefetching, adapts these policies to each phase's bottleneck via cross-layer cost modeling, and compiles decisions into overhead-free pipelines using a static computation graph, cache prefetching, and zero-copy asynchronous I/O. On mainstream MoE models, PDScope achieves 2.5-10.3x higher prefill throughput and 2.1-6.1x higher decode throughput than existing systems, showing that phase-aware co-design unlocks efficient MoE inference under memory constraints and extends naturally to multi-batch settings.

## Express Language Modeling

DevFeed: [Express Language Modeling](<https://devfeed.tech/articles/express-language-modeling-108512.md>)

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

Author: Albert Gong, Annabelle Michael Carrell, Raaz Dwivedi, Lester Mackey

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

Content type: article

Language: en

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

Topics: [context window](<https://devfeed.tech/topics/context-window.md>), [Compression](<https://devfeed.tech/topics/compression.md>), [vllm](<https://devfeed.tech/topics/vllm.md>)

Tags: [approximation](<https://devfeed.tech/tags/approximation.md>), [attention](<https://devfeed.tech/tags/attention.md>), [bottlenecks](<https://devfeed.tech/tags/bottlenecks.md>), [cache](<https://devfeed.tech/tags/cache.md>), [compression](<https://devfeed.tech/tags/compression.md>), [compute](<https://devfeed.tech/tags/compute.md>), [cs-ds](<https://devfeed.tech/tags/cs-ds.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [decoding](<https://devfeed.tech/tags/decoding.md>), [error](<https://devfeed.tech/tags/error.md>), [express](<https://devfeed.tech/tags/express.md>), [flashattention](<https://devfeed.tech/tags/flashattention.md>), [guarantees](<https://devfeed.tech/tags/guarantees.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [kv-cache](<https://devfeed.tech/tags/kv-cache.md>), [language](<https://devfeed.tech/tags/language.md>), [long-context](<https://devfeed.tech/tags/long-context.md>), [math-st](<https://devfeed.tech/tags/math-st.md>), [memory](<https://devfeed.tech/tags/memory.md>), [modeling](<https://devfeed.tech/tags/modeling.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [stat-me](<https://devfeed.tech/tags/stat-me.md>), [stat-ml](<https://devfeed.tech/tags/stat-ml.md>), [stat-th](<https://devfeed.tech/tags/stat-th.md>)

### AI overview

Express converts non-causal attention approximations into causal ones while preserving their approximation guarantees. Paired with Thinformer, it reports approximation error of log³⁄²(n)/s, O(s) memory, and O(s² log²(n)) compression overhead for sequence length n. The authors also describe an I/O-aware Triton implementation with substantial speedups over FlashAttention 2 and apply Express to long-context prefill, KV-cache compression, and long-form decoding under memory or compute constraints. The excerpt does not quantify the speedups or detail the four applications.

### Source excerpt

arXiv:2606.10944v3 Announce Type: replace Abstract: We introduce a new tool, Express, for converting a non-causal attention approximation into a causal approximation with matching approximation guarantees. When combined with the state-of-the-art Thinformer approximation, Express improves upon the best known causal attention guarantees, delivering $\log^{3/2}(n)/s$ approximation error with only $O(s)$ memory and $O(s^2 \log^2(n))$ compression overhead for a sequence of length $n$. We pair these developments with an efficient I/O-aware Triton implementation, demonstrate substantial speedups over FlashAttention 2, and use Express to overcome four resource bottlenecks in the language modeling pipeline: long-context prefill, KV cache compression, long-form memory-constrained decoding, and long-form compute-constrained decoding.

## Redox OS ring buffers project summary

DevFeed: [Redox OS ring buffers project summary](<https://devfeed.tech/articles/redox-os-ring-buffers-project-summary-104705.md>)

Original publisher: [Read original article](<https://lwn.net/Articles/1103359/>)

Author: jzb

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

Content type: news

Language: en

Sources: [LWN.net](<https://devfeed.tech/sources/lwn-net.md>)

Topics: [io\_uring](<https://devfeed.tech/topics/io-uring.md>), [Kernel](<https://devfeed.tech/topics/kernel.md>), [experience report](<https://devfeed.tech/topics/experience-report.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [application](<https://devfeed.tech/tags/application.md>), [applications](<https://devfeed.tech/tags/applications.md>), [async](<https://devfeed.tech/tags/async.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [communications](<https://devfeed.tech/tags/communications.md>), [drivers](<https://devfeed.tech/tags/drivers.md>), [executor](<https://devfeed.tech/tags/executor.md>), [faster](<https://devfeed.tech/tags/faster.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [implement](<https://devfeed.tech/tags/implement.md>), [implementing](<https://devfeed.tech/tags/implementing.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [io-uring](<https://devfeed.tech/tags/io-uring.md>), [liburing](<https://devfeed.tech/tags/liburing.md>), [operating-system](<https://devfeed.tech/tags/operating-system.md>), [os](<https://devfeed.tech/tags/os.md>), [project](<https://devfeed.tech/tags/project.md>), [published](<https://devfeed.tech/tags/published.md>), [ring](<https://devfeed.tech/tags/ring.md>)

### AI overview

Redox OS completed a phase of work on io_uring-like I/O in September, adding system-level ring buffer support for services and compatible drivers as a first step toward application-to-service ring buffer communication. The team also completed and demonstrated an io_uring- and liburing-like application API, developed supporting crates including an async executor for drivers, and made performance improvements aimed at faster switching between applications and system services. The excerpt does not provide implementation details or benchmark results.

### Source excerpt

The Redox OS project, which is a Unix-like microkernel-based operating system written in Rust, has published a report on the work that it has done in the last year to implement io_uring-like I/O. Last year, the Redox team received a grant to develop io_uring-like Ring Buffer support at the system task level, as a first step towards ring buffer communications between the application and the majority of system services. This phase of the work finished up in September, as the last pieces were put in place. [...] In addition to implementing the Ring Buffer machinery for our system services and drivers that can support it, an io_uring and liburing-like API for applications was completed and demonstrated. There was also substantial work done on support crates, including an async executor for drivers. And there was some very exciting work on various performance improvements, to allow much faster switching between applications and their system services. But I will let the team tell you all the technical details.

## IOSage: Detecting HPC I/O Bottleneck Patterns to Guide LLM Recommendations

DevFeed: [IOSage: Detecting HPC I/O Bottleneck Patterns to Guide LLM Recommendations](<https://devfeed.tech/articles/iosage-detecting-hpc-i-o-bottleneck-patterns-to-guide-llm-recommendations-103945.md>)

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

Author: Mahdi Banisharif, Tabassum Mahmud, Ahmad Tarraf, Suren Byna, Ali Jannesari

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

Content type: article

Language: en

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

Topics: [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [AI Models](<https://devfeed.tech/topics/ai-models.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [bottlenecks](<https://devfeed.tech/tags/bottlenecks.md>), [configuration](<https://devfeed.tech/tags/configuration.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-pf](<https://devfeed.tech/tags/cs-pf.md>), [experts](<https://devfeed.tech/tags/experts.md>), [false-positives](<https://devfeed.tech/tags/false-positives.md>), [faster](<https://devfeed.tech/tags/faster.md>), [file](<https://devfeed.tech/tags/file.md>), [file-system](<https://devfeed.tech/tags/file-system.md>), [hpc](<https://devfeed.tech/tags/hpc.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [job](<https://devfeed.tech/tags/job.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llms](<https://devfeed.tech/tags/llms.md>), [logs](<https://devfeed.tech/tags/logs.md>), [median](<https://devfeed.tech/tags/median.md>), [models](<https://devfeed.tech/tags/models.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [recommendations](<https://devfeed.tech/tags/recommendations.md>)

### AI overview

IOSage uses a classifier trained on labeled Darshan logs to identify HPC I/O bottleneck patterns; an LLM then receives those patterns, job configuration files, per-file evidence, and benchmark-derived cards to recommend changes. This differs from systems where the LLM diagnoses bottlenecks from a single log, which lacks a baseline for abnormal behavior. In reported tests, manually applied recommendations improved median total wall time by 4.38x for an openPMD kernel and 1.42x for hourly WRF restarts; Claude Sonnet 4 identified helpful changes in five of six scenarios, including 10-minute WRF restarts. On benchmark runs without detected patterns, classifier gating reduced proposed changes from 64 of 78 to 9. The classifier achieved 0.929 Micro-F1 on 488 benchmark test runs, falling to 0.832 on 158 runs from jobs and configurations outside training. On nine TraceBench production traces, it had 0.82 precision for the five issue labels matching registered patterns.

### Source excerpt

arXiv:2610.36370v1 Announce Type: cross Abstract: HPC applications often leave much of their parallel file system's bandwidth unused, and turning their Darshan logs into concrete I/O fixes still requires a scarce I/O expert. Rule-based tools flag counters against thresholds set by experts, and in tools built on large language models (LLMs), such as ION and IOAgent, the LLM decides which bottlenecks a log contains. We present IOSage, in which a classifier trained on many labeled logs, not the LLM, makes that decision, since a single log gives an LLM no baseline for what is abnormal. The LLM receives the I/O bottleneck patterns the classifier detects, the job's configuration files, per-file Darshan evidence, and for each pattern a card built from benchmark training runs, and writes recommended changes. Applied by hand and measured in repeated paired runs, the changes IOSage names speed up median total wall time 4.38x for an openPMD kernel (4.02x on a second storage tier) and 1.42x for hourly WRF restarts. For 5 of the 6 application scenarios with a helpful change, IOSage with Claude Sonnet 4 names it, including the change for 10-minute WRF restarts (up to 1.93x faster); with GPT-4o and Llama 3.1 as well, the classifier and cards name more helpful changes than the LLM alone. On 78 benchmark test runs without a pattern, the LLM deciding alone proposes changes for 64; with the classifier, for 9. The classifier reaches 0.929 Micro-F1 on 488 labeled benchmark test runs (0.916 as the gate; 0.832 on the 158 from configurations and jobs outside training), above Drishti's rules, WisIO, and IOAgent's pipeline without its literature retrieval. On TraceBench's nine expert-labeled traces from production systems, it has the highest precision of the tools compared (0.82), with 2 false positives against 12 for the keyword-mapped LLM diagnoses shipped with TraceBench and 5 for Drishti, on the five issue labels that match registered patterns.

## Synergy Logic SLM-RP4 - A Raspberry Pi 4 PLC with modular industrial I/O

DevFeed: [Synergy Logic SLM-RP4 - A Raspberry Pi 4 PLC with modular industrial I/O](<https://devfeed.tech/articles/synergy-logic-slm-rp4-a-raspberry-pi-4-plc-with-modular-industrial-i-o-101951.md>)

Original publisher: [Read original article](<https://www.cnx-software.com/2026/10/27/synergy-logic-slm-rp4-a-raspberry-pi-4-plc-with-modular-industrial-i-o/>)

Author: Debashis Das

Published: 2026-10-27T09:00:19Z

Content type: news

Language: en

Sources: [CNX Software - Embedded Systems News](<https://devfeed.tech/sources/cnx-software-embedded-systems-news.md>)

Topics: [Raspberry Pi](<https://devfeed.tech/topics/raspberry-pi.md>), [Modbus](<https://devfeed.tech/topics/modbus.md>), [Bluetooth](<https://devfeed.tech/topics/bluetooth.md>)

Tags: [acquisition](<https://devfeed.tech/tags/acquisition.md>), [automation](<https://devfeed.tech/tags/automation.md>), [bluetooth](<https://devfeed.tech/tags/bluetooth.md>), [broadcom-bcmxxxx](<https://devfeed.tech/tags/broadcom-bcmxxxx.md>), [c-c-plus-plus](<https://devfeed.tech/tags/c-c-plus-plus.md>), [debian](<https://devfeed.tech/tags/debian.md>), [din-rail](<https://devfeed.tech/tags/din-rail.md>), [fanless](<https://devfeed.tech/tags/fanless.md>), [gigabit-ethernet](<https://devfeed.tech/tags/gigabit-ethernet.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [hmi](<https://devfeed.tech/tags/hmi.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [industrial](<https://devfeed.tech/tags/industrial.md>), [industrial-automation](<https://devfeed.tech/tags/industrial-automation.md>), [industrial-iot](<https://devfeed.tech/tags/industrial-iot.md>), [iot](<https://devfeed.tech/tags/iot.md>), [linux](<https://devfeed.tech/tags/linux.md>), [modbus](<https://devfeed.tech/tags/modbus.md>), [modular](<https://devfeed.tech/tags/modular.md>), [plc](<https://devfeed.tech/tags/plc.md>), [python](<https://devfeed.tech/tags/python.md>), [raspberry-pi](<https://devfeed.tech/tags/raspberry-pi.md>), [raspberry-pi-4](<https://devfeed.tech/tags/raspberry-pi-4.md>), [raspberry-pi-os](<https://devfeed.tech/tags/raspberry-pi-os.md>), [scada](<https://devfeed.tech/tags/scada.md>), [spi](<https://devfeed.tech/tags/spi.md>), [video](<https://devfeed.tech/tags/video.md>), [wifi-5](<https://devfeed.tech/tags/wifi-5.md>)

### AI overview

The Synergy Logic SLM-RP4 is a DIN-rail Raspberry Pi 4 PLC with a built-in SPI backplane for up to eight SLM modules and 128 I/O points. Its modules cover digital and relay I/O, analog signals, and thermocouples; they connect without inter-module cables, but are not hot-swappable. It runs Raspberry Pi OS with OpenPLC Runtime and supports IEC 61131-3 programming, plus Python and C++ function blocks. The backplane allows configurable 1-1000 ms scan intervals (10 ms by default) and can stop PLC execution and reset outputs after excessive communication errors. Python and C++ libraries can control the backplane without OpenPLC, but cannot be used alongside it. The controller also includes a hardware watchdog and documentation for FUXA dashboards over Modbus TCP. It is listed at $249, with I/O modules sold separately.

### Source excerpt

Synergy Logic SLM-RP4 industrial PLC is built around a Raspberry Pi 4 SBC and designed for industrial automation, machine control, data acquisition, and Industrial IoT (IIoT) applications. The DIN-rail mountable controller supports 24V DC input and an SPI-based backplane that connects up to eight Synergy Logic I/O modules, providing up to 128 I/O points. It also features Gigabit Ethernet, WiFi 5, Bluetooth 5.0, USB ports, two micro-HDMI outputs, and a fanless aluminum enclosure. The system runs Raspberry Pi OS with OpenPLC pre-installed for standard IEC 61131-3 logic programming. Synergy Logic SLM-RP4 specifications: SBC - Raspberry Pi 4 Model B (2GB RAM) Storage - 16GB microSD card Video - 2x micro-HDMI ports Audio - 3.5mm audio jack Networking Gigabit Ethernet port Dual-band WiFi 5 (802.11ac) Bluetooth 5.0/BLE USB 2x USB 3.0 Type-A ports 2x USB 2.0 Type-A ports 1x USB-C port for auxiliary power I/O Expansion - SPI-based backplane supporting up [...] The post Synergy Logic SLM-RP4 - A Raspberry Pi 4 PLC with modular industrial I/O appeared first on CNX Software - Embedded Systems News.

## CVM-Store: A Secure Storage System for Confidential Virtual Machines

DevFeed: [CVM-Store: A Secure Storage System for Confidential Virtual Machines](<https://devfeed.tech/articles/cvm-store-a-secure-storage-system-for-confidential-virtual-machines-101431.md>)

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

Author: Thore Sommer, Masanori Misono, Dimitrios Stavrakakis, Pramod Bhatotia

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

Content type: article

Language: en

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

Topics: [Confidential Computing](<https://devfeed.tech/topics/confidential-computing.md>), [virtual machines](<https://devfeed.tech/topics/virtual-machines.md>), [systems](<https://devfeed.tech/topics/systems.md>), [virtualization](<https://devfeed.tech/topics/virtualization.md>)

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [batching](<https://devfeed.tech/tags/batching.md>), [cloud-infrastructure](<https://devfeed.tech/tags/cloud-infrastructure.md>), [cloud-workloads](<https://devfeed.tech/tags/cloud-workloads.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [data-protection](<https://devfeed.tech/tags/data-protection.md>), [encryption](<https://devfeed.tech/tags/encryption.md>), [filesystem](<https://devfeed.tech/tags/filesystem.md>), [high-performance](<https://devfeed.tech/tags/high-performance.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [kvs](<https://devfeed.tech/tags/kvs.md>), [nvme](<https://devfeed.tech/tags/nvme.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [rollback](<https://devfeed.tech/tags/rollback.md>), [semantics](<https://devfeed.tech/tags/semantics.md>), [storage](<https://devfeed.tech/tags/storage.md>), [system](<https://devfeed.tech/tags/system.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [virtual-machines](<https://devfeed.tech/tags/virtual-machines.md>)

### AI overview

CVM-Store extends confidential virtual machines' protection to persistent storage by combining a high-throughput userspace I/O engine with confidentiality, integrity, and freshness (CIF) protections. It interleaves I/O and authenticated encryption to avoid redundant copies and OS or hypervisor mediation, and offers composable protections tailored to access patterns through a key-value store, log, and filesystem. An asynchronous trusted counter service batches epochs to provide rollback protection without dedicated hardware support. For large objects, the abstract reports full CIF guarantees at about 1% of raw NVMe bandwidth for writes and 1-19% for reads.

### Source excerpt

arXiv:2610.34560v1 Announce Type: new Abstract: Stateful cloud workloads require high-performance persistent storage when running on untrusted cloud infrastructure. Confidential Virtual Machines (CVMs) promise to protect these workloads through hardware-enforced memory encryption and isolation without requiring application changes. However, they protect only data in use; persistent storage lies outside the CVM trust boundary, exposing all stateful data to the cloud provider. Extending the trust boundary to persistent storage presents inherent challenges. High-bandwidth workloads require near-raw NVMe throughput, yet the default kernel CVM I/O stacks are inadequate, and userspace I/O libraries are not designed with CVM use cases in mind. Access patterns and storage semantics vary between workloads, necessitating access-pattern-aware security abstractions rather than uniform block-level encryption. In order to mitigate against rollback, freshness is needed, but CVMs lack hardware primitives for this purpose, requiring alternative solutions. We present CVM-Store, a storage system that co-designs a high-throughput userspace I/O engine with CIF (confidentiality, integrity, freshness) data protection. The key insight is that neither authenticated encryption nor I/O is a bottleneck by itself, but their naive combination is. CVM-Store exploits this by interleaving them, eliminating redundant copies and OS/hypervisor mediation. CIF guarantees are provided as composable primitives that adapt protection to workload access patterns, from which we derive three concrete authenticated abstractions: a KVS, a log, and a filesystem. An asynchronous trusted counter service provides freshness guarantees with epoch-based batching, which enables rollback protection without dedicated hardware support. CVM-Store delivers full CIF guarantees within $\approx$1% (write) and 1-19% (read) of raw NVMe bandwidth for large objects.

## Approaching I/O-optimality for Approximate Attention

DevFeed: [Approaching I/O-optimality for Approximate Attention](<https://devfeed.tech/articles/approaching-i-o-optimality-for-approximate-attention-99414.md>)

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

Author: P\\'al Andr\\'as Papp, Aleksandros Sobczyk, Anastasios Zouzias

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

Content type: article

Language: en

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

Topics: [Transformer](<https://devfeed.tech/topics/transformer.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [attention](<https://devfeed.tech/tags/attention.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [computer-science](<https://devfeed.tech/tags/computer-science.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [flashattention](<https://devfeed.tech/tags/flashattention.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [large-language-models](<https://devfeed.tech/tags/large-language-models.md>), [lower-bound](<https://devfeed.tech/tags/lower-bound.md>), [lower-bounds](<https://devfeed.tech/tags/lower-bounds.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [matrices](<https://devfeed.tech/tags/matrices.md>), [matrix](<https://devfeed.tech/tags/matrix.md>), [memory](<https://devfeed.tech/tags/memory.md>), [neurips](<https://devfeed.tech/tags/neurips.md>)

### AI overview

The paper proposes I/O-efficient algorithms for approximate attention that reduce data-transfer dependence on context length from quadratic to almost linear, building on Alman and Song's method. It also gives algorithm-specific lower bounds across parameter regimes that nearly match the corresponding upper bounds, suggesting the algorithms are close to I/O-optimal. The supplied evidence is an abstract and does not specify the algorithms' precise costs or regimes.

### Source excerpt

arXiv:2605.23751v2 Announce Type: replace Abstract: We revisit the I/O complexity of attention in large language models. Given query-key-value matrices $Q,K,V\in\mathbb{R}^{n\times d}$, and a machine with fast memory size $M$, the goal is to compute the "attention matrix" $A=\text{softmax}(Q K ^{\top}/\sqrt{d}) V$ with the minimal number of data transfers between fast and slow memory. Existing methods in the literature, most notably FlashAttention and its variants, incur an I/O cost that depends quadratically on the context length $n$, while a trivial lower bound only requires $\Omega(nd)$ I/O's to read the inputs and write the output. In this work we show that the dependence on $n$ can be reduced to almost-linear, by developing I/O-efficient algorithms inspired by the recent approximate attention method of Alman and Song [NeurIPS'23]. We also provide (algorithm-specific) lower bounds in different parameter regimes, which nearly match the corresponding upper bounds, indicating that the proposed algorithms are indeed close to I/O-optimal.

[Next page](<https://devfeed.tech/tags/i-o.md?cursor=WyIyMDI2LTEwLTI2VDA0OjAwOjAwKzAwOjAwIiwgIjJkNjZjZjhiLTVkNDQtNDc5Yi05MWYwLWNmYmM5YWRmMjg0MSJd>)