Hasty Briefsbeta

All tags

#performance

528 stories total

Bilingual

Show HN: Nue – Apps lighter than a React button
a year ago
- Nue is a lightweight web framework focused on modern web standards (HTML, CSS, JS).
- It outperforms React/ShadCN in size — an entire app is lighter than a React button.
- Supports large-scale apps with Rust computation engine and Event Sourcing for 150k+ records.
- Offers ultra-fast HMR and build speeds with millisecond feedback loops.
- Targets Rust, Go, and JS engineers by promoting modular design, static typing, and minimal dependencies.
- Empowers design engineers with modern CSS (@layers, variables) for simpler systems.
- Helps UX engineers escape React hooks and utility classes for lighter, faster apps.
- Aims to reduce hidden complexity in web development and restore joy in building.
Measuring Acceleration Structures
a year ago
- Hardware accelerated raytracing relies on acceleration structures (BVH/BLAS) for scene geometry, with varying memory layouts across vendors.
- Experimental setup uses Amazon Lumberyard Bistro scene, measuring BLAS sizes across different GPUs (AMD, NVIDIA, Intel).
- Results show significant variance in BLAS memory consumption, with NVIDIA leading efficiency (e.g., RTX 5070 at 18.8 bytes/triangle).
- AMD's RDNA4 introduces new BVH node formats (BVH8, primitive nodes) to reduce memory usage, achieving ~48 bytes/triangle.
- Driver optimizations (e.g., AMDVLK updates) have progressively improved BLAS memory efficiency over time.
- BVH structures balance memory and traversal performance, with trade-offs in node branching factors and triangle compression.
- Future improvements may further reduce BVH sizes, especially on newer GPU architectures like RDNA4 and NVIDIA's 5xxx series.
C and C++ prioritize performance over correctness (2023)
a year ago
- C and C++ prioritize performance over correctness, leading to undefined behaviors that can break programs unexpectedly.
- Examples include uninitialized variables, arithmetic overflow, infinite loops, and null pointer usage, where compilers optimize based on undefined behavior assumptions.
- The C++ standards committee has resisted defining behaviors like signed integer overflow to maintain optimization potential, despite correctness concerns.
- Undefined behaviors in C and C++ have shifted from being non-portability issues to optimization opportunities, impacting debuggability and correctness.
- The trade-off between performance and correctness in C and C++ is clear, with performance often prioritized even at the cost of program stability and security.
Growing Buffers to Avoid Copying Data
a year ago
- Johnny’s Software Lab LLC specializes in software performance optimization.
- Avoiding data copying is crucial for performance, especially in C++ and operating system contexts.
- C++ lacks a built-in realloc function, complicating buffer resizing without copying.
- A proposed resize_buffer function could help avoid unnecessary data copying in C++.
- Linux uses mmap and mremap for memory allocation and resizing, requiring careful address management.
- Windows lacks mremap but can use VirtualAlloc for similar purposes, though with more manual management.
- jemalloc offers xallocx for buffer resizing, a feature not present in standard C libraries.
- Experiments show significant performance gains when avoiding data copying during buffer resizing.
- Potential issues include system-specific behaviors, silent failures, and virtual memory fragmentation.
- Despite challenges, avoiding data copying is beneficial for performance in certain scenarios.
Span<T>.SequenceEquals is faster than memcmp
a year ago
- Examining portability issues when migrating from .NET Framework 4.8.1 to .NET 8.
- Discovery of msvcrt.dll usage for fast byte array comparison in .NET.
- Introduction of Span<T> in modern .NET for type-safe and memory-safe contiguous memory representation.
- Performance comparison between memcmp, Span<T>.SequenceEqual, naive loop, and Enumerable.SequenceEqual.
- Benchmark results showing Span<T>.SequenceEqual outperforming memcmp in .NET 8 and .NET 9.
- Notable performance regression in .NET 9 for 1GB arrays, requiring further investigation.
- Recommendation to use IEnumerable<T>.SequenceEqual in .NET 8 for high performance without external dependencies.
- Advice to use Span<T>.SequenceEqual in .NET Framework for better performance.
- Suggestion to use order-sensitive hash for frequently compared large arrays to avoid expensive comparisons.
- Source code available on GitHub for further exploration and contributions.
Towards fearless SIMD, 7 years later
a year ago
- Rust's SIMD programming experience remains challenging despite progress, with all SIMD intrinsics marked as unsafe due to varying CPU support.
- Linebender projects are beginning to adopt SIMD for CPU/GPU hybrid rendering, color conversion, and 2D geometry primitives to maximize performance.
- Multiversioning is crucial for SIMD to handle different CPU capabilities, with approaches like the 'multiversion' crate and 'pulp' library being explored.
- Safety improvements are in progress, including proposals to make SIMD intrinsics safe under certain conditions and better runtime feature detection.
- Emerging trends like FP16 and AVX-512 are influencing SIMD development, with FP16 offering benefits for pixel values and AVX-512 introducing predication for efficient string operations.
- The 'std::simd' portable SIMD effort is ongoing but may not fully address the need for target-specific optimizations and multiversioning.
- Language evolution proposals aim to enhance Rust's SIMD support, making it safer and more ergonomic for developers.
- The goal is to foster community discussion and development of Rust's SIMD infrastructure to compete with solutions like Highway in C++.
Let's Take a Look at JEP 483: Ahead-of-Time Class Loading and Linking
a year ago
- JEP 483 introduces Ahead-of-Time (AOT) Class Loading & Linking to reduce Java application start-up times without code modifications.
- Part of Project Leyden, JEP 483 builds on Application Class Data Sharing (AppCDS) by also loading and linking classes ahead of time.
- A training run is required to create an AOT cache file, ensuring all necessary classes are loaded for optimal performance.
- Testing with Apache Kafka showed a 59% reduction in start-up time using AOT caching.
- Apache Flink also benefited, with a 51% reduction in time-to-first-message for a simple job.
- AOT caching is particularly useful for cloud-native scenarios, CLI tools, and testing environments where start-up times matter.
- GraalVM offers more advanced AOT compilation with faster start-up times but requires code adjustments and lacks Java's dynamism.
- Project Leyden aims for a middle ground between GraalVM's constraints and Java's full dynamism, with future JEPs planned for AOT compilation and method profiling.
Thoughts on ECS
a year ago
- ECS (Entity Component System) is a model where entities are unique identifiers with attachable components (data structs), and systems implement logic operating on these components.
- ECS is often promoted for performance benefits due to data locality and cache coherency, but real-world use cases may involve multiple components leading to scattered memory access.
- Alternatives to ECS include shallow class hierarchies, composition, and scripting, which avoid deep inheritance issues without requiring ECS.
- ECS performance claims are nuanced; while it can improve data locality, accessing multiple components can lead to cache misses, and dynamic composition (e.g., archetypes) introduces complexity and overhead.
- ECS excels in data-driven design, allowing runtime composition of behaviors, but may require boilerplate components and has limitations in true mix-and-match flexibility.
- Debugging ECS can be challenging due to indirection and dynamic memory layouts, complicating visualization and inspection.
- Pros of ECS: dynamic runtime composition, framework for cold/optional data, and enforced data-oriented design.
- Cons of ECS: added complexity, performance overhead from lookups, and debugging difficulties.
- A simpler alternative to ECS involves static entity types with composition, offering explicit control, better debugging, and optional cold data handling without full ECS complexity.
- ECS is best suited for data-driven, generic engines requiring runtime flexibility, while simpler approaches may suffice for most game development needs.
Show HN: Benchi – A benchmarking tool written in Go
a year ago
- Benchi is a minimal benchmarking framework leveraging Docker for isolated environments.
- Features include Docker integration, metrics collection in CSV, custom hooks, and progress monitoring.
- Installation options include using Go or a Linux binary via curl.
- Benchmarks are configured via YAML files, with Docker Compose for infrastructure and tools.
- Metrics collectors support Conduit, Docker, Kafka, and Prometheus for various performance metrics.
- Test configurations allow for pre/post infrastructure and tool commands, with concurrent during-test commands.
- Output includes logs and aggregated metrics, with results stored in timestamped folders.
- Common issues include Docker daemon connectivity problems, with solutions provided.
- Licensed under Apache License 2.0.
Is Python Code Sensitive to CPU Caching? (2024)
a year ago
- Cache-aware programming impacts performance in Python, despite its high-level nature.
- Experiments show random access in Python lists is slower than sequential access, especially with large datasets exceeding CPU cache sizes.
- Linear access maintains consistent performance, while random access slows down significantly as data grows beyond cache limits.
- Numpy arrays demonstrate reduced cache pressure and faster performance compared to vanilla Python lists due to dense data packing.
- Cache effects in Python can lead to performance differences of up to 280% between sequential and random access patterns.
Show HN: uWrap.js – A faster and more accurate text wrapping util in < 2KB
a year ago
- uWrap is a fast and accurate text wrapping utility for UI performance optimization in large, scrollable datasets.
- It outperforms canvas-hypertxt in CPU and memory usage while being more accurate.
- Currently works best with Latin charsets and supports the pre-line wrapping strategy.
- Does not handle Windows-style \r\n line breaks yet.
- Benchmarks show significant performance improvements over canvas-hypertxt across browsers.
- Easy to install via npm or script tag, with a simple TypeScript definition.
- Provides utility functions for counting lines, testing if text will wrap, and splitting text into lines.
Drag Racers Are Ditching Superchargers for Scuba-Style Tanks and Compressed Air
a year ago
- Compressed Air Supercharging (CAS) is an emerging technology in drag racing, replacing traditional turbos and superchargers.
- CAS force-feeds oxygen into the engine without requiring horsepower or exhaust air, providing extremely cold and dense air for power.
- The system uses carbon fiber tanks storing air at 3,300 psi, with a computer-controlled setup allowing adjustable boost levels (typically around 10 psi).
- Benefits include lower engine stress due to cooler, denser air and compatibility with lower-octane fuels like 91 pump gas.
- CAS is particularly effective in automatic cars with transmission brakes, engaging boost just before launch for immediate power.
- Notable users include racers Tina and Dave Pierce, who achieve 1,600 horsepower in their Chevy Colorado, and Ryan Mitchell with his Firebird.
- Refilling the air tanks requires specialized equipment, not a regular shop compressor.
- While still niche, CAS has potential to challenge traditional power adders in drag racing.
Faster interpreters in Go: Catching up with C++
a year ago
- Vitess replaced its AST-based SQL evaluation engine with a Virtual Machine (VM) written in Go, achieving performance comparable to MySQL's C++ implementation.
- The new VM is not only faster but also easier to maintain, despite being orders of magnitude more efficient.
- Vitess's evaluation engine supports complex SQL expressions that cannot be executed directly in MySQL, ensuring compatibility and accuracy.
- The VM uses static typing derived from semantic analysis, allowing for specialized bytecode without runtime type checks.
- A unique callback-based VM design in Go avoids traditional switch-based dispatch, improving performance and simplifying implementation.
- De-optimization is used for corner cases where static typing fails, falling back to the AST interpreter for dynamic type handling.
- Benchmarks show the new VM is up to 20x faster than the original AST interpreter and matches MySQL's C++ performance in many cases.
- The VM design minimizes memory allocations, further enhancing performance.
- JIT compilation is deemed unnecessary due to the high-level nature of SQL operations and the already low dispatch overhead.
Fastify is 7x Faster than Next.js
a year ago
- Revisiting SSR performance with @fastify/vue and @fastify/react at 1.0.0, now including metaframeworks like Nuxt and Next.
- Next.js setup involved create-next-app, App Router, and dynamic rendering to prevent prerendering.
- @fastify/react version required minimal changes, updating server.js and vite.config.js to use @fastify/react.
- Nuxt version used create-nuxt-app, transforming the HTML shell into a Vue component with Nuxt-specific tags.
- @fastify/vue version mirrored @fastify/react's approach, copying original code and updating configurations.
- Performance results: @fastify/vue (717 rps), Nuxt (561 rps), @fastify/react (347 rps), Next.js (49 rps).
- @fastify/react is 7x faster than Next.js, raising questions about Next.js overhead despite production settings.
- Discussion on the trade-offs between minimal frameworks (@fastify/vue, @fastify/react) and comprehensive solutions (Next.js, Nuxt).
- Highlighting the core functionality of SSR frameworks: seamless CSR to SSR transition and SPA behavior.
- Theo provides further analysis on the performance differences.
Doing the Prospero-Challenge in RPython
a year ago
- The Prospero Challenge involves rendering a 1024x1024 image from a mathematical formula with 7866 operations per pixel.
- The formula is in SSA-form, a linear sequence where each variable is assigned once, making it ideal for optimization.
- A baseline interpreter was implemented to parse and execute the program, but it was slow due to high interpretation overhead.
- Quadtrees were used to optimize rendering by subdividing the image and simplifying the formula via range analysis.
- A simple optimizer was written to perform interval analysis and peephole optimizations, though most added rules had minimal impact.
- A 'demanded information' optimization was introduced, focusing only on the sign of the result, which removed 25% of operations.
- Dead code elimination was implemented by marking used operations in a backward pass, improving efficiency.
- Random testing with Hypothesis ensured optimizer correctness by generating and minimizing test cases.
- Visualizations of the program and octree recursion were created to better understand the optimization process.
- A C implementation was developed to explore performance improvements using musttail, SIMD, and efficient struct packing.
- Performance tests showed the C version with demanded info optimizations was faster than the RPython version and competitive with Fidget.
We ended up rewriting NuGet Restore in .NET 9
a year ago
- NuGet Restore algorithm was rewritten to improve performance and scalability, reducing restore times significantly.
- Initial optimizations cut restore times in half, but a full rewrite achieved a 16x improvement (from ~32 mins to ~2 mins).
- The new algorithm avoids recursion and duplicate nodes, reducing memory usage and improving efficiency.
- Collaboration across NuGet, Visual Studio, and .NET teams was key to the project's success.
- The rewrite involved extensive testing, including automated tests, real-life repository tests, and dogfooding.
- Performance improvements led to significant cost savings and productivity gains for large repositories.
- Future work includes addressing known regressions, adding more parallelism, and enabling the new resolver for lock files.
- Key learnings: performance unlocks value, fresh perspectives help, and robust testing is essential.
Colossus: The secret ingredient behind Google Cloud's Rapid Storage
a year ago
- Google Cloud Storage introduces Rapid Storage, featuring a stateful gRPC-based streaming protocol for sub-millisecond read/write latency.
- Rapid Storage leverages Colossus, Google's internal file system, for high performance, low latency, and massive scale.
- Colossus uses handles for direct disk access via an optimized network protocol, enabling ultra-low latency durable appends.
- Rapid Storage supports 20 million requests per second in a single bucket, beneficial for AI/ML applications.
- The service ensures data correctness and handles client/server failures with transactional locking and versioning.
- Rapid Storage integrates with Cloud Storage FUSE for file-like access and supports Hierarchical Namespace for enhanced performance.
- Potential use cases include AI/ML data preparation, distributed databases, analytics processing, video streaming, and logging.
Show HN: Python at the Speed of Rust
a year ago
- Python is popular but slow compared to native languages like C or Rust.
- Compiling Python into native code can improve performance significantly.
- Fused multiply-add (FMA) operations are crucial for AI and LLMs.
- Symbolic tracing captures Python operations to build an Intermediate Representation (IR).
- Type annotations help in generating native code from the IR.
- The IR can be lowered into native code for various platforms.
- Compiled Python can approach Rust's performance with some overhead.
- Potential applications include AI, real-time data processing, and on-device LLM inference.
ArkType: Ergonomic TS validator 100x faster than Zod
a year ago
- Type syntax with safety and completions unlike anything seen before
- Deeply customizable error messages with great defaults
- Definitions are half as long, type errors twice as readable
- 100x faster than Zod and 2,000x faster than Yup at runtime
- Editor performance that enhances autocomplete experience
- ArkType uses set theory to understand and expose type relationships at runtime
- Every schema is internally normalized for optimal performance
- Comprehensive documentation from installation to integration
Battle of the Mallocators
a year ago
- Use jemalloc or tcmalloc with RocksDB to avoid OOM, as glibc malloc leads to higher RSS.
- RocksDB's allocation pattern (malloc on block read, free on eviction) stresses allocators, causing RSS to grow larger than expected with glibc malloc.
- InnoDB avoids per-block malloc/free, reducing allocator stress and keeping RSS more predictable.
- Peak RSS for MyRocks is smallest with jemalloc (1.22x buffer pool), slightly larger with tcmalloc (1.31x), and much larger with glibc malloc (3.62x).
- Performance (QPS) is slightly better with jemalloc and tcmalloc compared to glibc malloc for both InnoDB and MyRocks.
- VSZ can be larger with jemalloc, but this may not necessarily indicate a problem (could be address space usage).
- Benchmark setup: MySQL 8.0.40 (InnoDB) and FB MySQL 8.0.32 (MyRocks) on a Hetzner server with 128G RAM.
- For MyRocks, glibc malloc caused OOM with a 50G buffer pool, while jemalloc/tcmalloc handled 100G without issues.

firstprev0next

About|Login

#performance

Show HN: Nue – Apps lighter than a React button

Measuring Acceleration Structures

C and C++ prioritize performance over correctness (2023)

Growing Buffers to Avoid Copying Data

Span<T>.SequenceEquals is faster than memcmp

Towards fearless SIMD, 7 years later

Let's Take a Look at JEP 483: Ahead-of-Time Class Loading and Linking

Thoughts on ECS

Show HN: Benchi – A benchmarking tool written in Go

Is Python Code Sensitive to CPU Caching? (2024)

Show HN: uWrap.js – A faster and more accurate text wrapping util in < 2KB

Drag Racers Are Ditching Superchargers for Scuba-Style Tanks and Compressed Air

Faster interpreters in Go: Catching up with C++

Fastify is 7x Faster than Next.js

Doing the Prospero-Challenge in RPython

We ended up rewriting NuGet Restore in .NET 9

Colossus: The secret ingredient behind Google Cloud's Rapid Storage

Show HN: Python at the Speed of Rust

ArkType: Ergonomic TS validator 100x faster than Zod

Battle of the Mallocators