Hasty Briefsbeta

All tags

#performance

528 stories total

Bilingual

Helion: A modern fast paced Doom FPS engine in C#
a year ago
- Helion is a modern Doom engine designed for high performance.
- It handles complex maps efficiently, even on older hardware.
- Uses static rendering with state management for dynamic changes.
- Supports various WAD formats including vanilla, Boom, MBF, MBF21, UDMF (partial), and ID24.
- Minimum requirements: Windows 7 and Open GL 3.3 capable GPU.
- Available for Windows and Linux, with stable and nightly builds.
- Requires .NET 9; self-contained releases include it.
- Linux users need OpenAL, libsndfile, and libmpg123.
- Includes game documentation for setup and play.
- Source code and build instructions available for compilation.
- Community engagement via Discord and Doomworld forums.
- Bug reporting through GitHub Issues or Doomworld thread.
macOS Tahoe brings a new disk image format
a year ago
- ASIF is a new disk image format in macOS 26 Tahoe offering near-native speeds.
- ASIF disk images can be created using Disk Utility or the diskutil command tool.
- ASIF images are sparse files in APFS, with sizes dependent on stored data.
- Performance tests show ASIF achieves 5.8-6.6 GB/s read/write speeds (unencrypted).
- ASIF is recommended over RAW/UDRW for VM backing stores due to better efficiency.
- ASIF is faster than UDRW, UDSP, and sparse bundles, using a single file.
- ASIF support in macOS Sequoia 15.5 exists but lacks creation tools.
- Virtualizers should adopt ASIF for better performance in Tahoe.
- DropDMG is expected to support ASIF disk images soon.
jemalloc Postmortem
a year ago
- jemalloc was conceived in 2004 and has been publicly used for about 20 years.
- Originally part of the Lyken programming language, jemalloc was integrated into FreeBSD in 2005.
- Early versions of jemalloc had fragmentation issues, leading to significant redesigns.
- Mozilla Firefox 3's memory issues led to jemalloc's porting to Linux and Windows.
- Facebook's adoption of jemalloc highlighted the need for better instrumentation and profiling.
- jemalloc saw major updates, including testing infrastructure and Valgrind support in versions 3.0.0 and 4.x.
- Controversially, Valgrind support was removed in version 5.0.0, leading to backlash from the Rust community.
- Facebook's internal telemetry greatly benefited jemalloc's development, improving performance and resilience.
- Meta's shift in priorities led to reduced investment in jemalloc, stalling long-term development.
- The author considers upstream jemalloc development concluded, with potential for community forks.
The fastest way to detect a vowel in a string
a year ago
- The article explores 11 different methods to detect vowels in a string, ranging from naive loops to regex and prime number mappings.
- Performance benchmarks reveal that regex methods are surprisingly fast, especially for longer strings, outperforming traditional loops and other approaches.
- The set intersection method is efficient for long strings or sparse vowels but processes the entire string, unlike loops that can terminate early.
- Recursive methods and prime number mappings are creative but inefficient, with recursion failing for strings longer than 1000 characters due to Python's recursion limit.
- Bytecode analysis shows that regex benefits from optimized C implementations and bitmap lookups, explaining its superior performance.
- The article concludes that while regex is the fastest for most cases, readability and maintainability should guide method choice unless performance is critical.
OpenTelemetry for Go: Measuring overhead costs
a year ago
- Observability comes at a cost, including instrumentation overhead like CPU, memory, and network usage.
- OpenTelemetry is the industry standard for collecting telemetry data (metrics, logs, traces) in a vendor-neutral way.
- A benchmark was conducted to measure OpenTelemetry's overhead in a Go HTTP server using Valkey (Redis fork).
- Test setup involved separate nodes for the app, Valkey, load generator, and observability (Coroot Community Edition).
- Without OpenTelemetry, the app handled 10,000 RPS with p95 latency ~5ms and CPU usage at 2 cores.
- With OpenTelemetry enabled, CPU usage increased by ~35%, memory by 5-8MB, and p99 latency rose to ~15ms.
- Network traffic increased by ~4MB/s due to telemetry data export.
- eBPF-based instrumentation offers a lightweight alternative with minimal overhead, suitable for high-throughput environments.
- Coroot's agent demonstrated low CPU usage (<0.3 cores) in metrics-only mode during the test.
- The choice between OpenTelemetry and eBPF depends on the need for detailed traces vs. low overhead.
Bzip2 crate switches from C to 100% rust
a year ago
- bzip2 crate version 0.6.0 now uses a Rust implementation (libbz2-rs-sys) by default, improving performance and cross-compilation.
- The Rust implementation generally outperforms the C version, especially in compression, with significant speedups.
- Cross-compilation is simplified with the Rust implementation, eliminating issues with C dependencies, especially for WebAssembly, Windows, and Android.
- Symbols are not exported by default in libbz2-rs-sys, preventing conflicts with other dependencies, though a feature flag allows exporting if needed.
- The Rust implementation allows running tests with MIRI, enabling safer use of unsafe code and higher-level libraries.
- An audit found one logic bug (off-by-one error) and improved the fuzzer, with no other significant issues.
- The update is a maintenance win, making the bzip2 crate faster and easier to use without needing to think about underlying complexities.
Benchmark: SnapDOM may be a serious alternative to html2canvas
a year ago
- Benchmark test comparing snapDOM and html2canvas libraries for capturing DOM elements to canvas.
- Test includes basic elements, fun transitions, Orbit CSS framework, Google Fonts, Shadow DOM, Canvas, and various export formats.
- Performance measured by average speed over 5 captures per library to determine the winner.
- Features tested: pseudo-elements, clip-path demos, and mix blend modes.
Sep 0.11.0 – 9.5 GB/S CSV Parsing Using ARM Neon SIMD on Apple M1
a year ago
- Sep 0.11.0 was released with a new ARM NEON SIMD parser optimized for ARM64 CPUs like Apple M1 and Microsoft Cobalt 100.
- Performance improvements: 9.5 GB/s on Apple M1 (up from ~7 GB/s) and ~6 GB/s on Cobalt 100 (up from ~4 GB/s).
- Sep is now ~14x faster than CsvHelper and 6.4x faster than Sylvan.Data.Csv on Apple M1.
- The new parser uses ARM NEON SIMD (AdvSimd in .NET) for efficient CSV parsing, leveraging saturated conversion and optimized move mask operations.
- Performance benchmarks were conducted on GitHub runners, showing higher variance due to virtual machine environments.
- The blog post details the technical approach, including disassembling ARM64 code using NativeAOT and dumpbin on Windows.
- Key optimizations include handling 1024 bits (64 chars) at a time and using Geoff Langdale's efficient bulk move mask technique for ARM NEON.
- Links to additional resources on ARM SIMD optimizations and techniques are provided for further reading.
Ghostty is a fast, cross-platform terminal emulator
10 months ago
- Ghostty is a fast, feature-rich, and native terminal emulator that doesn't force users to choose between speed, features, or native UIs.
- It aims to push the boundaries of terminal emulation by supporting modern, opt-in features for CLI tool developers.
- Ghostty is standards-compliant, competitive in performance, and supports basic customizability like fonts and background colors.
- It offers richer windowing features such as multi-window, tabbing, and panes, and provides native platform experiences.
- Ghostty includes a cross-platform library called libghostty for embedding terminals in third-party projects.
- The macOS app is a SwiftUI-based application with a Metal renderer, while the Linux app is built with GTK.
- Ghostty has a built-in crash reporter that saves reports locally and can be uploaded to Sentry for analysis.
- Building Ghostty from source requires additional dependencies on Linux, such as blueprint-compiler.
- Documentation and resources are linted using Prettier, and Nix modules are formatted with Alejandra.
- The Nix package depends on a fixed-output derivation for the Zig package cache, which occasionally needs updating.
Revisiting Knuth's "Premature Optimization" Paper
10 months ago
- Knuth's famous quote 'premature optimization is the root of all evil' is often misinterpreted.
- The original paper discusses the use of 'goto' statements and performance trade-offs in structured programming.
- Knuth emphasizes that small optimizations (e.g., loop unrolling) are worthwhile if they are in critical code sections.
- Benchmarking is essential to identify which parts of a program truly benefit from optimization.
- Modern compilers do not always optimize effectively, sometimes requiring manual intervention (e.g., assembly tweaks).
- Using well-optimized library functions (e.g., STL, fast hash tables) is often better than manual micro-optimizations.
- A 10% performance improvement can be significant, especially in frequently used library functions.
React Zero-UI: Instant UI updates, ZERO re-renders, ZERO runtime
10 months ago
- Zero-UI enables instant UI state updates with zero React re-renders and a runtime of less than 1 KB.
- Pre-renders UI once and updates by flipping a data-* attribute, resulting in 5-10× faster visual updates.
- Includes benchmarks showing significant speed improvements over React, especially with large node counts.
- Requires Tailwind CSS v4 and integrates with Next.js (App Router) or Vite via a simple CLI setup.
- Features include global setters, TypeScript support, SSR compatibility, and framework-agnostic CSS.
- Designed for UI-only state (themes, toggles) while keeping business logic in React.
- Encourages community contributions and is MIT licensed.
HP ZBook Ultra G1a smashes the 'work laptop' paradigm with 96GB RAM for GPU
10 months ago
- HP ZBook Ultra G1a is a powerful, portable enterprise-grade laptop.
- Features a lightweight, thin chassis with a 14-inch 2.8K OLED display.
- Equipped with AMD Ryzen AI Max Pro chip for high performance.
- Supports up to 128GB DDR5 RAM and 4TB storage.
- Includes advanced security features like HP Wolf Security and fingerprint reader.
- Capable of running graphically demanding applications and AI models locally.
- Offers impressive graphics power with 40 integrated RDNA 3.5 cores.
- Includes multiple ports: Thunderbolt 4, USB-C, USB-A, HDMI 2.1, and Kensington lock.
- Designed for professionals like engineers and creative professionals.
- Boosts productivity with AI capabilities and seamless multitasking.
Python can run Mojo now
10 months ago
- Python can now call Mojo code, offering fast compiled functions.
- Setup is simplified using `uv pip install modular`.
- Example: Factorial function in Mojo shows performance comparison with Python.
- Overflow issues observed with larger numbers in Mojo.
- Prime counting example demonstrates significant speedup in Mojo vs Python and NumPy.
- Mojo is easier to learn than Rust but provides desired speed improvements.
- Modular stack is still early with some rough edges and limited support.
How much slower is random access, really?
10 months ago
- Random access performance is significantly impacted by cache locality, with first-to-last order being faster than random order.
- Performance differences become noticeable when arrays exceed the L3 cache size (around 1 million elements).
- First-to-last order averages about 1 nanosecond per element on a MacBook and 0.5 nanoseconds on a Linux desktop.
- Random order is 4x slower on MacBook and 8-16x slower on Linux for arrays fitting in RAM but exceeding L3 cache.
- For arrays larger than RAM, performance degrades sharply, with random order becoming 50x slower on Linux.
- Fisher-Yates shuffle is inefficient for large datasets; a two-pass shuffle is recommended.
- Memory-mapped files do not significantly improve performance for large datasets, with macOS and Linux showing different behaviors.
- Direct file reading can be more efficient than memory-mapping, especially on Linux.
Save your disk, write files directly into RAM with /dev/shm
10 months ago
- /dev/shm is a RAM-based scratchpad available in Unix systems by default.
- It is a tmpfs filesystem, meaning data stored in /dev/shm is lost upon reboot.
- Using /dev/shm can significantly improve performance for file operations by leveraging RAM speed.
- It is useful for temporary files, especially when working with large datasets or frequent read/write operations.
- Example use cases include linguistics data processing, where files can be accessed much faster.
- Tools like jq, rg, and grep benefit from the speedup when files are stored in /dev/shm.
- Memory usage should be monitored, as /dev/shm consumes RAM.
uv: The Fast Python Package Manager
10 months ago
- uv is a lightning-fast Python package manager built in Rust by Astral.
- It offers 10-100x faster performance than pip and replaces multiple Python tools like pip, pip-tools, pipx, poetry, pyenv, and virtualenv.
- Key features include rapid package installation, virtual environment creation, and a single binary with zero Python dependencies.
- Installation is simple via curl or Homebrew, and it includes Python version management.
- Commands cover project initialization, dependency management, and script execution without manual virtual environment activation.
- Best practices include project structure recommendations, Python version strategies, and dependency management tips.
- CI/CD integration with GitHub Actions is supported, and common pitfalls are addressed.
- Future updates include universal lockfiles and built-in Python version management.
- uv is recommended for faster dependency installation, simpler project management, and a modern Python development experience.
Untangling Lifetimes: The Arena Allocator
10 months ago
- The article discusses the limitations and complexities of traditional manual memory management in C using malloc and free.
- It introduces the arena allocator as a simpler and more efficient alternative to malloc and free, inspired by stack allocation.
- The author critiques common programming education that discourages manual memory management, advocating for a deeper understanding of lower-level details.
- Arena allocators group allocations into lifetimes, reducing the need for individual deallocations and simplifying memory management.
- The article provides practical examples and API designs for implementing and using arena allocators in various scenarios.
- It explores advanced uses of arenas, such as frame arenas for game loops and per-thread scratch arenas for temporary allocations.
- Implementation strategies for arena allocators are discussed, including dynamic growth and virtual memory utilization.
- The author emphasizes the importance of harmonizing high-level and low-level programming concepts for better performance and simplicity.
Linkwarden extension sends domain to server on tab switch
10 months ago
- The browser extension currently makes a request to the Linkwarden server on every tab click with the domain of the tab.
- The request is made to check if the domain is already saved in Linkwarden.
- The feature request suggests caching the hosts to reduce server requests and improve performance.
- An alternative suggestion is to disable the badge entirely to address load and privacy concerns.
Speeding up global DNS resolution by avoiding CNAMES
10 months ago
- Using CNAMEs in DNS can help with organization but slows down resolution time due to multiple queries.
- Each CNAME in the chain requires additional DNS lookups, increasing latency, especially for users far from regional servers.
- Global users experience significant delays (e.g., 1.5 seconds in Japan) compared to EU users (0.004–0.070 seconds).
- Removing CNAME chains and delegating subdomains directly to GeoIP nameservers reduces resolution time (e.g., from 1.9s to 0.7s).
- Further improvements could include eliminating zone delegation and ensuring global accessibility of all nameservers.
Show HN: TokenDagger – A tokenizer faster than OpenAI's Tiktoken
10 months ago
- TokenDagger is a fast implementation of OpenAI's TikToken for large-scale text processing.
- It offers 2x throughput and is 4x faster on code sample tokenization.
- Optimized PCRE2 regex engine for efficient token pattern matching.
- Full compatibility with OpenAI's TikToken tokenizer as a drop-in replacement.
- Simplified BPE algorithm to reduce performance impact of large special token vocabulary.
- Performance benchmarks show TokenDagger is 4.02x faster on code tokenization.
- Installation and setup instructions provided for easy adoption.
- Requires libpcre2-dev and Python 3 development tools for setup.

first prev6next

About|Login

#performance

Helion: A modern fast paced Doom FPS engine in C#

macOS Tahoe brings a new disk image format

jemalloc Postmortem

The fastest way to detect a vowel in a string

OpenTelemetry for Go: Measuring overhead costs

Bzip2 crate switches from C to 100% rust

Benchmark: SnapDOM may be a serious alternative to html2canvas

Sep 0.11.0 – 9.5 GB/S CSV Parsing Using ARM Neon SIMD on Apple M1

Ghostty is a fast, cross-platform terminal emulator

Revisiting Knuth's "Premature Optimization" Paper

React Zero-UI: Instant UI updates, ZERO re-renders, ZERO runtime

HP ZBook Ultra G1a smashes the 'work laptop' paradigm with 96GB RAM for GPU

Python can run Mojo now

How much slower is random access, really?

Save your disk, write files directly into RAM with /dev/shm

uv: The Fast Python Package Manager

Untangling Lifetimes: The Arena Allocator

Linkwarden extension sends domain to server on tab switch

Speeding up global DNS resolution by avoiding CNAMES

Show HN: TokenDagger – A tokenizer faster than OpenAI's Tiktoken