Hasty Briefsbeta

All tags

#performance

528 stories total

Bilingual

Bold : A Drop-In Replacement For Apple System Linker Written In Zig
a year ago
- Bold is a drop-in replacement for Apple's system linker ld, written fully in Zig.
- It is on par with LLVM lld linker, faster than the legacy Apple ld linker, but slower than the rewritten Apple ld linker.
- Benchmark results show bold is 2.23 times slower than the rewritten Apple ld linker but 2.38 times faster than LLVM lld linker.
- Bold can be used with clang via -fuse-ld=bold or with gcc via -B/path/to/bold.
- To build bold, you need Zig 0.14.0 and can compile it with 'zig build -Doptimize=ReleaseFast'.
- Unit and end-to-end tests can be run with 'zig build test'.
- Contributions to the repository are welcome.
Why GADTs matter for performance (2015)
a year ago
- GADTs (Generalized Algebraic Data Types) in OCaml were initially thought to be irrelevant for systems programming but proved useful for performance optimization.
- GADTs allow tweaking memory representations in ways that would otherwise be unsafe or difficult in OCaml.
- OCaml's polymorphism relies on uniform memory representation, which can lead to inefficient space usage for some datatypes.
- Attempting to create a compact array type without GADTs results in limited functionality or inefficient memory usage.
- Using GADTs, it's possible to create a compact array type that efficiently handles both general arrays and byte arrays.
- GADTs enable precise control over memory representation, which is crucial for high-performance applications.
Beating the fastest lexer generator in Rust
a year ago
- Lexer generators aim to simplify lexer creation and improve performance over hand-written implementations.
- Performance comparisons between logos and a naive lexer implementation show logos is faster on Apple M1 but slower on x86_64.
- Speculative execution differences between architectures affect lexer performance.
- Perfect hash functions are used for efficient keyword matching, leveraging that keywords fit into a 64-bit register.
- Optimizations for ASCII text can significantly improve lexer performance, as most source code is ASCII.
- Vectorization and SIMD instructions can be used to optimize lexer performance, especially for predictable patterns like whitespace.
- Benchmarking with realistic data shows the naive implementation can outperform logos by 20-30% in some scenarios.
- Keyword frequency and identifier patterns in real-world code affect the relative performance of lexer implementations.
Binary Formats Are Better Than JSON in Browsers
a year ago
- JSON is no longer the fastest option for browser-based web apps; alternatives like Avro, Protobuf, or Bebop should be considered for performance-sensitive applications.
- Benchmarking binary encodings in browsers revealed that many alternatives to JSON, including MessagePack, were slower, but recent developments have improved their performance.
- Common benchmarking mistakes include using Node.js instead of browsers and focusing on numeric-heavy datasets, which don't reflect typical use cases involving strings.
- End-to-end latency measurements, including server request to client processing, provide a more accurate comparison than just deserialization times.
- Compression reduces message size differences but doesn't eliminate the extra processing time required for JSON in browsers.
- Schema-based encodings like Avro and Protobuf offer built-in validation, adding safety without significant performance overhead.
- Lazy decoding in libraries like Flatbuffers and Cap'n Proto can improve performance when not all data is accessed, but materializing full objects may be slower.
- Recent browser improvements and library updates have made binary encodings more viable, with Bebop, Avro, and Protobuf showing strong performance.
- JSON has limitations, such as string size caps, lack of type support (e.g., 64-bit integers), and no built-in validation, which can lead to runtime errors.
- TypeScript and libraries like zod can mitigate some JSON issues, but schema-based encodings provide better end-to-end safety.
LPython: Novel, Fast, Retargetable Python Compiler (2023)
a year ago
- LPython is a Python compiler that converts type-annotated Python code into optimized machine code.
- It supports multiple backends including LLVM, C, C++, WASM, Julia, and x86.
- Features include Ahead-of-Time (AoT) compilation, Just-In-Time (JIT) compilation, and interoperability with CPython.
- LPython uses Abstract Semantic Representation (ASR) for intermediate optimizations, shared with LFortran.
- Benchmarks show LPython's competitive performance against Numba and C++ in various tasks.
- Supports machine-independent optimizations like loop unrolling, vectorization, and dead code removal.
- JIT compilation in LPython is achieved using decorators, with backend-specific optimization flags.
- Interoperability with CPython allows calling functions from libraries like NumPy and Matplotlib.
- AoT compilation examples demonstrate LPython's speed in generating binary outputs.
- Visualization examples include generating Mandelbrot sets using Matplotlib via LPython.
Why I Use WebAssembly
a year ago
- WebAssembly (WASM) enables running native code like FFmpeg directly in the browser, transforming web applications.
- WASM improves performance, as seen with Figma's 3x load time reduction using a C++ renderer.
- WASM's isolation properties make it useful beyond browsers, potentially replacing technologies like Docker.
- Client-side WASM eliminates server round trips, simplifying state management in applications like file converters.
- WASM allows sharing core logic across platforms, reducing the need for separate codebases for web and native apps.
- Tauri is highlighted as a lightweight alternative to Electron, using system web views for native apps with web UIs.
- Nema Studio exemplifies using WASM for a cross-platform DAW, targeting browser users before encouraging native app adoption.
Smalltalk-78 Xerox NoteTaker in-browser emulator
a year ago
- Multiple JavaScript modules loaded from lively-web.org
- Modules include SystemConsole.js, Lively2Lively.js, Functions.js, and others
- Loading times for modules range from 78 ms to 555 ms
- Modules related to morphic tools, IDE tools, and networking tools were loaded
My 2025 high-end Linux PC
a year ago
- The author built a PC with an Intel 285K CPU for low idle power, a 4TB SSD, and an Nvidia GPU for an 8K monitor.
- Components include a Fractal Define 7 Compact case, Corsair RM850x PSU, ASUS PRIME Z890-P mainboard, and Noctua fans.
- The initial build had a faulty CPU, which was replaced after extensive troubleshooting and stress testing.
- The author prefers Intel CPUs over AMD for better idle power efficiency, crucial for software development workloads.
- The Realtek 2.5 GbE network card on the mainboard required recent Linux firmware but works well in practice.
- The Noctua NH-D15 G2 CPU cooler was chosen for its quiet operation and effective cooling.
- The Samsung 990 Pro 4TB SSD was selected for reliability and performance, despite higher power draw concerns with PCIe 5 SSDs.
- Stress testing with Prime95 and MemTest86 confirmed the replacement CPU's stability.
- The RMA process for the faulty CPU took over a month, delaying the project significantly.
- The final build is stable, quiet, and power-efficient, with excellent performance for the author's needs.
Determinate Nix 3.5: introducing lazy trees
a year ago
- Lazy trees have been introduced in Determinate Nix version 3.5.2, based on upstream Nix 2.28.3.
- Lazy trees improve efficiency in large repositories, especially monorepos, by reducing evaluation time and disk usage.
- Initial release is opt-in only for cautious adoption.
- Lazy trees scope file copying to only what is needed, using a virtual filesystem to minimize unnecessary operations.
- Performance improvements include up to 3x faster evaluation and 20x less disk usage in some cases.
- Example provided shows a reduction from 304MB to 13MB in disk usage with lazy trees enabled.
- CI comparisons demonstrate significant performance gains, with evaluation time dropping from 11 seconds to 3.5 seconds.
- A new warning is introduced for inefficient source specifications in derivations, recommending better practices.
- Instructions for upgrading or installing Determinate Nix are provided for macOS and Linux.
- Future improvements planned include better evaluation caching, parallel evaluation, and multi-threaded unpacking of flakes.
Jetrelay: A high-performance ATproto relay in 500 LOC
a year ago
- Jetrelay is a pub/sub server compatible with Bluesky’s 'jetstream' data feed, designed to be highly efficient by leveraging Linux kernel features.
- The server can saturate a 10 Gbps network connection with just 8 CPU cores by avoiding unnecessary work.
- Jetrelay uses multicast-like behavior for TCP-based websockets, sending identical data to all clients efficiently.
- Key techniques include using `sendfile()` to bypass userspace for zero-copy data transfer, `io_uring` for handling many clients with minimal syscalls, and `FALLOC_FL_PUNCH_HOLE` for discarding old data without disrupting clients.
- The server maintains an in-memory index (`BTreeMap`) to quickly locate data for clients requesting backfill based on timestamps.
- Testing showed Jetrelay can handle up to 9,000 clients, saturating a 10 Gbps connection, with performance scaling linearly with CPU cores until bottlenecked by the network.
- Compared to the official jetstream server, Jetrelay achieves higher throughput for the 'no filtering' use case but lacks features like per-client filtering.
- The post discusses the broader context of push-based internet protocols, comparing ATproto's improvements over RSS, such as signed records and a filesystem-like data model.
- Jetrelay is a tech demo; production use would require additional features like backfill on startup, better websocket compliance, security measures, and more.
Linux Swap Table Code Shows the Potential for Performance Gains
a year ago
- Linux kernel developers are working on integrating swap cache and swap maps functionality with the swap allocator, leading to the creation of Swap Table.
- Swap Table aims to provide lower memory use, higher performance, dynamic swap allocation and growth, and greater extensibility.
- Engineer Kairui Song from Tencent posted a patch series for Swap Table, implementing design ideas discussed by kernel developers.
- The patches promise a 20-30% performance gain for various workloads and lower idle memory usage.
- The Swap Table patch series consists of 27 patches and is currently under review for potential inclusion in the mainline Linux kernel.
Show HN: Solidis – Tiny TS Redis client, no deps, for serverless
a year ago
- Solidis is a high-performance, SOLID-structured RESP client for Redis and other RESP-compatible servers.
- Supports both RESP2 and RESP3 protocols with zero dependencies and optimized for modern JavaScript/TypeScript applications.
- Features include efficient pipeline & batch processing, minimal memory footprint, and zero-copy buffer operations.
- Type-safe with extensive TypeScript definitions and comprehensive type guards for all commands.
- Lightweight with zero dependencies, minimum bundle size < 30KB, and full bundle size < 105KB.
- Advanced features include transaction support, Pub/Sub functionality, automatic reconnection, and command timeout handling.
- Two client implementations: basic client for minimal functionality and featured client with all RESP commands pre-loaded.
- Extensive configuration options for connection, authentication, protocol, recovery, timeouts, and performance tuning.
- Detailed error handling with specific error classes for different failure modes.
- Clear component separation with SolidisClient coordinating Connection, Requester, Parser, and PubSub components.
- Open-source project welcoming contributions with guidelines for code style, performance, and bundle size considerations.
- Licensed under MIT.
Rustls Server-Side Performance
a year ago
- Rustls is a memory-safe TLS implementation focused on performance and production readiness.
- The project has received investments from ISRG and aims to improve performance without compromising safety.
- Rustls offers a C API and FIPS support to replace C-based TLS implementations like OpenSSL, which have memory safety vulnerabilities.
- Server performance optimizations include minimizing slowdowns from shared resumption stores and improving handshake latency.
- Rustls supports two TLS resumption strategies: stateful (server-side storage) and stateless (client-side storage with tickets).
- Changes in Rustls 0.23.17 include using RwLock for ticket encryption keys and reducing default tickets from 4 to 2 to align with OpenSSL/BoringSSL.
- Benchmarks show Rustls scales linearly with core count and has ~2x lower handshake latency than OpenSSL.
New high-quality hash measures 71GB/s on M4
a year ago
- Rapidhash is the fastest recommended hash function by SMHasher and SMHasher3.
- It is extremely fast for both short and large inputs, surpassing 70GB/s on Apple's M4 CPUs.
- Optimized for AMD64 and AArch64 systems, compatible with gcc, clang, icx, and MSVC.
- Passes all tests in SMHasher and SMHasher3 with excellent collision probability, lower than wyhash.
- Outstanding collision ratio tested with datasets of 16B and 66B keys.
- Average latency is lower than xxh3 on various CPUs (M1 Pro, M3 Pro, Neoverse V2, AMD Turin).
- Peak throughput is higher than xxh3 on Apple M1 Pro, M3 Pro, M3 Ultra, M4, and Neoverse V2.
- A perfect hash function distributes its domain uniformly onto the image.
Cheap mini PCs have gotten good
a year ago
- The Minisforum UM870 is a compact mini PC with an AMD 8745H CPU, offering strong performance at an affordable price.
- It outperforms the more expensive Apple M4 Pro in certain tasks, especially those involving Docker and Linux toolchains.
- The UM870 can handle modern video games at 1080p medium settings, a feature the Mac Mini lacks.
- AMD's Zen 4 cores, used in the UM870, are built on the same 5nm process as Apple's M2, leading to competitive single-core performance.
- Upcoming AMD Ryzen AI Max 395+ chips show even greater performance, surpassing the M4 Pro in multi-core benchmarks.
- Mini PCs like the UM870 represent a significant advancement in computing power, offering data-center-level performance in a small, silent package.
- The article highlights the value of open-source Linux in outperforming macOS for developer-specific workloads.
- Recommendations include checking out the Minisforum UM870 or Beelink SER8 for great deals on mini PCs.
SQL OFFSET is worse than keyset pagination
a year ago
- Two methods for fetching next pages in database queries: offset and seek.
- Offset method numbers rows and filters to skip previous pages, supported by many databases.
- Seek method uses the last entry of the previous page to fetch following rows, offering better performance.
- Seek method requires a deterministic sort order for accurate results.
- Row values syntax can be used for seek method but is not widely supported.
- Performance comparison shows seek method scales better than offset method for deeper pages.
Backtrace is finally cheap by abusing x86/Linux's shadow stack
a year ago
- Backtrace is a useful but expensive debugging tool in native programming due to the costly process of reading DWARF sections and chasing frame pointers on the stack.
- Shadow stack is a security feature that stores return addresses separately, preventing stack buffer overflow attacks and improving performance by avoiding linked list traversal.
- Recent hardware support for shadow stacks has been announced by Intel and AMD, with Linux kernel support added in version 6.4 (requires `CONFIG_X86_USER_SHADOW_STACK=y`).
- GCC can enable shadow stack support via `-fcf-protection=return` or `=full`, which adds the `SHSTK` feature to `.note.gnu.property`.
- Glibc (version 2.28+) dynamically enables shadow stack based on hardware detection and tunables (`glibc.cpu.x86_shstk`), with options `on`, `off`, and `permissive`.
- Current limitations include incomplete hardware detection (requiring manual tunables like `GLIBC_TUNABLES='glibc.cpu.hwcaps=SHSTK'`) and dependency on all linked libraries being compiled with `-fcf-protection=full`.
- Shadow stack allows faster backtrace capture by directly reading return addresses, bypassing slow frame pointer chasing, and can be combined with `/proc/self/map` for debugging.
- Developers can manually enable/disable shadow stack using syscalls (`arch_prctl`), but must handle context-switching libraries (e.g., glibc's `makecontext`, `swapcontext`, `longjmp`) carefully.
- Shadow stack usage for backtracing is still immature and requires workarounds, but it has potential to improve debugging performance if upstream support improves.
Monitoring Node.js: Key Metrics You Should Track
a year ago
- Effective Node.js monitoring requires tracking runtime metrics (memory, CPU), application metrics (request rates, response times), and business metrics (user actions, conversion rates).
- Runtime metrics include memory usage (heap used vs heap total, external memory, garbage collection frequency, RSS), CPU utilization, and event loop metrics (lag, utilization, tick length).
- Application metrics cover HTTP request metrics (request rate, response time, error rate), database and external service performance (query execution time, connection pool utilization).
- Business metrics link technical performance to business outcomes (conversion rate, user engagement, cart abandonment, revenue impact).
- Implement metrics collection using built-in Node.js APIs or observability clients like OpenTelemetry with Last9.
- Custom metrics can track user experience (checkout time) and cache effectiveness (hit/miss ratio).
- Configure effective alerts with multi-threshold levels, correlation-based alerts, and anomaly detection.
- Common mistakes include misinterpreting memory sawtooth patterns, not correlating event loop metrics with performance, and using mean values instead of percentiles.
- Use metrics outside production for benchmarking new features, load testing, and A/B testing performance.
- Start with basic runtime metrics, expand to application and business metrics, and set up smart alerts and dashboards.
- Focus on actionable metrics that help debug faster and make informed decisions.
Too Much Go Misdirection
a year ago
- Go's io.Reader interface is commonly used for streaming data, but sometimes direct byte access is needed.
- The author encounters inefficiency when needing to use bytes directly from an io.Reader, especially with libraries like libavif and libheif.
- A workaround using type assertion and unsafe.Pointer is attempted to access bytes directly from a bytes.Reader.
- The image.Decode function complicates this by wrapping the reader in a bufio.Reader if it lacks a Peek method.
- Further workarounds involve unpacking the bufio.Reader to access the underlying bytes.Reader.
- Criticism is leveled at Go's structural typing and standard library practices for creating undocumented 'shadow APIs'.
- The author reflects on the broader implications of such design choices in Go.
FUSE to Enjoy a Performance Improvement with Linux 6.16
a year ago
- FUSE performance improvement expected in Linux 6.16.
- Buffer size for readdir increased to match user-space requests.
- Patch queued in FUSE 'for-next' branch for Linux 6.16 merge.
- No specific performance numbers shared in the commit message.

first prev3next

About|Login

#performance

Bold : A Drop-In Replacement For Apple System Linker Written In Zig

Why GADTs matter for performance (2015)

Beating the fastest lexer generator in Rust

Binary Formats Are Better Than JSON in Browsers

LPython: Novel, Fast, Retargetable Python Compiler (2023)

Why I Use WebAssembly

Smalltalk-78 Xerox NoteTaker in-browser emulator

My 2025 high-end Linux PC

Determinate Nix 3.5: introducing lazy trees

Jetrelay: A high-performance ATproto relay in 500 LOC

Linux Swap Table Code Shows the Potential for Performance Gains

Show HN: Solidis – Tiny TS Redis client, no deps, for serverless

Rustls Server-Side Performance

New high-quality hash measures 71GB/s on M4

Cheap mini PCs have gotten good

SQL OFFSET is worse than keyset pagination

Backtrace is finally cheap by abusing x86/Linux's shadow stack

Monitoring Node.js: Key Metrics You Should Track

Too Much Go Misdirection

FUSE to Enjoy a Performance Improvement with Linux 6.16