Hasty Briefsbeta

All tags

#performance optimization

122 stories total

Bilingual

Go Optimization Guide
a year ago
- The Go App Optimization Guide helps developers write faster and more efficient Go applications.
- Go provides tools for performance tuning, including memory reuse, allocation control, and efficient networking.
- Common Go patterns for performance include using sync.Pool, avoiding unnecessary allocations, and efficient error handling.
- Upcoming topics include high-performance networking in Go, managing concurrent connections, and performance tuning.
- The series is aimed at backend engineers, developers of latency-sensitive systems, and teams migrating to Go.
An Interview with Zen Chief Architect Mike Clark
a year ago
- Zen microarchitecture has significantly boosted AMD's CPU marketshare from 10% to 25% over eight years.
- Mike Clark, Zen's chief architect, discusses the flexibility of x86 and ARM ISAs, noting both can achieve similar performance per watt with appropriate microarchitecture.
- The x86 ISA's variable-length instructions and stronger memory model don't fundamentally limit performance or power efficiency.
- Larger page sizes (e.g., 16k or 64k) could benefit Zen architectures by reducing TLB pressure, though 4k pages remain manageable with techniques like page combining.
- CPUs and GPUs differ in cache line and register sizes (64 bytes vs. 128+ bytes) due to their focus on low-latency vs. throughput workloads, respectively.
- Scatter/gather operations are challenging on CPUs due to bandwidth limitations, but wider adoption in software could justify hardware improvements.
- Nontemporal stores can outperform regular stores when used correctly, as they reduce cache pollution and simplify memory subsystem operations.
- Modern CPU pipelines remain conceptually similar to older designs (e.g., Bulldozer), though proprietary optimizations prevent detailed public diagrams.
- Long-latency instructions like `sqrtpd` are handled by schedulers that account for their non-pipelined execution, avoiding overlap with other operations.
- Software developers are encouraged to adopt new ISA features (e.g., wider vectors, AI instructions) and provide feedback to guide future hardware designs.
Disk I/O bottlenecks in GitHub Actions
a year ago
- Disk I/O bottlenecks can significantly impact CI pipeline performance and are often overlooked.
- Tools like iostat and fio are useful for monitoring and benchmarking disk performance in CI pipelines.
- GitHub's default ubuntu-22.04 runner provides additional vCPUs but does not enhance disk performance.
- Monitoring disk performance during pipeline execution is crucial for identifying bottlenecks.
- Using iostat to monitor disk saturation during dependency installation can reveal performance issues.
- Cache operations, such as untarring dependencies, can expose disk I/O bottlenecks, especially with many small files.
- Disk throughput and IOPS are key metrics for understanding disk performance limitations.
- Benchmarking with fio helps verify if disk throughput or IOPS limits are being hit.
- Testing workflows on different runners using a matrix strategy can help identify optimal performance configurations.
- Depot Ultra Runner offers ultra-fast disk I/O with RAM disk cache and high-powered CPUs for improved performance.
Using Token Sequences to Iterate Ranges
a year ago
- The article discusses inefficiencies in C++ Ranges, particularly with views like filter and take_while, which perform redundant operations.
- It presents two solutions: Flux, a library offering internal iteration for better performance, and a theoretical approach using token sequences for code injection.
- Flux demonstrates how internal iteration can reduce overhead by avoiding redundant checks and optimizing space usage.
- The token sequences approach, still in design, allows for generating optimal loop structures dynamically, showcasing potential for zero-overhead abstractions.
- Examples highlight performance issues with common range operations and how alternative approaches can mitigate them.
- The article concludes by pondering future directions for C++ Ranges, including potential language and library enhancements for internal iteration.
Pdeathsig is almost never what you want
a year ago
- The author was tasked with optimizing Output Media start latency at Recall.ai.
- Output Media renders customer-supplied web pages into audio and video for bots, using Chromium in a sandboxed environment with Bubblewrap.
- Initial latency was 12 seconds due to Chromium's resource-intensive startup when Output Media was activated.
- The plan was to pre-load Chromium at bot startup to reduce latency.
- Testing revealed Chromium terminated unexpectedly, despite the parent process still running.
- Debugging identified the issue with Bubblewrap's --die-with-parent flag, which uses Linux's PR_SET_PDEATHSIG.
- PR_SET_PDEATHSIG tracks the parent thread, not the process, causing issues with Tokio's thread management.
- Tokio's dynamic thread parking and reaping led to premature termination of Chromium.
- Removing --die-with-parent resolved the issue, reducing latency to 2-3 seconds.
- The solution improved customer experience by significantly cutting wait times.
New Apache Cassandra Release Saves 400% IOPS
a year ago
- Apache Cassandra 5.0.4 released on April 10, 2025, with performance optimizations, especially for remotely attached storage like Amazon EBS.
- New compaction algorithm reduces IOPS usage and increases throughput, addressing a long-standing bottleneck.
- Benchmarks show up to 3x more throughput and significantly reduced IOPS usage with the new compaction logic.
- Read latency and throughput improved due to decreased time spent waiting for pread.
- Simplyblock complements Cassandra’s improvements by offering high-performance, scalable storage solutions.
- Simplyblock features include multi-attach and erasure coding for storage footprint reduction, ultra-low latency for sensitive workloads, and instant clones for development.
- Cassandra 5.0.4 highlights the need for scalable storage architectures to match modern distributed databases.
Get Out of My Head
a year ago
- Remove unnecessary tags from your site's <head> to improve performance.
- Enhance website accessibility by cleaning up the <head> section.
- Make websites more environmentally friendly by optimizing the <head> content.
JavaScript Views, the Hard Way – A Pattern for Writing UI
a year ago
- Writing JavaScript Views the Hard Way is a pattern for creating maintainable, performant views without frameworks like React or Vue.
- Key benefits include performance (direct imperative code), zero dependencies, portability across frameworks, maintainability through strict conventions, broad browser support, easier debugging, and functional programming style.
- The approach involves structuring views with templates, DOM variables, state variables, DOM update functions, state update functions, and initialization logic.
- Templates use plain HTML with placeholders for dynamic content, avoiding interpolation for browser compatibility.
- The `init` function acts as a closure for view instances, managing DOM and state updates through clearly defined sections.
- Conventions like naming DOM nodes with 'Node' suffix and state update functions with 'set' prefix help maintain clarity and debuggability.
- State and DOM updates are separated to ensure efficient rendering and clear mutation tracking.
- The pattern supports creating reusable, framework-agnostic components with minimal overhead.
Optimizing Heap Allocations in Go: A Case Study
a year ago
- A performance regression in Golang was caused by a refactor that unintentionally led to heap allocations instead of stack allocations.
- The issue stemmed from using a value receiver in a method, which created unnecessary copies of the receiver on the heap.
- Golang's escape analysis determines whether variables should be allocated on the stack or heap, but it can be conservative, leading to heap allocations even when stack allocation would be safe.
- The fix involved changing the method to use a pointer receiver, eliminating the unnecessary copies and improving performance by 30%.
- Understanding Golang's memory allocation behavior and using tools like `go build -gcflags "-m"` can help identify and optimize performance issues.
- Prefer pointer receivers to avoid unnecessary copies and potential heap allocations, especially in performance-critical code.
Hyperscaling Have I Been Pwned with Cloudflare Workers and Caching
a year ago
- Have I Been Pwned (HIBP) has evolved to use Cloudflare edge caching for faster searches.
- Caching at Cloudflare edge nodes reduces latency by 99%, improves availability, and cuts costs.
- HIBP now caches searches by the first six characters of SHA-1 hashed email addresses, totaling ~16 million possible prefixes.
- Cache flushes occur when new breaches are loaded or users opt out, temporarily increasing origin traffic and costs.
- API key validation remains a bottleneck as it requires a trip to the origin server in West US.
- Cloudflare's cache reserve handles over 3,900 Pwned Passwords requests per second on average, peaking at 17k/sec.
Threaded Code
a year ago
- Threaded code is a technique for implementing virtual machine interpreters, originally described by James R. Bell in 1973.
- Subroutine-threaded code involves sequences of code addresses representing virtual machine instructions, but it's not interpretive in the original sense.
- Direct threaded code uses an instruction pointer to execute sequences of instructions, with each instruction jumping to the next via a shared or individual NEXT routine.
- Indirect threaded code introduces a level of indirection with code and parameter fields, allowing shared code for similar instructions but with separate data.
- Switch threading uses a switch statement to implement threaded code, which can lead to high misprediction rates in modern CPUs' branch target buffers.
- Call threading represents each virtual machine instruction as a function, using global variables for registers, which may not be as efficient as local variables in switch threading.
- Performance varies among threading techniques, with direct and indirect threading generally offering better performance than switch or call threading due to branch prediction efficiencies.
- Implementing threaded code portably can involve using GNU C extensions for machine-independent engines or generating code automatically from stack effect notations.
- Historical context includes early uses of code fields and the evolution of threading techniques from string interpretation to modern implementations.
Optimizing Common Lisp
a year ago
- The author used sb-sprof, a statistical profiler in SBCL, to identify CPU and memory allocation hotspots in their Common Lisp Parser Combinator library.
- By profiling, they improved the runtime speed of the parcom/json module by 3x and reduced memory allocation by 25x.
- Key optimizations included replacing list allocations with slices, using schar for faster string access, and leveraging multiple-value-bind to reduce garbage collection.
- Stack allocation of local variables and caching of lambda closures were also employed to further reduce memory usage.
- The article emphasizes the importance of profiling to guide optimizations and demonstrates that parser combinators can be both elegant and performant in Common Lisp.
'I paid for the whole GPU, I am going to use the whole GPU'
a year ago
- GPUs are specialized co-processors designed for high-throughput mathematical operations, particularly matrix multiplications, where CPUs fall short.
- GPU utilization is a critical concern due to their high cost, with different aspects of utilization including Allocation, Kernel, and Model FLOP/s Utilization.
- GPU Allocation Utilization measures the fraction of GPU time spent running application code versus idle time, influenced by economic and operational factors.
- Modal helps improve GPU Allocation Utilization by aggregating demand and supply across clouds, reducing latency in spinning up GPUs for application use.
- GPU Kernel Utilization refers to the time GPUs spend executing kernels (GPU code), with low utilization often due to host overhead or insufficient work provisioning.
- Model FLOP/s Utilization (MFU) measures the efficiency of using the GPU's theoretical arithmetic bandwidth, with high MFU requiring optimized kernels and memory usage.
- Achieving high MFU is challenging, with state-of-the-art training runs achieving 20-41% MFU, while inference may reach higher efficiencies.
- Improving GPU utilization involves optimizing application code, reducing host overhead, using efficient kernels, and leveraging platforms like Modal for better allocation.
Prepare your apps for Google Play's 16 KB page size compatibility requirement
a year ago
- Google Play allows developers to distribute apps and games globally across Android devices.
- Android 15 introduces support for 16 KB memory page sizes to optimize performance on newer devices.
- Starting November 1, 2025, all new or updated apps targeting Android 15+ must support 16 KB page sizes.
- 16 KB page sizes enhance performance, and apps not supporting them may malfunction on future devices.
- Popular SDKs like React Native, Flutter, and Unity already support 16 KB, with Unreal Engine support coming soon.
- Many apps are already compatible, and adjustments for others are expected to be minimal.
- Developers can check app bundle compliance via the Play Console's app bundle explorer.
- Testing apps in a 16 KB environment ensures optimal performance and user experience.
- Detailed technical guidance is available in Google's December blog post and documentation.
21 GB/s CSV Parsing Using SIMD on AMD 9950X
a year ago
- Sep 0.10.0 achieves 21 GB/s CSV parsing speed on AMD 9950X (Zen 5).
- Performance improved from ~7 GB/s (0.1.0) to ~21 GB/s (0.10.0) in under 2 years.
- AVX-512 optimizations and hardware upgrades (Zen 3 to Zen 5) contributed to the speed boost.
- New AVX-512-to-256 parser circumvents .NET 9.0's suboptimal AVX-512 code generation, achieving faster speeds.
- Multi-threaded Sep parses 1 million rows in 72 ms (8 GB/s) on the 9950X.
- Cross-platform Vector256 parser performs on par with AVX2, ensuring broad compatibility.
$20K Bounty Offered for Optimizing Rust Code in Rav1d AV1 Decoder
a year ago
- Announcement of rav1d, a safer high-performance AV1 decoder written in Rust, developed in partnership with Immunant.
- rav1d is now complete, passing all tests like its C-based counterpart dav1d, and can be built and run in Chromium.
- Current challenge: rav1d is about 5% slower than dav1d, hindering adoption and prompting further optimization efforts.
- A $20,000 bounty pool is offered to achieve performance parity between rav1d and dav1d, open to residents of select countries.
- Contest rules specify that improvements must be made to Rust code, the Rust compiler, or standard library, without modifying shared assembly optimizations.
- Participants must merge their improvements into the relevant projects under open-source licenses and follow the contest's entry process.
- Bounty will be distributed proportionally among top contributors based on performance gains, with ISRG reserving final discretion on awards.
Community Stewardship of Faster CPython
a year ago
- Microsoft's support for Faster CPython has been cancelled, impacting Python's performance improvements.
- Python 3.14 is 20-40% faster than 3.10, thanks to contributions from various individuals and organizations.
- Options moving forward include finding another sponsor, shutting down experimental work, or continuing with community stewardship.
- Proposal to transfer Faster CPython to a community-owned model, forming a performance working group (WG) without decision-making power.
- Establish a PSF-owned benchmarking infrastructure and explore JIT design choices prioritizing maintainability over peak performance.
- Form a community council for conflict resolution and technical direction, modeled after the typing council (PEP 729).
- Nomination of initial community WG members, emphasizing diverse backgrounds and contributions to the project.
- Potential for community-led project success, citing examples like PyPy and existing contributors.
- Proposal for an informal WG to facilitate collaboration and discussion on CPython performance, replacing previous corporate-led mediation.
More than you ever wanted to know about font loading on the web (2021)
a year ago
- The post discusses the challenges of web font loading and its impact on Core Web Vitals, specifically Largest Contentful Paint (LCP) and Cumulative Layout Shift (CLS).
- It recommends using `font-display: optional` to improve LCP and CLS by ensuring text renders quickly and avoids layout shifts.
- The post explains scenarios where `font-display: optional` may not be suitable, such as when no viable fallback font exists (e.g., icon fonts).
- It explores the use of `preload` with `font-display: optional`, noting potential trade-offs in bandwidth usage and performance.
- The post highlights changes in browser caching behavior, advising self-hosting fonts or their loading CSS to avoid cross-origin requests.
- A tool is introduced to automatically match fallback fonts to custom fonts, reducing layout shifts when custom fonts load.
- The post mentions new web standards like `size-adjust`, `ascent-override`, and `descent-override` for better font matching.
- A summary emphasizes combining `font-display: optional` with self-hosted CSS for optimal LCP and CLS, while new standards offer additional solutions.
Slack, Notion, and VSCode Improved Electron App Performance
a year ago
- Electron apps can rival native app performance with proper optimization.
- Main performance challenges: slow startup and poor interaction performance.
- Key strategies include using bundlers (Webpack, esbuild, Vite) to replace synchronous `require()` calls.
- Defer non-critical imports using route-based code splitting and async imports.
- Migrate computationally expensive tasks to WebAssembly or native modules for better performance.
- Use V8 snapshots to reduce initialization time, as demonstrated by Atom and VSCode teams.
- Monitor end-user performance metrics like click latency, keypress latency, and scroll latency.
- Implement production JavaScript profiling to identify and fix performance bottlenecks.
- Notion improved performance metrics by 15-20% using production profiling tools like Palette.
A SwiftUI Runtime in C++
a year ago
- Kulve's SwiftUI runtime is a cross-platform, multithreaded, fully async runtime written in C++ with minor Objective-C scaffolding.
- The runtime was developed to optimize performance for Kulve, aiming for a lightweight, fast, and efficient Twitch experience with extended battery life on Apple silicon.
- Performance optimization involved three key steps: eliminating data copies, managing a single instance of all data to avoid ownership issues, and connecting the runtime to SwiftUI using NotificationCenter.
- The runtime uses void* pointers for type erasure and efficient memory management, avoiding the overhead of std::any or std::variant.
- NotificationCenter is utilized to connect the runtime with SwiftUI, enabling direct communication without data copies and providing control over data lifetimes.
- The runtime includes mechanisms to handle thread management, data population, and message sending, with a focus on avoiding race conditions and nullptr dereferences.
- A deferred deallocation strategy is employed to ensure SwiftUI views complete their operations before data sources are deallocated.
- The runtime is part of a recent AppStore submission, with the developer open to discussions about its implementation details.

firstprev0next

About|Login

#performance optimization

Go Optimization Guide

An Interview with Zen Chief Architect Mike Clark

Disk I/O bottlenecks in GitHub Actions

Using Token Sequences to Iterate Ranges

Pdeathsig is almost never what you want

New Apache Cassandra Release Saves 400% IOPS

Get Out of My Head

JavaScript Views, the Hard Way – A Pattern for Writing UI

Optimizing Heap Allocations in Go: A Case Study

Hyperscaling Have I Been Pwned with Cloudflare Workers and Caching

Threaded Code

Optimizing Common Lisp

'I paid for the whole GPU, I am going to use the whole GPU'

Prepare your apps for Google Play's 16 KB page size compatibility requirement

21 GB/s CSV Parsing Using SIMD on AMD 9950X

$20K Bounty Offered for Optimizing Rust Code in Rav1d AV1 Decoder

Community Stewardship of Faster CPython

More than you ever wanted to know about font loading on the web (2021)

Slack, Notion, and VSCode Improved Electron App Performance

A SwiftUI Runtime in C++