Hasty Briefsbeta

All tags

#performance

528 stories total

Bilingual

lsr: ls with io_uring
10 months ago
- lsr is a command-line tool similar to ls but optimized with io_uring.
- Installation requires Zig 0.14.0 and can be done via `zig build` with specific flags.
- Usage includes various display options like `--all`, `--long`, and sorting flags.
- Benchmarks show lsr outperforms other tools like ls, eza, lsd, and busybox in speed and syscall efficiency.
- Performance metrics are provided for different file counts, highlighting lsr's efficiency with io_uring.
Fcrand (Go language): drop-in replacement for crypto/rand, up to 10x faster
10 months ago
- fcrand is a high-performance drop-in replacement for Go's crypto/rand.
- It offers up to 10x faster performance for random data requests ≤512 bytes while maintaining cryptographic security.
- 100% API compatible with crypto/rand, making it a true drop-in replacement.
- Thread-safe with zero configuration, same as crypto/rand.
- Install via `go get -u github.com/sdrapkin/fcrand` and import as `rand "github.com/sdrapkin/fcrand"`.
- FIPS-140 ready, with environment variable `GODEBUG=fips140=on`.
- Performance benchmarks show significant speedups for small requests, with fallback to crypto/rand levels at 512+ bytes.
- Includes additional methods like `.Text()` and `.Prime()` for enhanced functionality.
Subreply – an open source text-only social network
9 months ago
- Tiny, but mighty social network available at subreply.com
- Install dependencies using pip3 install -r requirements.txt
- Run database migrations with python3 manage.py migrate
- Create project/local.py file and generate SIGNATURE using cryptography.fernet
- Performance target: speed of 50ms or lower for each page request
- Code quality: clean, easy to read, and easy to modify
Optimizations That Aren't
9 months ago
- Optimization should not be done for its own sake as it can reduce code readability and introduce bugs.
- Follow a structured optimization process: ensure code works, measure performance precisely, verify against requirements, record results, optimize, and re-verify.
- Always profile before and after optimizations to confirm improvements and avoid performance regressions.
- A real-world example highlights the dangers of optimization without profiling, leading to quadratic complexity in a COLLADA Exporter.
- Optimization without prior and post profiling is ineffective and can degrade performance significantly.
RE#: high performance derivative-based regex matching with intersection, complem
9 months ago
- RE# is a tool for regular expression matching based on symbolic derivatives.
- It avoids backtracking and supports complement, intersection, and lookarounds.
- The matching algorithm has input-linear complexity, both theoretically and experimentally.
- RE# is over 71% faster than the next fastest regex engine in Rust on baseline tests.
- It outperforms state-of-the-art engines on extended benchmarks, often by orders of magnitude.
Show HN: Pogocache – Fast caching software
9 months ago
- Pogocache is a fast, efficient caching software designed for low latency and CPU efficiency.
- It outperforms other caching solutions like Memcache, Valkey, Redis, Dragonfly, and Garnet in speed and efficiency.
- Pogocache supports multiple wire protocols including Memcache, Valkey/Redis, HTTP, and Postgres, making it versatile.
- It can be run as a server-based program or embedded directly into existing software for higher performance.
- Pogocache is optimized for both single-threaded and multithreaded performance, scaling well with core count.
- Security features include TLS support and optional authentication for secure connections.
- The software is designed for 64-bit Linux and MacOS systems.
- Pogocache includes features like memory eviction policies, expiration of entries, and efficient memory usage.
- Future roadmap includes domain-specific integrations, shared memory access, and enterprise tooling.
- Pogocache is open-source under AGPL license, with commercial support options available.
Common Expression Language – Fast, safe expression language
9 months ago
- Common Expression Language (CEL) is a fast, portable, and safe expression language.
- CEL is designed for embedding in applications with specific extensions.
- Ideal for extending declarative configurations in performance-critical applications.
- Use cases include list filters, validation constraints, and authorization rules.
- CEL evaluates safely and quickly, suitable for frequent evaluation scenarios.
- Best for applications where expressions are evaluated often but modified rarely.
- Example use case: evaluating HTTP requests against security policies.
- CEL overview and language definition available for further exploration.
Show HN: Go Command-streaming lib for distributed systems (3x faster than gRPC)
9 months ago
- cmd-stream-go is a high-performance, modular client–server library for Go based on the Command Pattern.
- Supports efficient, low-latency communication over TCP/TLS with streaming and observability.
- Client sends Commands to the server, where an Invoker executes them, and a Receiver provides server-side functionality.
- Features include TCP/TLS/mTLS support, asynchronous client, server streaming, reconnect, keepalive, Circuit Breaker pattern, OpenTelemetry integration, and modular design.
- High code coverage (90%) in submodules and basic integration tests in the main module.
- Performance optimization tips: use N parallel connections, pre-establish connections, keep connections alive.
- Can be used as a faster transport layer for existing RPC systems.
- Modular architecture includes core-go, delegate-go, handler-go, and transport-go submodules.
- Designed for easy replacement of any part of the library.
Pogocache 1.0 – Claims Better Performance Than Memcache, Valkey and Redis
9 months ago
- Pogocache 1.0 was released as a fast open-source caching software.
- It claims better performance than Memcache, Valkey, Redis, Garnet, and Dragonfly.
- Supports multiple protocols: Memcache, Valkey, Redis, HTTP, and Postgres.
- Written in C and available under AGPLv3 license.
- Performance benchmarks and future success compared to competitors remain to be seen.
Hyperpb: 10x faster dynamic Protobuf parsing that's faster than generated code
9 months ago
- hyperpb is a fully-dynamic Protobuf parser that is 10x faster than dynamicpb and 3x faster than parsing with generated code.
- It matches or beats vtprotobuf’s generated code in benchmarks without compromising correctness.
- hyperpb enables processing and validating large amounts of arbitrary streamed data in a type-aware manner.
- It was developed to solve bottlenecks encountered while building Bufstream, enabling broker-side validation with Protobuf.
- hyperpb supports all proto2, proto3, and editions-mode schemas, matching Protobuf Go perfectly.
- The parser requires compilation at runtime, similar to a regular expression library, and includes advanced features like profile-guided optimization.
- hyperpb is open-sourced to foster wider Protobuf adoption and to engage with the community for further improvements.
- Buf is hiring for those interested in working on novel projects like hyperpb.
Show HN: Quite Fast, sharded cache for Go with LRU/LFU, TTL and object pooling
9 months ago
- Kioshun cache library benchmark results show high performance with up to 326M+ operations/sec for GET operations.
- Installation is simple with `go get github.com/unkn0wn-root/kioshun`.
- Quick start example demonstrates basic cache operations like Set, Get, and Delete.
- Configuration options include MaxSize, ShardCount, CleanupInterval, DefaultTTL, and EvictionPolicy.
- Architecture is sharded to minimize lock contention, with automatic sharding and optimal shard count based on CPU cores.
- API Reference includes methods like Set, Get, Delete, Exists, Clear, Size, Stats, and Close.
- HTTP Middleware supports various frameworks (Gin, Echo, Chi, Gorilla Mux) with configurable caching policies.
- Cache Invalidation Setup requires path-based key generators for pattern-based invalidation to work.
XOR_singleheader: Header-only binary fuse and XOR filter library
9 months ago
- Bloom filters are used to quickly check set membership, but xor filters and binary fuse filters are faster and more concise alternatives.
- Binary fuse filters and xor filters are naturally compressible and smaller than cuckoo filters.
- The library is header-only, implements both binary fuse and xor filters, and is available under the Apache license.
- Basic usage involves allocating, populating, and querying the filter with functions like `binary_fuse8_allocate`, `binary_fuse8_populate`, and `binary_fuse8_contain`.
- There are 8-bit and 16-bit versions, with the 16-bit version offering lower false-positive probability at the cost of more memory.
- Serialization options include unpacked (faster) and packed (smaller but slower) formats.
- Construction of binary fuse filters requires temporary memory (~24 bytes per entry), but can be done with minimal temporary memory at a slower speed.
- The library includes testing and benchmarking tools to evaluate performance and correctness.
- Bug reports and fixes are encouraged, but the project does not aim to be warning-free under all static analyzers.
New Aarch64 Back End
9 months ago
- New Aarch64 Backend introduced by Andrew Kelley & Jacob Young, passing 79% of behavior tests with significant performance improvements.
- Zig Roadmap 2026 discussed in a scheduled Zig SHOWTIME episode.
- Parallel Self-Hosted Code Generation implemented, improving compilation speed by 5% to 50%.
- Self-Hosted x86 Backend now default in Debug mode, outperforming LLVM in compilation speed.
- Intro to the Zig Build System video released by Loris Cro, explaining package creation and module import.
- FreeBSD and NetBSD Cross-Compilation Support added, enabling binary builds for these targets.
- Website updated to Zine 0.10.0, transitioning to a standalone executable with new features.
- Improved UBSan Error Messages now provide clear diagnostics for undefined behavior in C interop.
- No-Libc Zig now outperforms Glibc Zig in memory allocation and performance benchmarks.
- LLDB Fork for Zig developed by Alex Rønne Petersen, enhancing debugging support for self-hosted backends.
High-Performance Shell Kit
9 months ago
- Developers face issues with slow and bloated command-line shells.
- Popular frameworks like Oh My Zsh cause startup delays and complexity.
- Users must choose between poor performance or manual configuration.
- A high-performance shell kit offers a pre-configured, lightweight solution.
- Includes best-in-class tools for prompt customization, fuzzy search, and auto-suggestions.
- Provides a fast, powerful, and ready-to-use terminal experience.
- Eliminates bloat and manual setup hassle with a simple installer.
Final Benchmarks of Clear Linux on Intel: ~48% Faster Than Ubuntu Out-of-the-Box
9 months ago
- Intel has discontinued the Clear Linux project, a high-performance Linux distribution optimized for x86_64 processors.
- Clear Linux was known for aggressive compiler tuning, kernel patches, and system-wide optimizations, leading in performance on both Intel and AMD hardware.
- Final benchmarks show Clear Linux is ~48% faster than Ubuntu 25.04 out-of-the-box on Intel Xeon Max servers.
- Clear Linux was heavily optimized for AVX-512 and newer Intel ISA features, making it ideal for high-performance computing.
- Benchmarks were conducted on a Supermicro Hyper SuperServer with dual Xeon Max 9468 processors, 512GB RAM, and NVMe storage.
- Clear Linux 43760 used Linux 6.15.5 kernel, GCC 15.1.1, and Python 3.13, while Ubuntu 25.04 used Linux 6.14, GCC 14.2, and Python 3.13.
- Ubuntu 25.04 defaults to 'schedutil' governor, which can impact performance compared to Clear Linux's 'performance' governor.
- Power consumption was monitored to assess the impact of Clear Linux's optimizations on CPU efficiency.
Breaking the WASM/JS communication performance barrier
9 months ago
- Sledgehammer bindgen provides faster Rust batched bindings for JS code.
- wasm-bindgen is more general, allowing returning values and handling various types; better for most users.
- Sledgehammer is designed for web frameworks needing low-level, fast DOM access.
- Sledgehammer can be used alongside wasm-bindgen.
- String decoding is expensive; wasm-bindgen calls TextDecoder.decode per string, while Sledgehammer calls it once per batch.
- For small strings, decoding in JavaScript is faster to avoid TextDecoder.decode overhead.
- Benchmark link provided for performance comparison.
- Caching strings in JavaScript avoids repeated decoding.
- Static strings in Sledgehammer are hashed by pointer, not value.
- Operations in Sledgehammer are encoded as byte sequences, packed into arrays.
- Operations are batched in fours as u32, optimizing read costs.
- Benchmark link provided for operation encoding efficiency.
Constrained languages are easier to optimize
9 months ago
- Modern low-level languages are hard to optimize due to complex alias analysis and memory allocation/deallocation.
- Haskell's referential transparency allows for easier optimizations like stream fusion, unlike C which struggles with pointer aliasing.
- Futhark, a functional parallel language, achieves high performance by using unboxed fixed-size integers and static array size constraints.
- SQL's declarative nature allows for significant performance improvements over time, as seen in Postgres benchmarks.
- Raw pointers are sometimes necessary for specific memory optimizations, but their use should be minimized in general-purpose languages.
- Rust is a step in the right direction with opt-in raw pointers and functional paradigms that enable optimizations.
- The future lies in meta-languages that facilitate easy interoperation between specialized languages for optimal performance.
Disabling telemetry in ByteDance's VSCode fork increases data sent to its server
9 months ago
- Trae IDE, ByteDance's fork of Visual Studio Code, exhibits excessive resource consumption with 33 processes vs. 9 in VSCode.
- Persistent telemetry transmission occurs despite user settings being disabled, sending data to ByteDance servers.
- Community management practices include censorship, with keywords like 'track' triggering automatic mutes.
- Telemetry captures detailed system info, usage patterns, performance metrics, and unique identifiers.
- Resource usage is 6x higher than VSCode, and telemetry settings appear non-functional.
- Data collection lacks transparency, with information routed to ByteDance infrastructure.
The Useless UseCallback
9 months ago
- The article discusses the overuse and often unnecessary application of `useCallback` and `useMemo` in React for performance optimization.
- Memoization is primarily used for two reasons: performance optimization to avoid unnecessary re-renders and to prevent effects from firing too often by maintaining referential stability.
- The article highlights scenarios where memoization is pointless, such as when passing callbacks to non-memoized components or React built-in components that don't rely on referential stability.
- A common pitfall is using non-primitive props as dependencies in internal hooks, which can break memoization if the props aren't stable, leading to unnecessary re-renders or effect executions.
- The article provides a real-life example from the Sentry codebase where nested dependencies break memoization chains, making the initial memoizations useless.
- Alternatives to excessive memoization are suggested, including the 'Latest Ref Pattern' and the upcoming React feature `useEffectEvent`, which aims to simplify managing dependencies in effects without manual memoization.
- The author advocates for reducing reliance on memoization due to its complexity and fragility, suggesting that future compiler optimizations or React features could handle these cases more effectively.
Lance v2: A columnar container format for modern data (2024)
9 months ago
- Lance v2 is introduced to address inefficiencies in AI/ML workloads that existing formats like Parquet struggle with.
- Key use cases for Lance v2 include point lookups, wide columns, very wide schemas, flexible encodings, and flexible metadata.
- Lance v2 eliminates row groups, optimizing for ideal page sizes and decoupling I/O and compute for better performance.
- The format allows columns to be of different lengths and supports writing data 'array at a time' or 'batch at a time'.
- Lance v2 treats encodings as extensions, making it easy to add new encodings without modifying the file format.
- The format does not enforce a type system, keeping the specification simple and avoiding ecosystem fragmentation.
- Flexibility in data placement (page buffer, column buffer, file buffer) enables new use cases beyond traditional tabular data.
- Statistics in Lance v2 are part of the encoding process, allowing for various forms like zone maps and bloom filters.
- The initial implementation of Lance v2 is available, with performance on par with the best Parquet readers.
- Community help is sought for additional use cases, benchmarks, integration tests, and ecosystem integrations.

first prev8next

About|Login

#performance

lsr: ls with io_uring

Fcrand (Go language): drop-in replacement for crypto/rand, up to 10x faster

Subreply – an open source text-only social network

Optimizations That Aren't

RE#: high performance derivative-based regex matching with intersection, complem

Show HN: Pogocache – Fast caching software

Common Expression Language – Fast, safe expression language

Show HN: Go Command-streaming lib for distributed systems (3x faster than gRPC)

Pogocache 1.0 – Claims Better Performance Than Memcache, Valkey and Redis

Hyperpb: 10x faster dynamic Protobuf parsing that's faster than generated code

Show HN: Quite Fast, sharded cache for Go with LRU/LFU, TTL and object pooling

XOR_singleheader: Header-only binary fuse and XOR filter library

New Aarch64 Back End

High-Performance Shell Kit

Final Benchmarks of Clear Linux on Intel: ~48% Faster Than Ubuntu Out-of-the-Box

Breaking the WASM/JS communication performance barrier

Constrained languages are easier to optimize

Disabling telemetry in ByteDance's VSCode fork increases data sent to its server

The Useless UseCallback

Lance v2: A columnar container format for modern data (2024)