Boosting Java Performance: A Comparative Analysis of High-Performance Libraries

Introduction

Java is a versatile and widely used programming language, known for its robustness and cross-platform compatibility. One of the critical components of Java is its Collections Framework, which provides a standard set of data structures and algorithms to developers. However, the performance of Java's built-in collections might not always be sufficient for high-performance applications. This is where specialized libraries like HPPC (High Performance Primitive Collections) come into play.

This article presents an overview of a comparative benchmark study performed on various Java libraries, including HPPC, FastUtil, and Primitive Collections. The benchmarks were performed using Jmh version 1.35 and JDK 17.0.2 Java HotSpot(TM) on a Ryzen 9 7900 processor. The goal of this study was to illustrate how these libraries can improve the performance of Java applications, sometimes by a factor of more than 100 times, compared to using Java's built-in collections.

Methodology

Each benchmark focused on the amount of time it took to perform each operation in microseconds. The operations tested included "add", "contains", "get", "indexOf", "iterateForEach", "iterateForLoop", "iterateIndex", "iterateStream", "lastIndexOf", and "remove". Each operation was tested on collection sizes of 100, 1,000, and 10,000 elements.

Key Findings

The study revealed significant performance differences between the libraries and Java's built-in collections. For instance:

1. Add Operation: For an ArrayList of size 10,000, the Java built-in collections took 4,370,611 microseconds to perform the "add" operation. In contrast, HPPC took 2,251,535 microseconds, FastUtil took 377,974 microseconds, and Primitive Collections took 377,885 microseconds.
2. Contains Operation: For the "contains" operation on an ArrayList of size 10,000, the Java built-in collections took a staggering 65,689,478 microseconds, while HPPC, FastUtil, and Primitive Collections performed the same operation in 14,343,377 microseconds, 14,387,613 microseconds, and 14,386,189 microseconds, respectively.
3. Get Operation: For the "get" operation on an ArrayList of size 10,000, the Java built-in collections took 15,653 microseconds. HPPC performed the same operation much faster, taking only 13,094 microseconds, while FastUtil and Primitive Collections took 15,274 microseconds and 15,598 microseconds, respectively.
4. Remove Operation: The "remove" operation showed an even more significant performance gap. For an ArrayList of size 10,000, the Java built-in collections took 99,444,316 microseconds, while HPPC completed the operation in 21,364,139 microseconds. FastUtil and Primitive Collections took 21,495,868 microseconds and 21,114,303 microseconds, respectively.

The benchmark study clearly illustrates that using specialized libraries like HPPC can significantly improve Java application performance, sometimes by a factor of more than 100 times, compared to using Java's built-in collections.

However, developers should note that the exact performance gain may depend on the specific operation and the size of the collection. Different libraries may also offer varying performance benefits for different operations.

What is HPPC?

HPPC is a Java library designed to provide high-performance, efficient collections of primitive types. It was created as a response to the perceived inefficiencies of standard Java collections when dealing with primitive data types.

While Java collections are robust and versatile, they were designed to hold objects, not primitive types. When you use a primitive type with a standard Java collection, the Java compiler automatically "boxes" that primitive into its wrapper class (for example, an int becomes an Integer). This boxing and unboxing process can be a significant source of inefficiency in high-performance applications.

HPPC provides a set of collection classes that are designed to hold primitive types directly, eliminating the need for boxing and unboxing and thereby increasing performance.

HPPC in Practice: Examples

Let's take a look at some examples of how HPPC can be used in place of standard Java collections to increase performance.

Example 1: Using HPPC's IntArrayList

In standard Java, if you want to create a list of integers, you might use an ArrayList<Integer>. However, this involves boxing each int into an Integer. With HPPC, you can use an IntArrayList instead:

import com.carrotsearch.hppc.IntArrayList;

IntArrayList list = new IntArrayList();
list.add(1);
list.add(2);
list.add(3);

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}        

In this example, the IntArrayList directly holds the int values, and there is no need to box them into Integer objects.

Example 2: Using HPPC's IntObjectHashMap

Similarly, if you want to create a map with integer keys in standard Java, you might use a HashMap<Integer, Object>. Again, this involves boxing each int into an Integer. With HPPC, you can use an IntObjectHashMap instead:

import com.carrotsearch.hppc.IntObjectHashMap;

IntObjectHashMap<String> map = new IntObjectHashMap<>();
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");

for (IntObjectCursor<String> cursor : map) {
    System.out.println(cursor.key + ": " + cursor.value);
}        

In this example, the IntObjectHashMap directly holds the int keys, and there is no need to box them into Integer objects.

Conclusion

For high-performance applications where every microsecond counts, using a library like HPPC can be a game changer. It offers a familiar API, similar to the standard Java collections, but with the added benefit of increased performance when dealing with primitive data types. Whether you're building a real-time trading system, a high-speed game engine, or any other performance-critical application, HPPC is a tool worth considering.

References