8213035: Pack MethodHandleInlineStrategy coder and length into a long
Reviewed-by: vlivanov, mchung
--- a/src/java.base/share/classes/java/lang/StringConcatHelper.java Tue Oct 30 09:06:08 2018 +0100
+++ b/src/java.base/share/classes/java/lang/StringConcatHelper.java Tue Oct 30 09:34:50 2018 +0100
@@ -37,119 +37,104 @@
}
/**
- * Check for overflow, throw the exception on overflow.
- * @param len String length
- * @return length
+ * Check for overflow, throw exception on overflow.
+ * @param lengthCoder String length and coder
+ * @return lengthCoder
*/
- private static int checkOverflow(int len) {
- if (len < 0) {
- throw new OutOfMemoryError("Overflow: String length out of range");
+ private static long checkOverflow(long lengthCoder) {
+ if ((int)lengthCoder >= 0) {
+ return lengthCoder;
}
- return len;
+ throw new OutOfMemoryError("Overflow: String length out of range");
}
/**
- * Mix value length into current length
+ * Mix value length and coder into current length and coder.
* @param current current length
* @param value value to mix in
- * @return new length
+ * @return new length and coder
*/
- static int mixLen(int current, boolean value) {
+ static long mix(long current, boolean value) {
return checkOverflow(current + (value ? 4 : 5));
}
/**
- * Mix value length into current length
+ * Mix value length and coder into current length and coder.
* @param current current length
* @param value value to mix in
- * @return new length
+ * @return new length and coder
*/
- static int mixLen(int current, byte value) {
- return mixLen(current, (int)value);
+ static long mix(long current, byte value) {
+ return mix(current, (int)value);
}
/**
- * Mix value length into current length
+ * Mix value length and coder into current length and coder.
* @param current current length
* @param value value to mix in
- * @return new length
+ * @return new length and coder
*/
- static int mixLen(int current, char value) {
- return checkOverflow(current + 1);
+ static long mix(long current, char value) {
+ return checkOverflow(current + 1) | (StringLatin1.canEncode(value) ? 0 : UTF16);
}
/**
- * Mix value length into current length
+ * Mix value length and coder into current length and coder.
* @param current current length
* @param value value to mix in
- * @return new length
+ * @return new length and coder
*/
- static int mixLen(int current, short value) {
- return mixLen(current, (int)value);
+ static long mix(long current, short value) {
+ return mix(current, (int)value);
}
/**
- * Mix value length into current length
+ * Mix value length and coder into current length and coder.
* @param current current length
* @param value value to mix in
- * @return new length
+ * @return new length and coder
*/
- static int mixLen(int current, int value) {
+ static long mix(long current, int value) {
return checkOverflow(current + Integer.stringSize(value));
}
/**
- * Mix value length into current length
+ * Mix value length and coder into current length and coder.
* @param current current length
* @param value value to mix in
- * @return new length
+ * @return new length and coder
*/
- static int mixLen(int current, long value) {
+ static long mix(long current, long value) {
return checkOverflow(current + Long.stringSize(value));
}
/**
- * Mix value length into current length
+ * Mix value length and coder into current length and coder.
* @param current current length
* @param value value to mix in
- * @return new length
- */
- static int mixLen(int current, String value) {
- return checkOverflow(current + value.length());
- }
-
- /**
- * Mix coder into current coder
- * @param current current coder
- * @param value value to mix in
- * @return new coder
+ * @return new length and coder
*/
- static byte mixCoder(byte current, char value) {
- return (byte)(current | (StringLatin1.canEncode(value) ? 0 : 1));
- }
-
- /**
- * Mix coder into current coder
- * @param current current coder
- * @param value value to mix in
- * @return new coder
- */
- static byte mixCoder(byte current, String value) {
- return (byte)(current | value.coder());
+ static long mix(long current, String value) {
+ current += value.length();
+ if (value.coder() == String.UTF16) {
+ current |= UTF16;
+ }
+ return checkOverflow(current);
}
/**
* Prepends the stringly representation of boolean value into buffer,
* given the coder and final index. Index is measured in chars, not in bytes!
*
- * @param index final char index in the buffer
- * @param buf buffer to append to
- * @param coder coder to add with
- * @param value boolean value to encode
- * @return new index
+ * @param indexCoder final char index in the buffer, along with coder packed
+ * into higher bits.
+ * @param buf buffer to append to
+ * @param value boolean value to encode
+ * @return updated index (coder value retained)
*/
- static int prepend(int index, byte[] buf, byte coder, boolean value) {
- if (coder == String.LATIN1) {
+ static long prepend(long indexCoder, byte[] buf, boolean value) {
+ int index = (int)indexCoder;
+ if (indexCoder < UTF16) {
if (value) {
buf[--index] = 'e';
buf[--index] = 'u';
@@ -162,6 +147,7 @@
buf[--index] = 'a';
buf[--index] = 'f';
}
+ return index;
} else {
if (value) {
StringUTF16.putChar(buf, --index, 'e');
@@ -175,72 +161,72 @@
StringUTF16.putChar(buf, --index, 'a');
StringUTF16.putChar(buf, --index, 'f');
}
+ return index | UTF16;
}
- return index;
}
/**
* Prepends the stringly representation of byte value into buffer,
* given the coder and final index. Index is measured in chars, not in bytes!
*
- * @param index final char index in the buffer
- * @param buf buffer to append to
- * @param coder coder to add with
- * @param value byte value to encode
- * @return new index
+ * @param indexCoder final char index in the buffer, along with coder packed
+ * into higher bits.
+ * @param buf buffer to append to
+ * @param value byte value to encode
+ * @return updated index (coder value retained)
*/
- static int prepend(int index, byte[] buf, byte coder, byte value) {
- return prepend(index, buf, coder, (int)value);
+ static long prepend(long indexCoder, byte[] buf, byte value) {
+ return prepend(indexCoder, buf, (int)value);
}
/**
* Prepends the stringly representation of char value into buffer,
* given the coder and final index. Index is measured in chars, not in bytes!
*
- * @param index final char index in the buffer
- * @param buf buffer to append to
- * @param coder coder to add with
- * @param value char value to encode
- * @return new index
+ * @param indexCoder final char index in the buffer, along with coder packed
+ * into higher bits.
+ * @param buf buffer to append to
+ * @param value char value to encode
+ * @return updated index (coder value retained)
*/
- static int prepend(int index, byte[] buf, byte coder, char value) {
- if (coder == String.LATIN1) {
- buf[--index] = (byte) (value & 0xFF);
+ static long prepend(long indexCoder, byte[] buf, char value) {
+ if (indexCoder < UTF16) {
+ buf[(int)(--indexCoder)] = (byte) (value & 0xFF);
} else {
- StringUTF16.putChar(buf, --index, value);
+ StringUTF16.putChar(buf, (int)(--indexCoder), value);
}
- return index;
+ return indexCoder;
}
/**
* Prepends the stringly representation of short value into buffer,
* given the coder and final index. Index is measured in chars, not in bytes!
*
- * @param index final char index in the buffer
- * @param buf buffer to append to
- * @param coder coder to add with
- * @param value short value to encode
- * @return new index
+ * @param indexCoder final char index in the buffer, along with coder packed
+ * into higher bits.
+ * @param buf buffer to append to
+ * @param value short value to encode
+ * @return updated index (coder value retained)
*/
- static int prepend(int index, byte[] buf, byte coder, short value) {
- return prepend(index, buf, coder, (int)value);
+ static long prepend(long indexCoder, byte[] buf, short value) {
+ return prepend(indexCoder, buf, (int)value);
}
/**
* Prepends the stringly representation of integer value into buffer,
* given the coder and final index. Index is measured in chars, not in bytes!
*
- * @param index final char index in the buffer
- * @param buf buffer to append to
- * @param coder coder to add with
- * @param value integer value to encode
- * @return new index
+ * @param indexCoder final char index in the buffer, along with coder packed
+ * into higher bits.
+ * @param buf buffer to append to
+ * @param value integer value to encode
+ * @return updated index (coder value retained)
*/
- static int prepend(int index, byte[] buf, byte coder, int value) {
- if (coder == String.LATIN1) {
- return Integer.getChars(value, index, buf);
+ static long prepend(long indexCoder, byte[] buf, int value) {
+ if (indexCoder < UTF16) {
+ return Integer.getChars(value, (int)indexCoder, buf);
} else {
- return StringUTF16.getChars(value, index, buf);
+ return StringUTF16.getChars(value, (int)indexCoder, buf) | UTF16;
}
}
@@ -248,17 +234,17 @@
* Prepends the stringly representation of long value into buffer,
* given the coder and final index. Index is measured in chars, not in bytes!
*
- * @param index final char index in the buffer
- * @param buf buffer to append to
- * @param coder coder to add with
- * @param value long value to encode
- * @return new index
+ * @param indexCoder final char index in the buffer, along with coder packed
+ * into higher bits.
+ * @param buf buffer to append to
+ * @param value long value to encode
+ * @return updated index (coder value retained)
*/
- static int prepend(int index, byte[] buf, byte coder, long value) {
- if (coder == String.LATIN1) {
- return Long.getChars(value, index, buf);
+ static long prepend(long indexCoder, byte[] buf, long value) {
+ if (indexCoder < UTF16) {
+ return Long.getChars(value, (int)indexCoder, buf);
} else {
- return StringUTF16.getChars(value, index, buf);
+ return StringUTF16.getChars(value, (int)indexCoder, buf) | UTF16;
}
}
@@ -266,39 +252,49 @@
* Prepends the stringly representation of String value into buffer,
* given the coder and final index. Index is measured in chars, not in bytes!
*
- * @param index final char index in the buffer
- * @param buf buffer to append to
- * @param coder coder to add with
- * @param value String value to encode
- * @return new index
+ * @param indexCoder final char index in the buffer, along with coder packed
+ * into higher bits.
+ * @param buf buffer to append to
+ * @param value String value to encode
+ * @return updated index (coder value retained)
*/
- static int prepend(int index, byte[] buf, byte coder, String value) {
- index -= value.length();
- value.getBytes(buf, index, coder);
- return index;
+ static long prepend(long indexCoder, byte[] buf, String value) {
+ indexCoder -= value.length();
+ if (indexCoder < UTF16) {
+ value.getBytes(buf, (int)indexCoder, String.LATIN1);
+ } else {
+ value.getBytes(buf, (int)indexCoder, String.UTF16);
+ }
+ return indexCoder;
}
/**
* Instantiates the String with given buffer and coder
- * @param buf buffer to use
- * @param index remaining index
- * @param coder coder to use
- * @return String resulting string
+ * @param buf buffer to use
+ * @param indexCoder remaining index (should be zero) and coder
+ * @return String resulting string
*/
- static String newString(byte[] buf, int index, byte coder) {
+ static String newString(byte[] buf, long indexCoder) {
// Use the private, non-copying constructor (unsafe!)
- if (index != 0) {
- throw new InternalError("Storage is not completely initialized, " + index + " bytes left");
+ if (indexCoder == LATIN1) {
+ return new String(buf, String.LATIN1);
+ } else if (indexCoder == UTF16) {
+ return new String(buf, String.UTF16);
+ } else {
+ throw new InternalError("Storage is not completely initialized, " + (int)indexCoder + " bytes left");
}
- return new String(buf, coder);
}
+ private static final long LATIN1 = (long)String.LATIN1 << 32;
+
+ private static final long UTF16 = (long)String.UTF16 << 32;
+
/**
* Provides the initial coder for the String.
- * @return initial coder
+ * @return initial coder, adjusted into the upper half
*/
- static byte initialCoder() {
- return String.COMPACT_STRINGS ? String.LATIN1 : String.UTF16;
+ static long initialCoder() {
+ return String.COMPACT_STRINGS ? LATIN1 : UTF16;
}
}
--- a/src/java.base/share/classes/java/lang/invoke/StringConcatFactory.java Tue Oct 30 09:06:08 2018 +0100
+++ b/src/java.base/share/classes/java/lang/invoke/StringConcatFactory.java Tue Oct 30 09:34:50 2018 +0100
@@ -318,6 +318,13 @@
}
@Override
+ public String toString() {
+ return "Recipe{" +
+ "elements=" + elements +
+ '}';
+ }
+
+ @Override
public int hashCode() {
return elements.hashCode();
}
@@ -368,6 +375,15 @@
}
@Override
+ public String toString() {
+ return "RecipeElement{" +
+ "value='" + value + '\'' +
+ ", argPos=" + argPos +
+ ", tag=" + tag +
+ '}';
+ }
+
+ @Override
public int hashCode() {
return (int)tag;
}
@@ -1520,24 +1536,24 @@
}
// Start building the combinator tree. The tree "starts" with (<parameters>)String, and "finishes"
- // with the (int, byte[], byte)String in String helper. The combinators are assembled bottom-up,
- // which makes the code arguably hard to read.
+ // with the (byte[], long)String shape to invoke newString in StringConcatHelper. The combinators are
+ // assembled bottom-up, which makes the code arguably hard to read.
// Drop all remaining parameter types, leave only helper arguments:
MethodHandle mh;
- mh = MethodHandles.dropArguments(NEW_STRING, 3, ptypes);
+ mh = MethodHandles.dropArguments(NEW_STRING, 2, ptypes);
- // Mix in prependers. This happens when (byte[], int, byte) = (storage, index, coder) is already
- // known from the combinators below. We are assembling the string backwards, so "index" is the
- // *ending* index.
+ // Mix in prependers. This happens when (byte[], long) = (storage, indexCoder) is already
+ // known from the combinators below. We are assembling the string backwards, so the index coded
+ // into indexCoder is the *ending* index.
for (RecipeElement el : recipe.getElements()) {
// Do the prepend, and put "new" index at index 1
switch (el.getTag()) {
case TAG_CONST: {
- MethodHandle prepender = MethodHandles.insertArguments(prepender(String.class), 3, el.getValue());
+ MethodHandle prepender = MethodHandles.insertArguments(prepender(String.class), 2, el.getValue());
mh = MethodHandles.filterArgumentsWithCombiner(mh, 1, prepender,
- 1, 0, 2 // index, storage, coder
+ 1, 0 // indexCoder, storage
);
break;
}
@@ -1545,8 +1561,8 @@
int pos = el.getArgPos();
MethodHandle prepender = prepender(ptypes[pos]);
mh = MethodHandles.filterArgumentsWithCombiner(mh, 1, prepender,
- 1, 0, 2, // index, storage, coder
- 3 + pos // selected argument
+ 1, 0, // indexCoder, storage
+ 2 + pos // selected argument
);
break;
}
@@ -1557,7 +1573,7 @@
// Fold in byte[] instantiation at argument 0
mh = MethodHandles.foldArgumentsWithCombiner(mh, 0, NEW_ARRAY,
- 1, 2 // index, coder
+ 1 // index
);
// Start combining length and coder mixers.
@@ -1569,47 +1585,28 @@
// Coders are more interesting. Only Object, String and char arguments (and constants)
// can have non-Latin1 encoding. It is easier to blindly convert constants to String,
// and deduce the coder from there. Arguments would be either converted to Strings
- // during the initial filtering, or handled by primitive specializations in CODER_MIXERS.
+ // during the initial filtering, or handled by specializations in MIXERS.
//
- // The method handle shape before and after all length and coder mixers is:
- // (int, byte, <args>)String = ("index", "coder", <args>)
- byte initialCoder = INITIAL_CODER;
- int initialLen = 0; // initial length, in characters
+ // The method handle shape before and after all mixers are combined in is:
+ // (long, <args>)String = ("indexCoder", <args>)
+ long initialLengthCoder = INITIAL_CODER;
for (RecipeElement el : recipe.getElements()) {
switch (el.getTag()) {
case TAG_CONST:
String constant = el.getValue();
- initialCoder = (byte) coderMixer(String.class).invoke(initialCoder, constant);
- initialLen += constant.length();
+ initialLengthCoder = (long)mixer(String.class).invoke(initialLengthCoder, constant);
break;
case TAG_ARG:
int ac = el.getArgPos();
Class<?> argClass = ptypes[ac];
- MethodHandle lm = lengthMixer(argClass);
-
- if (argClass.isPrimitive() && argClass != char.class) {
- // Compute new "index" in-place using old value plus the appropriate argument.
- mh = MethodHandles.filterArgumentsWithCombiner(mh, 0, lm,
- 0, // old-index
- 2 + ac // selected argument
- );
-
- } else {
- MethodHandle cm = coderMixer(argClass);
+ MethodHandle mix = mixer(argClass);
- // Compute new "index" in-place using old value plus the appropriate argument.
- mh = MethodHandles.filterArgumentsWithCombiner(mh, 0, lm,
- 0, // old-index
- 2 + ac // selected argument
- );
-
- // Compute new "coder" in-place using old value plus the appropriate argument.
- mh = MethodHandles.filterArgumentsWithCombiner(mh, 1, cm,
- 1, // old-coder
- 2 + ac // selected argument
- );
- }
+ // Compute new "index" in-place using old value plus the appropriate argument.
+ mh = MethodHandles.filterArgumentsWithCombiner(mh, 0, mix,
+ 0, // old-index
+ 1 + ac // selected argument
+ );
break;
default:
@@ -1617,9 +1614,9 @@
}
}
- // Insert initial lengths and coders here.
+ // Insert initial length and coder value here.
// The method handle shape here is (<args>).
- mh = MethodHandles.insertArguments(mh, 0, initialLen, initialCoder);
+ mh = MethodHandles.insertArguments(mh, 0, initialLengthCoder);
// Apply filters, converting the arguments:
if (filters != null) {
@@ -1630,45 +1627,34 @@
}
@ForceInline
- private static byte[] newArray(int length, byte coder) {
- return (byte[]) UNSAFE.allocateUninitializedArray(byte.class, length << coder);
+ private static byte[] newArray(long indexCoder) {
+ byte coder = (byte)(indexCoder >> 32);
+ int index = ((int)indexCoder & 0x7FFFFFFF);
+ return (byte[]) UNSAFE.allocateUninitializedArray(byte.class, index << coder);
}
private static MethodHandle prepender(Class<?> cl) {
return PREPENDERS.computeIfAbsent(cl, PREPEND);
}
- private static MethodHandle coderMixer(Class<?> cl) {
- return CODER_MIXERS.computeIfAbsent(cl, CODER_MIX);
- }
-
- private static MethodHandle lengthMixer(Class<?> cl) {
- return LENGTH_MIXERS.computeIfAbsent(cl, LENGTH_MIX);
+ private static MethodHandle mixer(Class<?> cl) {
+ return MIXERS.computeIfAbsent(cl, MIX);
}
// This one is deliberately non-lambdified to optimize startup time:
private static final Function<Class<?>, MethodHandle> PREPEND = new Function<Class<?>, MethodHandle>() {
@Override
public MethodHandle apply(Class<?> c) {
- return lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "prepend", int.class, int.class, byte[].class, byte.class,
+ return lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "prepend", long.class, long.class, byte[].class,
Wrapper.asPrimitiveType(c));
}
};
// This one is deliberately non-lambdified to optimize startup time:
- private static final Function<Class<?>, MethodHandle> CODER_MIX = new Function<Class<?>, MethodHandle>() {
+ private static final Function<Class<?>, MethodHandle> MIX = new Function<Class<?>, MethodHandle>() {
@Override
public MethodHandle apply(Class<?> c) {
- return lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "mixCoder", byte.class, byte.class,
- Wrapper.asPrimitiveType(c));
- }
- };
-
- // This one is deliberately non-lambdified to optimize startup time:
- private static final Function<Class<?>, MethodHandle> LENGTH_MIX = new Function<Class<?>, MethodHandle>() {
- @Override
- public MethodHandle apply(Class<?> c) {
- return lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "mixLen", int.class, int.class,
+ return lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "mix", long.class, long.class,
Wrapper.asPrimitiveType(c));
}
};
@@ -1676,26 +1662,24 @@
private static final MethodHandle NEW_STRING;
private static final MethodHandle NEW_ARRAY;
private static final ConcurrentMap<Class<?>, MethodHandle> PREPENDERS;
- private static final ConcurrentMap<Class<?>, MethodHandle> LENGTH_MIXERS;
- private static final ConcurrentMap<Class<?>, MethodHandle> CODER_MIXERS;
- private static final byte INITIAL_CODER;
+ private static final ConcurrentMap<Class<?>, MethodHandle> MIXERS;
+ private static final long INITIAL_CODER;
static final Class<?> STRING_HELPER;
static {
try {
STRING_HELPER = Class.forName("java.lang.StringConcatHelper");
- MethodHandle initCoder = lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "initialCoder", byte.class);
- INITIAL_CODER = (byte) initCoder.invoke();
+ MethodHandle initCoder = lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "initialCoder", long.class);
+ INITIAL_CODER = (long) initCoder.invoke();
} catch (Throwable e) {
throw new AssertionError(e);
}
PREPENDERS = new ConcurrentHashMap<>();
- LENGTH_MIXERS = new ConcurrentHashMap<>();
- CODER_MIXERS = new ConcurrentHashMap<>();
+ MIXERS = new ConcurrentHashMap<>();
- NEW_STRING = lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "newString", String.class, byte[].class, int.class, byte.class);
- NEW_ARRAY = lookupStatic(Lookup.IMPL_LOOKUP, MethodHandleInlineCopyStrategy.class, "newArray", byte[].class, int.class, byte.class);
+ NEW_STRING = lookupStatic(Lookup.IMPL_LOOKUP, STRING_HELPER, "newString", String.class, byte[].class, long.class);
+ NEW_ARRAY = lookupStatic(Lookup.IMPL_LOOKUP, MethodHandleInlineCopyStrategy.class, "newArray", byte[].class, long.class);
}
}