changeset 52326:77018c2b97df

8213035: Pack MethodHandleInlineStrategy coder and length into a long Reviewed-by: vlivanov, mchung
author redestad
date Tue, 30 Oct 2018 09:34:50 +0100
parents 0451e0a2f1f5
children 6fe18b0c0e88
files src/java.base/share/classes/java/lang/StringConcatHelper.java src/java.base/share/classes/java/lang/invoke/StringConcatFactory.java
diffstat 2 files changed, 174 insertions(+), 194 deletions(-) [+]
line wrap: on
line diff
--- 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
+     * @return new length and coder
      */
-    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
-     */
-    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);
+                        MethodHandle mix = mixer(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);
-
-                            // 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);
         }
     }