Hasty Briefsbeta

All tags

#performance optimization

19 stories total

Bilingual

Hanami 3.0: In Full Bloom
20 days ago
- Hanami 3.0 introduces major features: first-class mailers with integrated email delivery and templates, built-in internationalization (i18n) for translations and localization, and Minitest support alongside existing RSpec.
- Performance improvements include default component memoization, reducing allocations by up to 80% and increasing throughput by nearly 3x, plus optimizations in Hanami Action and View.
- Enhancements to developer experience: colorized logs, improved asset watching, body parsing integrated into Hanami Action, undecorated view exposures by default, and a cleaner foundation with renamed gems.
- Additional refinements: new generators (provider, mailer), options for app generation (--test, --template-engine), updated dependencies (Ruby 3.3+, Puma 7.1), and various fixes for routing and templates.
- Easy setup with commands to install and run Hanami 3.0, plus upgrade notes for existing 2.3 users, supported by contributions from the community and sponsors.
Database Traffic Control
21 days ago
- Postgres lacks built-in traffic management, making it vulnerable to performance degradation or crashes during query spikes.
- PlanetScale introduces Database Traffic Control™, enabling real-time resource budgeting and limits for queries via rules like query patterns, application names, users, and custom tags.
- Traffic Control allows setting limits on CPU, concurrency, and query timing, with modes for warning or enforcement to throttle or block excessive queries.
- Use cases include incident response for rogue queries, priority-based traffic shaping, isolating AI agent traffic, and prioritizing paid tiers in multi-tenant apps.
- Available via PlanetScale dashboard, API, and CLI, it supports automated budget creation and sqlcommenter tags for enhanced traffic categorization.
NUMA: Cores, memory, and the distance between them
a month ago
- NUMA (Non-Uniform Memory Access) means memory access costs vary depending on CPU and memory bank locations, unlike UMA (Uniform Memory Access).
- NUMA emerged to scale beyond single-socket limits, with each socket having its own memory controller and interconnects like AMD's HyperTransport/Infinity Fabric and Intel's QPI/UPI.
- Modern servers can have multiple NUMA nodes per socket due to designs like AMD's EPYC with chiplets and Intel's Sub-NUMA Clustering, moving beyond the 'one socket, one node' model.
- Remote memory access on modern servers is 1.5x to 3x slower than local access in microbenchmarks, worsening under load due to interconnect contention, affecting tail latency.
- Memory interleaving spreads memory across nodes to flatten costs but sacrifices peak performance for predictability, making 'everything equally bad'.
- NUMA involves two affinities: CPU affinity (pinning processes to CPUs) and memory affinity (controlling memory allocation per node), which must align for optimal performance.
- Linux's 'first touch' policy allocates memory on the node of the CPU that first accesses it, which can cause remote accesses if allocation and usage threads are on different nodes.
- Xen's dom0 lacks NUMA awareness, leading to mismatches between guest vCPUs and memory placement, silently causing cross-interconnect access and performance issues.
- Virtualized systems like Xen have two stacks (hypervisor and guest) making separate placement decisions, unlike KVM where the host Linux kernel manages NUMA for VMs.
- Edera's work makes Xen NUMA-aware end-to-end, allowing guests to see accurate topology and optimize placement, avoiding the 'blind and interleave' dilemma.
Superpowers 6
21 days ago
- Superpowers 6 offers significant performance improvements: builds are up to 50% faster and up to 60% cheaper in token costs.
- Key optimizations include merging spec compliance and code quality review agents, pre-generating review packets to reduce git commands, and improving task-specific agent guidance.
- The improvements were validated through an autoresearch loop with 25 experiments, identifying effective strategies like terse reviewer contracts and conditional implementer tiering.
- The evals suite at https://github.com/prime-radiant-inc/superpowers-evals was crucial for testing changes across various coding agents and harnesses.
- Superpowers 6 is available for installation from https://github.com/obra/superpowers, with updates to plugin marketplaces following soon.
- Prime Radiant is hiring for a Superpowers Community Engineer role at https://primeradiant.com/jobs/superpowers-community-engineer/.
CachyOS June 2026 Release
22 days ago
- CachyOS June 2026 release introduces Hyprland Noctalia desktop, DNS-over-QUIC support, and performance improvements.
- Package updates include Python extended PGO for better performance, GCC branch misprediction tuning for Intel/AMD CPUs, and pacman network isolation.
- Installer now features Hyprland Noctalia with a preview video, removed paru in favor of Shelly, and improved hardware/keyboard detection.
- CachyOS-Welcome adds DNS-over-QUIC via blocky, a troubleshooting page, terminal support, and new localizations including Azerbaijani and Greek.
- Fixes cover installer handling of keyboard layouts, pacman config, cleanup steps, and crashes in CachyOS-Welcome when cachyos-pi is missing.
- Manual updates not required; users can update with sudo pacman -Syu and download ISOs from provided mirrors for desktop and handheld editions.
How we made WINDOW JOIN parallel and vectorized
a month ago
- QuestDB introduced a dedicated WINDOW JOIN operator to efficiently aggregate one table over a time window around each row of another, simplifying complex SQL queries that previously required multiple joins and unions.
- The operator achieves high performance through data-level parallelism, where the left-hand side (LHS) table is split into page frames processed by worker threads, and a low-cardinality fast path that enables SIMD vectorized aggregation.
- Key optimizations include building per-key indexes and contiguous value buffers for RHS data, allowing binary searches for window bounds and efficient SIMD kernels for aggregates like sum, avg, min, and max.
- Benchmarks against Timescale, DuckDB, and ClickHouse on a 50M-row trades and 150M-row prices dataset showed QuestDB's parallel + SIMD implementation running 5x faster than its single-threaded version and 25x faster than ClickHouse's best rewrite.
- The WINDOW JOIN operator supports various configurations, including one-sided windows, include/exclude prevailing rows, and multiple aggregate functions, with plans to expand temporal operators like HORIZON JOIN in future releases.
JPEG-XL Libjxl 0.12 Brings More Performance Optimizations
18 days ago
- libjxl 0.12 release improves JPEG-XL image format performance and features.
- Includes new jxltran tool for extracting codestreams from JXLP boxes.
- Progressive lossless images are 30~40% smaller and encode 2-5x faster with multi-threading.
- Lossless images decode faster and are 30~80% smaller overall.
- SIMD optimizations boost encoding, with EstimateCost SIMDified for 5% improvement.
- Modular encoding/decoding up to 4x faster via SIMD, and histogram encoding/decoding overhauled.
Girls Just Wanna Have Fast MPMC Queues with Bounded Waiting
15 days ago
- The post presents a wait-free (bounded waiting) MPMC queue design based on a ticket lock system.
- The queue uses atomic counters for producers and consumers, with separate data and state buffers.
- Operations avoid CAS loops, minimizing cache contention and head-of-line blocking.
- Bounded waiting is ensured unless threads are suspended or fail, preventing starvation.
- Drivable enqueue/dequeue operations allow non-blocking polling for async/event loop integration.
- A rare race condition risk exists at high reservation number overflow boundaries (e.g., 2^63+1).
- Benchmarks show good scalability with multiple producers/consumers, though performance varies by core count.
Pg_re2: Postgres extension for fast, RE2-powered regular expressions in Postgres
12 days ago
- ClickHouse introduces pg_re2, a Postgres extension for fast RE2-powered regular expressions, emphasizing speed and compatibility.
- RE2 uses finite automata for faster, more predictable performance compared to Postgres's backtracking POSIX regex, with benchmarks showing 1.8x to 8.6x speedups.
- pg_re2 adds index support (@~ operator) with btree and GIN indexes, providing 1.1x to 1.8x acceleration and better trigram handling for patterns.
- Compatibility with ClickHouse regex functions is key, as pg_re2 addresses syntax differences (e.g., \b meaning word boundary vs. backspace) to ensure consistent results when using pg_clickhouse.
- pg_re2 functions push down to ClickHouse, eliminating discrepancies and improving performance for analytical queries, and is recommended for a unified high-performance data platform.
We scaled PgBouncer to 4x throughput
10 days ago
- PgBouncer is single-threaded, using only one CPU core even on multi-core systems, which can bottleneck throughput.
- In ClickHouse Managed Postgres, multiple PgBouncer processes are run, scaled to available cores, using so_reuseport for kernel load balancing.
- Query cancellation is addressed via peering: processes forward cancel requests to the correct session owner, ensuring functionality across the fleet.
- Transaction mode pooling returns server connections after commits, with connection budgets split across processes to avoid oversubscribing Postgres.
- Performance tests show a fleet of 16 processes achieves ~336k TPS (4x higher) and utilizes ~8 cores, while a single process peaks at ~87k TPS and uses only one core.
- A single PgBouncer suffices at low concurrency, but under high load, multi-process fleets prevent the pooler from becoming a bottleneck.
Migrating a production AI agent to GPT-5.6: 2.2x faster, 27% cheaper
9 days ago
- Ploy's agent now uses GPT-5.6 Sol as the default model, replacing Claude Opus after it performed better in quality, speed (2.2x faster), and cost (27% cheaper).
- Migrating to GPT-5.6 required fixing evaluation harness biases, tool call schemas (to handle optional parameters), prompt caching (workspace-scoped keys), and reasoning replay (self-contained blobs).
- GPT-5.6 excels at clean, modern designs but can be generic without guidance; tool call verbosity initially caused empty file reads, resolved via schema transforms.
- Prompt caching differences between providers significantly impacted costs; OpenAI's model requires explicit keys per workspace for effective cache hits.
- The model shows promise with lean code output and improved visual scores, but configuration adjustments are crucial for fair performance and cost comparisons.
Lobste.rs is now running on SQLite
8 days ago
- SQLite migration was successfully deployed on Saturday, with positive results including reduced CPU and memory usage, faster site performance, and lower VPS costs.
- The migration project was initiated due to concerns about MariaDB's future after K1's acquisition, with initial plans to move to PostgreSQL but ultimately choosing SQLite for pragmatism and simplicity.
- Multiple pull request attempts were made, with a failed first deploy due to performance issues from full table scans and n+1 queries, which were fixed in subsequent attempts.
- A successful second deploy occurred on July 11th, after thorough testing and fixes, with the site handling Monday traffic spikes well and minor issues promptly addressed.
- Key lessons included SQLite's concurrency model (multiple readers, single writer via WAL mode), the importance of performance tuning, and the benefits of using simpler solutions like SQLite over more complex databases like PostgreSQL.
- Backup strategy involves a nightly job using restic, and deployment uses Hatchbox with Capistrano for zero-downtime updates, leveraging SQLite's local file system and WAL mode for concurrent access.
- Community contributions were acknowledged, and the migration is seen as a step toward ensuring the site's long-term sustainability, with SQLite proving suitable for the site's needs despite initial skepticism about concurrency.
Lobste.rs is now running on SQLite
7 days ago
- SQLite deployment completed successfully with improved performance and reduced costs.
- Migration process involved multiple PR attempts and performance fixes.
- Lessons learned include SQLite's concurrency model and backup strategies.
- Community collaboration and healthy expectations contributed to the project's success.
- SQLite chosen over PostgreSQL for simplicity and meeting project needs.
Count the Bytes, Not the FLOPs
7 days ago
- The article describes how tsbootstrap's batched design, which materialized a large intermediate tensor (160 MB for 10,000 observations and 2,000 replicates), caused memory-bound performance issues due to low arithmetic intensity, leading to slower performance than the incumbent library.
- A fused, streaming path was implemented using kernel fusion to avoid materializing the full replicate tensor, reducing memory traffic by keeping the working set in cache and only storing the final statistics (e.g., 16 kB instead of 160 MB).
- A second performance wall was addressed by eliminating O(B) seed object allocations through a counter-based random number generator (Philox-4x32-10), reducing setup time from 13.1 ms to 0.55 ms for small workloads and ensuring bitwise reproducibility.
- The redesign achieved speedups of 3.1x to 20x on sustained workloads compared to the incumbent, with the fused path winning all 16 benchmark cells, though the materializing path still remains slower.
- Key principles: never materialize arrays only consumed by reductions, fuse operations to minimize memory traffic, and derive state rather than carrying it, leading to significant performance gains through subtraction rather than addition of complexity.
Just Use Postgres for Job Queues
5 days ago
- Scaling Postgres-backed job queues is challenging but possible with optimizations.
- SKIP LOCKED helps solve contention by allowing workers to lock and skip already locked rows.
- Adjusting transaction isolation levels from REPEATABLE READ to READ COMMITTED reduces serialization failures.
- Optimizing indexes, such as using selective and partial indexes, cuts CPU usage and improves performance.
We rewrote our custom visualisation renderers from SVG to be in Canvas
5 days ago
- The new profiler dashboard replaces SVG with Canvas for rendering flame graphs, eliminating the need for DOM nodes per frame and reducing browser workload.
- Canvas uses an immediate-mode API, where drawing commands create pixels directly, avoiding style, layout, and garbage collection overhead associated with retained-mode SVG.
- Data is handled via columnar Arrow format over Arrow Flight, enabling zero-copy reads and efficient rendering by accessing arrays for frame attributes like x-positions, widths, and depths.
- Rendering optimizations include viewport culling to draw only visible frames and precomputed positions, making zooming, scrolling, and resetting interactions feel instant.
- Performance improvements show the Canvas renderer is about 3.6× faster in isolated tests, with live interactions like zooming and scrolling becoming 4-5 times quicker, though accessibility and text selection remain trade-offs.
Zero-dependency streaming tar parser and writer for JavaScript
3 days ago
- The NPM ecosystem suffers from legacy dependencies, which slow down applications, increase install times, and expand the attack surface for supply chain attacks.
- e18e.dev is a movement to modernize the ecosystem by promoting cleaner, more efficient libraries like modern-tar, a zero-dependency, standards-compliant TAR parser.
- The architecture of modern-tar decouples parsing logic from I/O, using a pure, synchronous state machine that works across runtimes, including browsers and Node.js.
- A zero-copy ring buffer minimizes memory allocations and garbage collector pressure by storing references to incoming data rather than copying it.
- To handle concurrency and security, modern-tar uses a path-caching mechanism with promise chains, enabling parallel processing while maintaining strict sequential order and preventing vulnerabilities like TOCTOU.
- Benchmarks show modern-tar is 1.4x faster than node-tar and 2.6x faster than tar-fs for archives with many small files, while being stable, actively maintained, and widely adopted in the industry.
Refs: Mutable Arrays in jax
2 days ago
- JAX Arrays are immutable, aiding optimized compilation but can limit expressiveness and performance for tasks like memory control.
- Refs are mutable arrays compatible with JAX transformations like jit and grad, allowing in-place reads and writes via indexing.
- Refs have constraints: they cannot be returned from jit functions, passed multiple times, or used in vmap with closed-over refs.
- Automatic differentiation works with pure functions using Refs internally, and ref arguments can be used for gradient accumulation via vjp.with_refs.
- Refs support in-place updates, enabling efficient gradient accumulation over microbatches without materializing separate arrays.
- foreach decorator uses Refs to write flexible loops with non-sequential access, avoiding scan's fixed pattern for better performance.
SPIR-V on ROCm: A Portable IR for AMD GPUs
19 hours ago
- ROCm adopts SPIR-V as a portable intermediate representation for AMD GPUs, enabling compile-once, specialize-on-device model to replace ahead-of-time per-target compilation.
- SPIR-V addresses scalability issues: eliminates long build times, large fat binaries, and lack of forward compatibility associated with AOT-per-target approach, allowing single binary to run on future GPU architectures.
- Key feature is late-resolved feature predicates (ZCFS), which enable per-arch dispatch without runtime overhead via builtins like __builtin_amdgcn_processor_is and __builtin_amdgcn_is_invocable.
- Benchmark shows SPIR-V provides flat build time and binary size regardless of target count, while fat binaries scale linearly; first-launch JIT latency (~70-100 ms) is mitigated by caching.
- Current status includes shipping amdgcnspirv target and JIT caching; in-flight developments include in-tree LLVM SPIR-V backend and JIT-at-package-install; library coverage remains a limitation.

firstprev0next

About|Login

#performance optimization

Hanami 3.0: In Full Bloom

Database Traffic Control

NUMA: Cores, memory, and the distance between them

Superpowers 6

CachyOS June 2026 Release

How we made WINDOW JOIN parallel and vectorized

JPEG-XL Libjxl 0.12 Brings More Performance Optimizations

Girls Just Wanna Have Fast MPMC Queues with Bounded Waiting

Pg_re2: Postgres extension for fast, RE2-powered regular expressions in Postgres

We scaled PgBouncer to 4x throughput

Migrating a production AI agent to GPT-5.6: 2.2x faster, 27% cheaper

Lobste.rs is now running on SQLite

Lobste.rs is now running on SQLite

Count the Bytes, Not the FLOPs

Just Use Postgres for Job Queues

We rewrote our custom visualisation renderers from SVG to be in Canvas

Zero-dependency streaming tar parser and writer for JavaScript

Refs: Mutable Arrays in jax

SPIR-V on ROCm: A Portable IR for AMD GPUs