How to use FastTuple for off-heap memory in Java?

Use the directMemory() method in the TupleSchema builder to allocate tuples off-heap, and always call destroy() to free memory, as shown in the examples to avoid leaks.

FastTuple vs Java arrays for performance?

FastTuple offers better memory locality and GC reduction for heterogeneous primitives, but Java arrays are simpler and faster for homogeneous data; benchmarks show FastTuple can match or exceed array performance in specific scenarios.

Does FastTuple support string types?

Not currently; support for String is planned for a later release, so it's limited to primitive types like long, int, and double for now.

How to set up FastTuple with Maven given the dependency issue?

You must manually install Janino jars using mvn install:install-file commands provided in the building section, which is more complex than standard Maven dependencies.

Is FastTuple thread-safe for concurrent access?

With cache line padding for off-heap tuples, it can avoid false sharing, but concurrent manipulation requires careful design; pooling is per-thread, which helps reduce contention in high-throughput scenarios.

What performance gains can I expect from FastTuple?

Benchmarks show operations up to millions per millisecond for certain access methods, significantly reducing GC pressure and improving latency, but gains depend on schema design and allocation strategy.

fasttuple — High-Performance Java Primitive Collections

What is fasttuple?

FastTuple is a Java library that generates heterogeneous collections of primitive values with adjacent memory layout, either on-heap or off-heap. It solves the performance problems caused by primitive boxing in the JVM, such as broken locality of reference and increased garbage collection pressure, by ensuring data is stored contiguously for optimal cache efficiency.

Target Audience

Java developers working on high-performance, data-intensive applications, such as financial systems, real-time analytics, or low-latency services, where memory efficiency and reduced GC pauses are critical.

Value Proposition

Developers choose FastTuple for its ability to drastically improve memory locality and reduce garbage collection overhead through bytecode-generated, schema-defined tuples. Its support for off-heap storage and pooling makes it uniquely suited for scenarios where traditional Java collections fall short on performance.

Overview

FastTuple is a Java library designed to overcome the performance limitations of primitive boxing in the JVM by generating heterogeneous collections of primitive values that are laid out adjacently in memory. It addresses issues of memory locality and garbage collection pressure, making it suitable for high-performance computing and data-intensive applications.

Key Features

Adjacent Memory Layout — Stores primitive values contiguously in memory to optimize cache locality and access speed.
On-Heap and Off-Heap Storage — Supports both heap-allocated tuples and direct memory allocation using Java's off-heap capabilities.
Runtime Bytecode Generation — Dynamically generates Java classes based on user-defined schemas of field names and primitive types.
Tuple Pooling — Includes a pooling mechanism to reduce garbage collection overhead and improve performance in high-throughput scenarios.
Cache Line Padding — Allows off-heap tuples to be padded to avoid false sharing in concurrent multi-threaded environments.
Multiple Access Methods — Provides static binding, indexed accessors, and dynamic invocation techniques for flexible tuple manipulation.

Philosophy

FastTuple prioritizes performance and memory efficiency by minimizing JVM overhead, leveraging bytecode generation to create optimized data structures that respect hardware memory hierarchies.

fasttuple

What is fasttuple?

Overview

Key Features

Philosophy

Related Projects

Found a gem we're missing?

Use Cases

Best For

Not Ideal For

Pros & Cons

Pros

Cons

Frequently Asked Questions