JEP draft: Efficient array comparison intrinsics
(rough draft; needs formatting; see http://cr.openjdk.java.net/~mr/jep/jep-2.0-02.html)
There are efficient operations (both safe and unsafe) for copying arrays, but none for comparing them. Let's fix this so users don't have to roll their own.
At a minimum, the following intrinsic would allow suitable higher-level comparison operations to be implemented:
/** Find the index of a mismatch between src and dest, or -1 if none. */ System.arrayMismatch((Object src, int srcPos, Object dest, int destPos, int length, boolean fromEnd);
- Returns an index in src of an element which differs from the corresponding element in dest, if such an element exists.
- If no such element exists, returns
- If fromEnd is true, returns the index of the last differing element, else returns the first.
- Correspondences between elements are as for System.arraycopy.
- The result will be either
-1or a value between
- Exceptions are as for
- The arrays must have compatible element types, either both the same primitive type or both reference types.
- Comparisons are done as if by the Java
- In particular references to different objects differ, even if
Object.equalswould return true.
- Also, floating point
NaNs always differ, even from themselves.
This mechanism is easy to code and easy to vectorize. Most higher-level array comparison operations can readily be built on top of it.
Basic comparison operations (at least lexicographic
compareTo) using it should be added to
String.compareTo can be re-implemented on top of this intrinsic.
Methods of the form
String.mismatchTo should be added.
As a possible follow-up,
System.arrayIndexOf could be added to perform a vectorized non-anchored search of one array inside another. This loop is less interesting, however, since it would be too narrow for some use cases involving
NaNs, structural object comparisons, or case-insensitive searches.