January 2014 - core-libs-dev

ISO-8859-16 charset/decoder/encoder
by Charles Oliver Nutter 25 Aug '17

25 Aug '17

Again, apologies if this is not the right list. OpenJDK does not currently contain support for encoding/decoding ISO-8859-16. A JRuby user recently reported that they needed this encoding. So, I implemented it. Here's a link to the charset/decoder/encoder in JRuby's repository: https://github.com/jruby/jruby/blob/master/core/src/main/java/org/jruby/uti… I tried to follow the general form of the other ISO-8859 charsets, but there's probably more reuse possible (I believe they use sun.nio.cs classes I can't access). Happy to contribute this. Unsure of the process. - Charlie

4 5

Re: Analysis on JDK-8022321 java/lang/ref/OOMEInReferenceHandler.java fails intermittently
by David Holmes 24 Jun '16

24 Jun '16

Hi Kalyan, This is not a hotspot issue so I'm moving this to core-libs, please drop hotspot from any replies. On 20/12/2013 6:26 AM, srikalyan wrote: > Hi all, I have been working on the bug JDK-8022321 > <https://bugs.openjdk.java.net/browse/JDK-8022321> , this is a sporadic > failure and the webrev is available here > http://cr.openjdk.java.net/~srikchan/Regression/JDK-8022321_OOMEInReference… I'm really not sure what to make of this. We have a test that triggers an out-of-memory condition but the OOME can actually turn up in the ReferenceHandler thread causing it to terminate and the test to fail. We previously accounted for the non-obvious occurrences of OOME due to the Object.wait and the possible need to load the InterruptedException class - but still the OOME can appear where we don't want it. So finally you have just placed the whole for(;;) loop in a try/catch(OOME) that ignores the OOME. I'm certain that makes the test happy, but I'm not sure it is really what we want for the ReferenceHandler thread. If the OOME occurs while cleaning, or enqueuing then we will fail to clean and/or enqueue but there would be no indication that has occurred and I think that is a bigger problem than this test failing. There may be no way to make this test 100% reliable. In fact I'd suggest that no memory exhaustion test can be 100% reliable. David > * > **"Root Cause:Still not known"* > 2 places where there is a possibility for OOME > 1) Cleaner.clean() > 2) ReferenceQueue.enqueue() > > 1) The cleanup code in turn has 2 places where there is potential for > throwing OOME, > a) thunk Thread which is run from clean() method. This Runnable is > passed to Cleaner and appears in the following classes > java/nio/DirectByteBuffer.java > sun/misc/Perf.java > sun/nio/fs/NativeBuffer.java > sun/nio/ch/IOVecWrapper.java > sun/misc/Cleaner/ExitOnThrow.java > However none of the above overridden implementations ever create an > object in the clean() code. > b) new PrivilegedAction created in try catch Exception block of > clean() method but for this object to be created and to be held > responsible for OOME an Exception(other than OOME) has to be thrown. > > 2) No new heap objects are created in the enqueue method nor anywhere in > the deep call stack (VM.addFinalRefCount() etc) so this cannot be a > potential cause. > > *Experimental change to java.lang.Reference.java* : > - Put one more guard (try catch with OOME block) in the Reference > Handler Thread which may give the Reference Handler a chance to cleanup. > This is fixing the test failure (several 1000 runs with 0 failures) > - Without the above change the test fails atleast 3-5 times for every > 1000 run. > > *PS*: The code change is to a very critical part of JDK and i am fully > not aware of the consequences of the change, hence seeking expert help > here. Appreciate your time and inputs towards this. >

10 95

Replacement of Quicksort in java.util.Arrays with new Dual-Pivot Quicksort
by Vladimir Yaroslavskiy 27 Feb '16

27 Feb '16

Hello All, I'd like to share with you new Dual-Pivot Quicksort which is faster than the known implementations (theoretically and experimental). I'd like to propose to replace the JDK's Quicksort implementation by new one. Description ----------- The classical Quicksort algorithm uses the following scheme: 1. Pick an element P, called a pivot, from the array. 2. Reorder the array so that all elements, which are less than the pivot, come before the pivot and all elements greater than the pivot come after it (equal values can go either way). After this partitioning, the pivot element is in its final position. 3. Recursively sort the sub-array of lesser elements and the sub-array of greater elements. The invariant of classical Quicksort is: [ <= p | >= p ] There are several modifications of the schema: [ < p | = p | > p ] or [ = p | < p | > p | = p ] But all of them use *one* pivot. The new Dual-Pivot Quicksort uses *two* pivots elements in this manner: 1. Pick an elements P1, P2, called pivots from the array. 2. Assume that P1 <= P2, otherwise swap it. 3. Reorder the array into three parts: those less than the smaller pivot, those larger than the larger pivot, and in between are those elements between (or equal to) the two pivots. 4. Recursively sort the sub-arrays. The invariant of the Dual-Pivot Quicksort is: [ < P1 | P1 <= & <= P2 } > P2 ] The new Quicksort is faster than current implementation of Quicksort in JDK (L. Bentley and M. Douglas McIlroy) and classical Quicksort. The full description of the Dual-Pivot Quicksort you can find on my page: http://iaroslavski.narod.ru/quicksort Performance tests ----------------- Here is result of running on different types of input data: Client VM all 85% organ 0..1 0..4 random ascend descend equal equal pipes random 010101 random Dual-Pivot: 16.83 5.31 5.47 0.35 0.68 10.59 1.06 1.02 2.18 Bentley's: 19.77 9.08 10.13 0.63 1.12 13.22 1.63 1.08 2.49 Server VM all 85% organ 0..1 0..4 random ascend descend equal equal pipes random 010101 random Dual-Pivot: 23.94 6.68 6.63 0.43 0.62 17.14 1.42 1.96 3.41 Bentley's: 25.20 10.18 10.32 2.07 1.33 16.72 2.95 1.82 3.39 The a lot of other tests have been run under client and server mode. The most interesting is BentleyBasher test framework. It runs battery of tests for all cases: { 100, 1000, 10000, 1000000 } x { sawtooth, rand, stagger, plateau, shuffle } x { ident, reverse, reverse_front, reverse_back, sort, dither} where 100, ... , 1000000 - array length sawtooth: x[i] =i%m rand: x[i] = rand() % m stagger: x[i] = (i*m + i) % n plateau: x[i] = min(i, m) shuffle: x[i] = rand()%m? (j+=2): (k+=2) ident(x) - a copy of x reverse(x, 0, n) - reversed copy reverse_front(x, 0, n/2) - front half reversed reverse_back(x, n/2, n) - back half reversed sort(x) - an ordered copy dither(x) - add i%5 to x[i] Here is the result of execution: Server VM: http://spreadsheets.google.com/pub?key=t_EAWUkQ4mD3BIbOv8Fa-AQ&output=html Client VM: http://spreadsheets.google.com/pub?key=tdiMo8xleTxd23nKUObcz0Q&single=true&… Mathematical investigations --------------------------- It is proved that for the Dual-Pivot Quicksort the average number of comparisons is 2*n*ln(n), the average number of swaps is 0.8*n*ln(n), whereas classical Quicksort algorithm has 2*n*ln(n) and 1*n*ln(n) respectively. Full mathematical proof see in attached proof.txt and proof_add.txt files. Theoretical results are also confirmed by experimental counting of the operations. Diff between current and new implementation of Quicksort -------------------------------------------------------- Here is the link to the diff for java.util.Arrays class: http://cr.openjdk.java.net/~alanb/6880672/webrev.00 If you like to look and play with new algorithm, please, take attached class DualPivotQuicksort.java Feedback -------- Also I'd like to share a feedback from Joshua Bloch and Jon Bentley who spent a lot of time investigating this algorithm, who gave me many advices and tips how to make new Quicksort better. -------- Original Message -------- Subject: Re: Integration of new Dual-Pivot Quicksort into JDK 7 Date: Thu, 10 Sep 2009 07:20:11 -0700 From: Joshua Bloch <jjb(a)google.com> Jon also says that Vladimir should make every reasonable improvement to the basic method before checking in the code. In his words, "It would be horrible to put the new code into the library, and then have someone else come along and speed it up by another 20% by using standard techniques." I believe it's not unlikely that this code may end up getting ported to many languages and widely deployed in much the manner of Bentley and McIlroy's fine sort (which is nearing 20 successful years in the field). Jon will help Vladimir do this. -------- Original Message -------- Subject: Dual-Pivot Quicksort: Next Steps Date: Wed, 09 Sep 2009 15:02:25 -0400 From: Jon Bentley <jbentley(a)avaya.com> Vladimir, Josh, I *finally* feel like I understand what is going on. Now that I (think that) I see it, it seems straightforward and obvious. Tony Hoare developed Quicksort in the early 1960s. I was very proud to make minor contributions to a particularly clean (binary) quicksort in the mid 1980s, to a relatively straightforward, industrial strength Quicksort with McIlroy in the early 1990s, and then to algorithms and data structures for strings with Sedgewick in the mid 1990s. I think that Vladimir's contributions to Quicksort go way beyond anything that I've ever done, and rank up there with Hoare's original design and Sedgewick's analysis. I feel so privileged to play a very, very minor role in helping Vladimir with the most excellent work! ----------------------------------------------- Let me know, if you have any questions/comments. Thank you, Vladimir Here is the details between steps (1) and (2) in the case of Dual-Pivot Quicksort: ----------------------------------------------------------------------------- >From the algorithm above, the average number of comparisons C_n as a function of the number of elements may be represented by the equation: (1) C_n = 1 + 2/(n*(n-1)) * sum_{i=0}^{n-2} sum_{j=i+1}^{n-1} {C_i + 1*i + C_{j-i-1} + 2*(j-i- 1) + C_{n-j-1} + 2*(n-j-1)} Equation (1) means that total number is the sum of the comparison numbers of all cases of partitions into 3 parts plus number of comparisons for elements from left part (one comparison), center and right parts (2 comparisons). !!! It can be rewritten in other way: !!! (2) C_n = 1 + R*(n-2) + 2/(n(n-1)) * sum_{i=0}^{n-2} sum_{j=i+1}^{n-1} {C_i + C_{j-i-1} + C_{n-j-1}} where R is the average number of comparisons during one iteration. This constant R can be found as average value (1 + 2 + 2) / 3 = 5/3 ~ 1.6666. ----------------------------------------------------------------------------- How it can be rewritten: We should show that 2/(n*(n-1)) * sum_{i=0}^{n-2} sum_{j=i+1}^{n-1} {i + 2*(j-i- 1) + 2*(n-j-1)} equals to 5/3 * (n-2). Let's consider the double sum: sum_{i=0}^{n-2} sum_{j=i+1}^{n-1} {i + 2*(j-i- 1) + 2*(n-j-1)} = = sum_{i=0}^{n-2} sum_{j=i+1}^{n-1} {2*n - 4} - sum_{i=0}^{n-2} sum_{j=i+1}^{n-1} {i} = = 2*(n-2)*sum_{i=0}^{n-2} {n-1-i} - sum_{i=0}^{n-2} sum_{j=i+1}^{n-1} {i} = = 2*(n-2)*((n-1)^2 - (n-1)*(n-2)/2) - (n-1)*sum_{i=0}^{n-2} {i} + sum_{i=0}^{n-2} {i*i} = ------------------------------------------------------------------ here we use the property: sum_{k=1}{n} {k^2} = n^3/3 + n^2/2 + n/6 ------------------------------------------------------------------ = 2*(n-2)*((n-1)^2 - (n-1)*(n-2)/2) - (n-1)*(n-1)*(n-2)/2 + (n-2)^3/3 + (n-2)^2/2 + (n-2)/6 = = 1/6 * (12*(n-1)^2*(n-2) - 6*(n-1)*(n-2)^2 - 3*(n-1)^2*(n-2) + 2*(n-2)^3 + 3*(n-2)^2 + (n-2)) = = 1/6 * (3*(n-1)*(n-2)*(3*(n-1) - 2*(n-2)) + (n-2)*(2*(n-2)^2 + 3*(n-2) + 1))) = = 1/6 * (3*(n-1)*(n-2)*(n+1) + (n-2)*(2*n^2 - 5*n + 3)) = = 1/6 * (n-2)*(5*n^2 - 5*n) = 5/6 * n*(n-1)*(n-2) Substitute the result into equation (1): (1.1) C_n = 1 + 2/(n*(n-1)) * 5/6 * n*(n-1)*(n-2) + 2/(n*(n-1)) * sum_{i=0}^{n-2} sum_{j=i+1}^{n-1} {C_i + C_{j-i-1} + C_{n-j-1}} or (1.2) C_n = 1 + 5/3*(n-2) + 2/(n*(n-1)) * sum_{i=0}^{n-2} sum_{j=i+1}^{n-1} {C_i + C_{j-i-1} + C_{n-j-1}} We see that (1.2) is same as (2). /** * @author Vladimir Yaroslavskiy * @version 2009.09.10 m765 */ public class DualPivotQuicksort { public static void sort(int[] a) { sort(a, 0, a.length); } public static void sort(int[] a, int fromIndex, int toIndex) { rangeCheck(a.length, fromIndex, toIndex); dualPivotQuicksort(a, fromIndex, toIndex - 1, 3); } private static void rangeCheck(int length, int fromIndex, int toIndex) { if (fromIndex > toIndex) { throw new IllegalArgumentException("fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")"); } if (fromIndex < 0) { throw new ArrayIndexOutOfBoundsException(fromIndex); } if (toIndex > length) { throw new ArrayIndexOutOfBoundsException(toIndex); } } private static void swap(int[] a, int i, int j) { int temp = a[i]; a[i] = a[j]; a[j] = temp; } private static void dualPivotQuicksort(int[] a, int left, int right, int div) { int len = right - left; if (len < 27) { // insertion sort for tiny array for (int i = left + 1; i <= right; i++) { for (int j = i; j > left && a[j] < a[j - 1]; j--) { swap(a, j, j - 1); } } return; } int third = len / div; // "medians" int m1 = left + third; int m2 = right - third; if (m1 <= left) { m1 = left + 1; } if (m2 >= right) { m2 = right - 1; } if (a[m1] < a[m2]) { swap(a, m1, left); swap(a, m2, right); } else { swap(a, m1, right); swap(a, m2, left); } // pivots int pivot1 = a[left]; int pivot2 = a[right]; // pointers int less = left + 1; int great = right - 1; // sorting for (int k = less; k <= great; k++) { if (a[k] < pivot1) { swap(a, k, less++); } else if (a[k] > pivot2) { while (k < great && a[great] > pivot2) { great--; } swap(a, k, great--); if (a[k] < pivot1) { swap(a, k, less++); } } } // swaps int dist = great - less; if (dist < 13) { div++; } swap(a, less - 1, left); swap(a, great + 1, right); // subarrays dualPivotQuicksort(a, left, less - 2, div); dualPivotQuicksort(a, great + 2, right, div); // equal elements if (dist > len - 13 && pivot1 != pivot2) { for (int k = less; k <= great; k++) { if (a[k] == pivot1) { swap(a, k, less++); } else if (a[k] == pivot2) { swap(a, k, great--); if (a[k] == pivot1) { swap(a, k, less++); } } } } // subarray if (pivot1 < pivot2) { dualPivotQuicksort(a, less, great, div); } } } At first consider the classic Quicksort scheme and find the average number of comparisons and swaps for it. We assume that input data is random permutation of n numbers from the range [1..n]. Classic Quicksort ================= 1. Choose a pivot element (take random), 2. Compare each (n-1) elements with the pivot 3. and swap it, if necessary, to have the partitions: [ <= pivot | >= pivot ] 4. Sort recursively left and right parts. >From the algorithm above, the average number of comparisons C_n as a function of the number of elements may be represented by the equation: (1) C_n = (n-1) + 1/n * sum_{k=0}^{n-1} {C_k + C_{n-k-1}} and last sum can be rewritten: (2) C_n = (n-1) + 2/n * sum_{k=0}^{n-1} C_k Write formula (2) for n+1: (3) C_{n+1} = n + 2/(n+1) * sum_{k=0}^{n} C_k Multiply (2) by n and (3) by (n+1) and subtract one from other, we have: (4) (n+1)*C_{n+1} - n*C_n = 2*n + 2*C_n Sorting an array of n elements may be considered as selecting one permutation of the n elements among all possible permutations. The number of possible permutations of n elements is n!, so the task for any sorting algorithm is to determine the one permutation out of n! possibilities. The minimum number of operations (swap and comparisons) for sorting n elements is const*ln(n!). >From the Stirling's formula the approximation of the number of operations is A*n*ln(n) + B*n + C, where A, B and C are constant coefficients. The coefficients B and C are not important for large n. Therefore, the function C_n may be approximated by the equation: (5) C_n = A*n*ln(n) The function C_n is substituted from equation (5) into equation (4), which yields the following equation: (6) (n+1)*A*(n+1)*ln(n+1) - n*A*n*ln(n) = 2*n + 2*A*n*ln(n) Using the properties of logarithms, equation (6) can then be reduced to: (7) n*ln(1+1/n) + 2*ln(1+1/n) + (1/n) * ln(n+1) = 2/A Using a property of logarithm: ln(1 + x) -> x, if x -> 0, and other property: ln(n) / n -> 0, when n -> +oo, equation (7) will be approximated by: (8) 1 + 0 + 0 = 2/A So, the coefficient A is equal to 2 and the average number of comparisons in sorting of n size arrays is (9) C_n = 2*n*ln(n). To find the approximation of the average number of swaps, we use the similar approach as in the case of comparisons. The average number of swaps S_n as a function of the number of elements may be represented by the equation: (10) S_n = 1/2*(n-1) + 2/n * sum_{k=0}^{n-1} S_k We assume that average number of swaps during one iteration is 1/2*(n-1). It means that in average one half of elements is swapped only. Using the same approach, we find that the coefficient A equals to 1. Therefore, the function S_n may be approximated by the equation: (11) S_n = n*ln(n) ------------------------------------------------------------------------------- Now consider the Dual-Pivot Quicksort scheme and find the average number of comparisons and swaps for it. We assume that input data is random permutation of n numbers from the range [1..n]. Dual-Pivot Quicksort ==================== 1. Choose 2 pivot elements pivot1 and pivot2 (take random), 2. pivot1 must be less or equal than pivot2, otherwise they are swapped 3. Compare each (n-2) elements with the pivots 4. and swap it, if necessary, to have the partitions: [ <= p1 | p1 <= & <= p2 | >= p2 ] 5. Sort recursively left, center and right parts. >From the algorithm above, the average number of comparisons C_n as a function of the number of elements may be represented by the equation: (1) C_n = 1 + 2/(n*(n-1)) * sum_{i=0}^{n-2} sum_{j=i+1}^{n-1} {C_i + 1*i + C_{j-i-1} + 2*(j-i-1) + C_{n-j-1} + 2*(n-j-1)} Equation (1) means that total number is the sum of the comparison numbers of all cases of partitions into 3 parts plus number of comparisons for elements from left part (one comparison), center and right parts (2 comparisons). It can be rewritten in other way: (2) C_n = 1 + R*(n-2) + 2/(n(n-1)) * sum_{i=0}^{n-2} sum_{j=i+1}^{n-1} {C_i + C_{j-i-1} + C_{n-j-1}} where R is the average number of comparisons during one iteration. This constant R can be found as average value (1 + 2 + 2) / 3 = 5/3, which means that elements from left part are required only one comparison, and elements form center and right parts - two comparisons. The double sum in equation (2) can be reduced: (3) C_n = 1 + 5/3*(n-2) + 2/(n*(n-1)) * sum_{k=0}^{n-2} {3 * (n-k-1) * C_k} Denote 1 + 5/3*(n-2) by f_n and multiply to n*(n-1): (4) n*(n-1)*C_n = n*(n-1)*f_n + 6 * sum_{k=0}^{n-2} {(n-k-1) * C_k} Write formula (4) for n+1: (5) n*(n+1)*C_{n+1} = n*(n+1)*f_n + 6 * sum_{k=0}^{n-1} {(n-k) * C_k} Subtract (4) from (5), we have: (6) n*(n+1)*C_{n+1} - n*(n-1)*C_n = n*(n+1)*f_n - n*(n-1)*f_n + 6 * sum_{k=0}^{n-2} C_k + 6*C_{n-1} Denote n*(n+1)*C_{n+1} - n*(n-1)*C_n by X_n and n*(n+1)*f_n - n*(n-1)*f_n by F_n: (7) X_n = F_n + 6 * sum_{k=0}^{n-2} C_k + 6*C_{n-1} Write formula (7) for n+1: (8) X_{n+1} = F_{n+1} + 6 * sum_{k=0}^{n-1} C_k + 6*C_n Subtract (7) from (8), we have: (9) X_{n+1} - X_n = F_{n+1} - F_n + 6*C_n Resolving of F_{n+1} - F_n gives: (10) X_{n+1} - X_n = 2 + 10*n + 6*C_n The function X_n is substituted into equation (10), which yields the following equation: (11) (n+1)*(n+2)C_{n+2} -2*n(n+1)*C_{n+1} + (n*(n-1) - 6)*C_n = 2 + 10*n We will find the function C_n approximated by the equation: (12) C_n = A*n*ln(n) The function C_n is substituted from equation (12) into equation (11), which yields the following equation: (13) (n^3+5*n^2+8*n+4)*ln(n+2) - (2*n^3+4*n^2+2*n)*ln(n+1) + (n^3-n^2-6*n)*ln(n) = (10*n+2) / A Using the properties of logarithms, equation (13) can then be reduced to: (14) n^3*(ln(n+2)-2*ln(n+1)+ln(n)) + n^2*(5*ln(n+2)-4*ln(n+1)-ln(n)) + n*(8*ln(n+2)-2*ln(n+1)-6*ln(n)) + 4*ln(n+2) = (10*n+2) / A Using a property of logarithm: ln(1 + x) -> x, if x -> 0, and other property: ln(n) / n -> 0, when n -> +oo, equation (15) will be approximated by: (15) -1 + 4 + 2 + 0 + 0 = 10 / A So, the coefficient A is equal to 2 and the average number of comparisons in sorting of n size arrays is (9) C_n = 2*n*ln(n). To find the approximation of the average number of swaps, we use the similar approach as in the case of comparisons. The average number of swaps S_n as a function of the number of elements may be represented by the equation: (10) S_n = 4 + 2/3*(n-2) + 2/(n*(n-1)) * sum_{k=0}^{n-2} {(n-k-1)*S_k} We assume that average number of swaps during one iteration is 2/3*(n-2). It means that in average one third of elements is swapped only. Using the same approach, we find that the coefficient A equals to 0.8. Therefore, the function S_n may be approximated by the equation: (11) S_n = 0.8*n*ln(n) ------------------------------------------------------------------------- And as summary: The value of the coefficient A: dual-pivot classic comparison: 2.0 2.0 swap: 0.8 1.0

14 20

JEP 187: Serialization 2.0
by mark.reinhold＠oracle.com 30 Dec '14

30 Dec '14

Posted: http://openjdk.java.net/jeps/187 - Mark

5 8

RFR: Faster ZipFile.getEntry()/entries()
by Xueming Shen 22 May '14

22 May '14

Hi, The change proposed here is to bring the zip entry handing code from the native level to the java level. This effectively solves the performance issues of ZipFile.getEntry and entries() that is caused by multiple jni invocation steps to generate one single ZipEntry (see ZipFile.getZipEntry()). A simple non-scientific benchmark test of simply iterating the ZipFile via the Enumeration from entries() on rt.jar/charsets.jar suggests a 50%+ speed boost. http://cr.openjdk.java.net/~sherman/zipfile_j/webrev Couple notes: (1) Ideally it might be desired to go further to bring all the native code of ZipFile to java level (which should help completely remove that mmap crash issue, have better file and memory management... ), but it is suggested that it might be better to limit the scope of the change at this late release circle. (2) JavaFile.read0() is the version that uses "getPrimitiveArrayCritical" to read file bits into the java array directly (instead of using a stack buffer and then copy into the java array), which appears to be 5% faster. But I can't make up my mind of which one would be better. Given (1) the trouble we had before in De/Infalter code (when the getPrimitiveArrayCritical is being heavily used), (2) FileInputStream uses the same "copy" approach, I'm staying with the "copy" appraoch, but option appreciated. (3) We will have to keep the native implementation (zip_util.c) for the vm directly access. Thanks! -Sherman

3 4

RFR (S) 8025238: nsk/jvmti/scenarios/bcinstr/BI04/bi04t002 crashed with SIGSEGV
by Coleen Phillimore 02 May '14

02 May '14

Summary: Redefined class in stack trace may not be found by method_idnum so handle null. This is a simple change. I had another change to save the method name (as u2) in the backtrace, but it's not worth the extra footprint in backtraces for this rare case. The root problem was that we save method_idnum in the backtrace (u2) instead of Method* to avoid Method* from being redefined and deallocated. I made a change to InstanceKlass::method_from_idnum() to return null rather than the last method in the list, which causes this crash. Dan and I went down the long rabbit-hole of why method_idnum is changed for obsolete methods and we think there's some cleanup and potential bugs in this area. But this is not that change. I'll file another bug to continue this investigation for jdk9 (or 8uN). Staffan created a test - am including core-libs for the review request. Also tested with all of the vm testbase tests, mlvm tests, and java/lang/instrument tests. open webrev at http://cr.openjdk.java.net/~coleenp/8025238/ bug link https://bugs.openjdk.java.net/browse/JDK-8025238 test case for jdk8 repository: open webrev at http://cr.openjdk.java.net/~coleenp/8025238_jdk Thanks, Coleen

6 15

Signature of MethodHandleInfo.reflectAs is not specific enough
by Remi Forax 01 Mar '14

01 Mar '14

The is a stupid issue with the signature of MethodHandleInfo.reflectAs, j.l.r.Field, Method or Constructor implement two interfaces Member and AnnotatedElement, with the current signature, the code info.reflectAs(Member.class, lookup) works but the code info.reflectAs(AnnotatedElement.class, lookup) doesn't work. Because there is no way to do an 'or' between several bounds of a type variable, I think that the signature of reflectAs should be changed from : public <T extends Member> T reflectAs(Class<T> expected, Lookup lookup); to public <T> T reflectAs(Class<T> expected, Lookup lookup); and the javadoc should be modified to explain that a Member or AnnotatedElement are valid bounds of T. As a side effect, the signature of MethodHandles.reflectAs(Class<T>, MethodHandle) should be updated accordingly. There is a workaround, one can write: (AnnotatedElement)info.reflectAs(Member.class, lookup) but it's at best weird. cheers, Rémi

5 8

RFR: JDK-8032050: TEST_BUG: java/rmi/activation/Activatable/shutdownGracefully/ShutdownGracefully.java fails intermittently
by Tristan Yan 20 Feb '14

20 Feb '14

Hi All Could you review the bug fix for JDK-8032050. http://cr.openjdk.java.net/~tyan/JDK-8032050/webrev.00/ Description: This rare happened failure caused because when RMID starts. It don't guarantee sun.rmi.server.Activation.startActivation finishes. Fix by adding a iterative getSystem with a 5 seconds timeout. Thank you. Tristan

2 12

RFR for JDK-8028711: TEST_BUG: Tests should pass through VM options: corelibs tests
by michael cui 13 Feb '14

13 Feb '14

Hi, Please review the following code changes for https://bugs.openjdk.java.net/browse/JDK-8028711 The bug and fix are for enforcing the following rules: launch java from shell script, ${TESTVMOPTS} and ${TESTJAVAOPTS} should be passed in. launch javac from shell script, ${TESTTOOLVMOPTS} and ${TESTJAVACOPTS} should be passed in. So almost all the scripts who failed to follow above rules are touched by this fix. There are very few exceptions since test cases explicitly state that they are intended to launch java without any vm options. webrev http://cr.openjdk.java.net/~tyan/michael/JDK-8028711/webrev.01/ Thanks, Michael Cui

2 10

Re: ObjectIn/OutputStream improvements
by Chris Hegarty 06 Feb '14

06 Feb '14

Forwarding to correct core-libs-dev list. -Chris. On 31 Jan 2014, at 14:22, Chris Hegarty <chris.hegarty(a)oracle.com> wrote: > Hi Robert, > > I think your patch can be split into two logical, independent, parts. The first is the use of unsafe to access the String UTF length. The seconds is to reuse, where possible, the existing StringBuilder instances, skipping of primitive/object reading/writing where applicable, and general cleanup. > > Since this is a very sensitive area I would like to consider these separately. To that end, I have taken the changes that are applicable to the latter, removed any subjective stylistic changes, and made some additional cleanup improvements. > > http://cr.openjdk.java.net/~chegar/serial_stupp.00/webrev/ > > Specifically, > * I think for clarify and readability SerialCallbackContext > checkAndSetUsed() should be invoked directly. It makes it very > clear what the intent is. > * Skip primitive/object reading/writing if no primitives/objects in > the stream/class. ( I personally don't see any benefit of rounding > up the size of the array, it just seems to add unnecessary > complexity ) > * Move primitive types into getPrimitiveSignature for better reuse > of code. This retains your change to not create the additional > StringBuilder when it is not necessary. > > I am currently running tests on this change. > > -Chris. > > On 07/01/14 13:03, Robert Stupp wrote: >> Hi, >> I've attached the diff to the original email - it has been stripped. >> Here's a second try (inline). >> I've already signed the OCA and it has been approved :) >> Robert >> # HG changeset patch >> # User snazy >> # Date 1387101091 -3600 >> # Sun Dec 15 10:51:31 2013 +0100 >> # Node ID 6d46d99212453017c88417678d08dc8f10da9606 >> # Parent 9e1be800420265e5dcf264a7ed4abb6f230dd19d >> Removed some unnecessary variable assignments. >> ObjectInputStream: >> - skip primitive/object reading if no primitive/objects in class >> - use shared StringBuilder for string reading (prevent superfluous >> object allocations) >> ObjectOutputStream: >> - skip primitive/object writing if no primitive/objects in class >> - use unsafe access to calculate UTF-length >> - use unsafe access in readBytes() and writeChars() methods to access >> String value field >> - removed cbuf field >> ObjectStreamClass/ObjectStreamField: >> - minor improvement in getClassSignature ; share method code with >> ObjectStreamField >> diff --git a/src/share/classes/java/io/ObjectInputStream.java >> b/src/share/classes/java/io/ObjectInputStream.java >> --- a/src/share/classes/java/io/ObjectInputStream.java >> +++ b/src/share/classes/java/io/ObjectInputStream.java >> @@ -39,8 +39,8 @@ >> import java.util.HashMap; >> import java.util.concurrent.ConcurrentHashMap; >> import java.util.concurrent.ConcurrentMap; >> -import java.util.concurrent.atomic.AtomicBoolean; >> import static java.io.ObjectStreamClass.processQueue; >> + >> import sun.reflect.misc.ReflectUtil; >> >> /** >> @@ -534,7 +534,7 @@ >> if (ctx == null) { >> throw new NotActiveException("not in call to readObject"); >> } >> - Object curObj = ctx.getObj(); >> + ctx.getObj(); >> ObjectStreamClass curDesc = ctx.getDesc(); >> bin.setBlockDataMode(false); >> GetFieldImpl getField = new GetFieldImpl(curDesc); >> @@ -1597,7 +1597,7 @@ >> int descHandle = handles.assign(unshared ? unsharedMarker : desc); >> passHandle = NULL_HANDLE; >> >> - ObjectStreamClass readDesc = null; >> + ObjectStreamClass readDesc; >> try { >> readDesc = readClassDescriptor(); >> } catch (ClassNotFoundException ex) { >> @@ -1976,29 +1976,34 @@ >> } >> >> int primDataSize = desc.getPrimDataSize(); >> - if (primVals == null || primVals.length < primDataSize) { >> - primVals = new byte[primDataSize]; >> - } >> - bin.readFully(primVals, 0, primDataSize, false); >> - if (obj != null) { >> - desc.setPrimFieldValues(obj, primVals); >> - } >> - >> - int objHandle = passHandle; >> - ObjectStreamField[] fields = desc.getFields(false); >> - Object[] objVals = new Object[desc.getNumObjFields()]; >> - int numPrimFields = fields.length - objVals.length; >> - for (int i = 0; i < objVals.length; i++) { >> - ObjectStreamField f = fields[numPrimFields + i]; >> - objVals[i] = readObject0(f.isUnshared()); >> - if (f.getField() != null) { >> - handles.markDependency(objHandle, passHandle); >> + if (primDataSize > 0) { >> + if (primVals == null || primVals.length < primDataSize) { >> + primVals = new byte[ ((primDataSize>>4)+1)<<4 ]; >> + } >> + bin.readFully(primVals, 0, primDataSize, false); >> + if (obj != null) { >> + desc.setPrimFieldValues(obj, primVals); >> } >> } >> - if (obj != null) { >> - desc.setObjFieldValues(obj, objVals); >> + >> + int numObjFields = desc.getNumObjFields(); >> + if (numObjFields > 0) { >> + int objHandle = passHandle; >> + ObjectStreamField[] fields = desc.getFields(false); >> + Object[] objVals = new Object[numObjFields]; >> + int numPrimFields = fields.length - objVals.length; >> + for (int i = 0; i < objVals.length; i++) { >> + ObjectStreamField f = fields[numPrimFields + i]; >> + objVals[i] = readObject0(f.isUnshared()); >> + if (f.getField() != null) { >> + handles.markDependency(objHandle, passHandle); >> + } >> + } >> + if (obj != null) { >> + desc.setObjFieldValues(obj, objVals); >> + } >> + passHandle = objHandle; >> } >> - passHandle = objHandle; >> } >> >> /** >> @@ -2377,8 +2382,10 @@ >> private final byte[] buf = new byte[MAX_BLOCK_SIZE]; >> /** buffer for reading block data headers */ >> private final byte[] hbuf = new byte[MAX_HEADER_SIZE]; >> - /** char buffer for fast string reads */ >> + /** char buffer for fast string reads - used by {@link >> #readUTFSpan(long)} */ >> private final char[] cbuf = new char[CHAR_BUF_SIZE]; >> + /** shared string builder for less object allocations - used by >> {@link #readUTFBody(long)}, {@link #readUTFChar(long)} and {@link >> #readUTFSpan(long)} */ >> + private final StringBuilder sbuf = new >> StringBuilder(CHAR_BUF_SIZE); >> >> /** block data mode */ >> private boolean blkmode = false; >> @@ -3044,19 +3051,19 @@ >> * utflen bytes. >> */ >> private String readUTFBody(long utflen) throws IOException { >> - StringBuilder sbuf = new StringBuilder(); >> if (!blkmode) { >> end = pos = 0; >> } >> >> + sbuf.setLength(0); >> while (utflen > 0) { >> int avail = end - pos; >> if (avail >= 3 || (long) avail == utflen) { >> - utflen -= readUTFSpan(sbuf, utflen); >> + utflen -= readUTFSpan(utflen); >> } else { >> if (blkmode) { >> // near block boundary, read one byte at a time >> - utflen -= readUTFChar(sbuf, utflen); >> + utflen -= readUTFChar(utflen); >> } else { >> // shift and refill buffer manually >> if (avail > 0) { >> @@ -3076,10 +3083,10 @@ >> * Reads span of UTF-encoded characters out of internal buffer >> * (starting at offset pos and ending at or before offset end), >> * consuming no more than utflen bytes. Appends read >> characters to >> - * sbuf. Returns the number of bytes consumed. >> + * {@link #sbuf}. Returns the number of bytes consumed. >> */ >> - private long readUTFSpan(StringBuilder sbuf, long utflen) >> - throws IOException >> + private long readUTFSpan(long utflen) >> + throws IOException >> { >> int cpos = 0; >> int start = pos; >> @@ -3111,19 +3118,19 @@ >> throw new UTFDataFormatException(); >> } >> cbuf[cpos++] = (char) (((b1 & 0x1F) << 6) | >> - ((b2 & 0x3F) << 0)); >> + (b2 & 0x3F)); >> break; >> >> case 14: // 3 byte format: 1110xxxx 10xxxxxx >> 10xxxxxx >> b3 = buf[pos + 1]; >> - b2 = buf[pos + 0]; >> + b2 = buf[pos ]; >> pos += 2; >> if ((b2 & 0xC0) != 0x80 || (b3 & 0xC0) != >> 0x80) { >> throw new UTFDataFormatException(); >> } >> cbuf[cpos++] = (char) (((b1 & 0x0F) << 12) | >> - ((b2 & 0x3F) << 6) | >> - ((b3 & 0x3F) << 0)); >> + ((b2 & 0x3F) << 6) | >> + (b3 & 0x3F)); >> break; >> >> default: // 10xx xxxx, 1111 xxxx >> @@ -3150,12 +3157,12 @@ >> >> /** >> * Reads in single UTF-encoded character one byte at a time, >> appends >> - * the character to sbuf, and returns the number of bytes consumed. >> + * the character to {@link #sbuf}, and returns the number of >> bytes consumed. >> * This method is used when reading in UTF strings written in >> block >> * data mode to handle UTF-encoded characters which (potentially) >> * straddle block-data boundaries. >> */ >> - private int readUTFChar(StringBuilder sbuf, long utflen) >> + private int readUTFChar(long utflen) >> throws IOException >> { >> int b1, b2, b3; >> @@ -3181,8 +3188,7 @@ >> if ((b2 & 0xC0) != 0x80) { >> throw new UTFDataFormatException(); >> } >> - sbuf.append((char) (((b1 & 0x1F) << 6) | >> - ((b2 & 0x3F) << 0))); >> + sbuf.append((char) (((b1 & 0x1F) << 6) | (b2 & 0x3F))); >> return 2; >> >> case 14: // 3 byte format: 1110xxxx 10xxxxxx 10xxxxxx >> @@ -3198,8 +3204,8 @@ >> throw new UTFDataFormatException(); >> } >> sbuf.append((char) (((b1 & 0x0F) << 12) | >> - ((b2 & 0x3F) << 6) | >> - ((b3 & 0x3F) << 0))); >> + ((b2 & 0x3F) << 6) | >> + (b3 & 0x3F))); >> return 3; >> >> default: // 10xx xxxx, 1111 xxxx >> diff --git a/src/share/classes/java/io/ObjectOutputStream.java >> b/src/share/classes/java/io/ObjectOutputStream.java >> --- a/src/share/classes/java/io/ObjectOutputStream.java >> +++ b/src/share/classes/java/io/ObjectOutputStream.java >> @@ -35,7 +35,8 @@ >> import java.util.concurrent.ConcurrentHashMap; >> import java.util.concurrent.ConcurrentMap; >> import static java.io.ObjectStreamClass.processQueue; >> -import java.io.SerialCallbackContext; >> + >> +import sun.misc.Unsafe; >> import sun.reflect.misc.ReflectUtil; >> >> /** >> @@ -458,7 +459,7 @@ >> if (ctx == null) { >> throw new NotActiveException("not in call to >> writeObject"); >> } >> - Object curObj = ctx.getObj(); >> + ctx.getObj(); >> ObjectStreamClass curDesc = ctx.getDesc(); >> curPut = new PutFieldImpl(curDesc); >> } >> @@ -1300,7 +1301,7 @@ >> */ >> private void writeString(String str, boolean unshared) throws >> IOException { >> handles.assign(unshared ? null : str); >> - long utflen = bout.getUTFLength(str); >> + long utflen = BlockDataOutputStream.getUTFLength(str); >> if (utflen <= 0xFFFF) { >> bout.writeByte(TC_STRING); >> bout.writeUTF(str, utflen); >> @@ -1527,29 +1528,34 @@ >> desc.checkDefaultSerialize(); >> >> int primDataSize = desc.getPrimDataSize(); >> - if (primVals == null || primVals.length < primDataSize) { >> - primVals = new byte[primDataSize]; >> + if (primDataSize > 0) { >> + if (primVals == null || primVals.length < primDataSize) { >> + primVals = new byte[ ((primDataSize>>4)+1)<<4 ]; >> + } >> + desc.getPrimFieldValues(obj, primVals); >> + bout.write(primVals, 0, primDataSize, false); >> } >> - desc.getPrimFieldValues(obj, primVals); >> - bout.write(primVals, 0, primDataSize, false); >> >> - ObjectStreamField[] fields = desc.getFields(false); >> - Object[] objVals = new Object[desc.getNumObjFields()]; >> - int numPrimFields = fields.length - objVals.length; >> - desc.getObjFieldValues(obj, objVals); >> - for (int i = 0; i < objVals.length; i++) { >> - if (extendedDebugInfo) { >> - debugInfoStack.push( >> - "field (class \"" + desc.getName() + "\", name: \"" + >> - fields[numPrimFields + i].getName() + "\", type: \"" + >> - fields[numPrimFields + i].getType() + "\")"); >> - } >> - try { >> - writeObject0(objVals[i], >> - fields[numPrimFields + i].isUnshared()); >> - } finally { >> + int numObjFields = desc.getNumObjFields(); >> + if (numObjFields > 0) { >> + ObjectStreamField[] fields = desc.getFields(false); >> + Object[] objVals = new Object[numObjFields]; >> + int numPrimFields = fields.length - objVals.length; >> + desc.getObjFieldValues(obj, objVals); >> + for (int i = 0; i < objVals.length; i++) { >> if (extendedDebugInfo) { >> - debugInfoStack.pop(); >> + debugInfoStack.push( >> + "field (class \"" + desc.getName() + "\", name: >> \"" + >> + fields[numPrimFields + i].getName() + "\", >> type: \"" + >> + fields[numPrimFields + i].getType() + "\")"); >> + } >> + try { >> + writeObject0(objVals[i], >> + fields[numPrimFields + i].isUnshared()); >> + } finally { >> + if (extendedDebugInfo) { >> + debugInfoStack.pop(); >> + } >> } >> } >> } >> @@ -1743,15 +1749,11 @@ >> private static final int MAX_BLOCK_SIZE = 1024; >> /** maximum data block header length */ >> private static final int MAX_HEADER_SIZE = 5; >> - /** (tunable) length of char buffer (for writing strings) */ >> - private static final int CHAR_BUF_SIZE = 256; >> >> /** buffer for writing general/block data */ >> private final byte[] buf = new byte[MAX_BLOCK_SIZE]; >> /** buffer for writing block data headers */ >> private final byte[] hbuf = new byte[MAX_HEADER_SIZE]; >> - /** char buffer for fast string writes */ >> - private final char[] cbuf = new char[CHAR_BUF_SIZE]; >> >> /** block data mode */ >> private boolean blkmode = false; >> @@ -1763,6 +1765,18 @@ >> /** loopback stream (for data writes that span data blocks) */ >> private final DataOutputStream dout; >> >> + /** use unsafe to directly access value field in >> java.lang.String */ >> + private static final Unsafe unsafe = Unsafe.getUnsafe(); >> + /** use field offset to directly access value field in >> java.lang.String */ >> + private static final long stringValueOffset; >> + static { >> + try { >> + stringValueOffset = >> unsafe.objectFieldOffset(String.class.getDeclaredField("value")); >> + } catch (NoSuchFieldException e) { >> + throw new InternalError(e); >> + } >> + } >> + >> /** >> * Creates new BlockDataOutputStream on top of given >> underlying stream. >> * Block data mode is turned off by default. >> @@ -1972,35 +1986,23 @@ >> } >> >> public void writeBytes(String s) throws IOException { >> - int endoff = s.length(); >> - int cpos = 0; >> - int csize = 0; >> + char[] sChars = (char[])unsafe.getObject(s, stringValueOffset); >> + int endoff = sChars.length; >> for (int off = 0; off < endoff; ) { >> - if (cpos >= csize) { >> - cpos = 0; >> - csize = Math.min(endoff - off, CHAR_BUF_SIZE); >> - s.getChars(off, off + csize, cbuf, 0); >> - } >> if (pos >= MAX_BLOCK_SIZE) { >> drain(); >> } >> - int n = Math.min(csize - cpos, MAX_BLOCK_SIZE - pos); >> + int n = Math.min(endoff - off, MAX_BLOCK_SIZE - pos); >> int stop = pos + n; >> while (pos < stop) { >> - buf[pos++] = (byte) cbuf[cpos++]; >> + buf[pos++] = (byte) sChars[off++]; >> } >> - off += n; >> } >> } >> >> public void writeChars(String s) throws IOException { >> - int endoff = s.length(); >> - for (int off = 0; off < endoff; ) { >> - int csize = Math.min(endoff - off, CHAR_BUF_SIZE); >> - s.getChars(off, off + csize, cbuf, 0); >> - writeChars(cbuf, 0, csize); >> - off += csize; >> - } >> + char[] sChars = (char[])unsafe.getObject(s, stringValueOffset); >> + writeChars(sChars, 0, sChars.length); >> } >> >> public void writeUTF(String s) throws IOException { >> @@ -2130,25 +2132,21 @@ >> } >> >> /** >> - * Returns the length in bytes of the UTF encoding of the given >> string. >> + * Returns the length in bytes of the UTF encoding of this >> given string. >> */ >> - long getUTFLength(String s) { >> - int len = s.length(); >> + static long getUTFLength(String s) { >> + char[] value = (char[])unsafe.getObject(s, stringValueOffset); >> + int len = value.length; >> long utflen = 0; >> for (int off = 0; off < len; ) { >> - int csize = Math.min(len - off, CHAR_BUF_SIZE); >> - s.getChars(off, off + csize, cbuf, 0); >> - for (int cpos = 0; cpos < csize; cpos++) { >> - char c = cbuf[cpos]; >> - if (c >= 0x0001 && c <= 0x007F) { >> - utflen++; >> - } else if (c > 0x07FF) { >> - utflen += 3; >> - } else { >> - utflen += 2; >> - } >> + char c = value[off++]; >> + if (c >= 0x0001 && c <= 0x007F) { >> + utflen++; >> + } else if (c > 0x07FF) { >> + utflen += 3; >> + } else { >> + utflen += 2; >> } >> - off += csize; >> } >> return utflen; >> } >> @@ -2198,40 +2196,36 @@ >> * 8-byte length header) of the UTF encoding for the given string. >> */ >> private void writeUTFBody(String s) throws IOException { >> + char[] sChars = (char[])unsafe.getObject(s, stringValueOffset); >> + int len = sChars.length; >> int limit = MAX_BLOCK_SIZE - 3; >> - int len = s.length(); >> for (int off = 0; off < len; ) { >> - int csize = Math.min(len - off, CHAR_BUF_SIZE); >> - s.getChars(off, off + csize, cbuf, 0); >> - for (int cpos = 0; cpos < csize; cpos++) { >> - char c = cbuf[cpos]; >> - if (pos <= limit) { >> - if (c <= 0x007F && c != 0) { >> - buf[pos++] = (byte) c; >> - } else if (c > 0x07FF) { >> - buf[pos + 2] = (byte) (0x80 | ((c >> 0) & >> 0x3F)); >> - buf[pos + 1] = (byte) (0x80 | ((c >> 6) & >> 0x3F)); >> - buf[pos + 0] = (byte) (0xE0 | ((c >> 12) & >> 0x0F)); >> - pos += 3; >> - } else { >> - buf[pos + 1] = (byte) (0x80 | ((c >> 0) & >> 0x3F)); >> - buf[pos + 0] = (byte) (0xC0 | ((c >> 6) & >> 0x1F)); >> - pos += 2; >> - } >> - } else { // write one byte at a time to >> normalize block >> - if (c <= 0x007F && c != 0) { >> - write(c); >> - } else if (c > 0x07FF) { >> - write(0xE0 | ((c >> 12) & 0x0F)); >> - write(0x80 | ((c >> 6) & 0x3F)); >> - write(0x80 | ((c >> 0) & 0x3F)); >> - } else { >> - write(0xC0 | ((c >> 6) & 0x1F)); >> - write(0x80 | ((c >> 0) & 0x3F)); >> - } >> + char c = sChars[off++]; >> + if (pos <= limit) { >> + if (c <= 0x007F && c != 0) { >> + buf[pos++] = (byte) c; >> + } else if (c > 0x07FF) { >> + buf[pos + 2] = (byte) (0x80 | ( c & 0x3F)); >> + buf[pos + 1] = (byte) (0x80 | ((c >> 6) & 0x3F)); >> + buf[pos ] = (byte) (0xE0 | ((c >> 12) & 0x0F)); >> + pos += 3; >> + } else { >> + buf[pos + 1] = (byte) (0x80 | ( c & 0x3F)); >> + buf[pos ] = (byte) (0xC0 | ((c >> 6) & 0x1F)); >> + pos += 2; >> + } >> + } else { // write one byte at a time to normalize block >> + if (c <= 0x007F && c != 0) { >> + write(c); >> + } else if (c > 0x07FF) { >> + write(0xE0 | ((c >> 12) & 0x0F)); >> + write(0x80 | ((c >> 6) & 0x3F)); >> + write(0x80 | ( c & 0x3F)); >> + } else { >> + write(0xC0 | ((c >> 6) & 0x1F)); >> + write(0x80 | ( c & 0x3F)); >> } >> } >> - off += csize; >> } >> } >> } >> @@ -2464,7 +2458,10 @@ >> StringBuilder buffer = new StringBuilder(); >> if (!stack.isEmpty()) { >> for(int i = stack.size(); i > 0; i-- ) { >> - buffer.append(stack.get(i-1) + ((i != 1) ? "\n" : "")); >> + buffer.append(stack.get(i - 1)); >> + if (i!=1) { >> + buffer.append('\n'); >> + } >> } >> } >> return buffer.toString(); >> diff --git a/src/share/classes/java/io/ObjectStreamClass.java >> b/src/share/classes/java/io/ObjectStreamClass.java >> --- a/src/share/classes/java/io/ObjectStreamClass.java >> +++ b/src/share/classes/java/io/ObjectStreamClass.java >> @@ -1474,7 +1474,28 @@ >> /** >> * Returns JVM type signature for given class. >> */ >> - private static String getClassSignature(Class<?> cl) { >> + static String getClassSignature(Class<?> cl) { >> + if (cl.isPrimitive()) >> + if (cl == Integer.TYPE) { >> + return "I"; >> + } else if (cl == Byte.TYPE) { >> + return "B"; >> + } else if (cl == Long.TYPE) { >> + return "J"; >> + } else if (cl == Float.TYPE) { >> + return "F"; >> + } else if (cl == Double.TYPE) { >> + return "D"; >> + } else if (cl == Short.TYPE) { >> + return "S"; >> + } else if (cl == Character.TYPE) { >> + return "C"; >> + } else if (cl == Boolean.TYPE) { >> + return "Z"; >> + } else if (cl == Void.TYPE) { >> + return "V"; >> + } >> + >> StringBuilder sbuf = new StringBuilder(); >> while (cl.isArray()) { >> sbuf.append('['); >> @@ -1503,7 +1524,7 @@ >> throw new InternalError(); >> } >> } else { >> - sbuf.append('L' + cl.getName().replace('.', '/') + ';'); >> + sbuf.append('L').append(cl.getName().replace('.', >> '/')).append(';'); >> } >> return sbuf.toString(); >> } >> diff --git a/src/share/classes/java/io/ObjectStreamField.java >> b/src/share/classes/java/io/ObjectStreamField.java >> --- a/src/share/classes/java/io/ObjectStreamField.java >> +++ b/src/share/classes/java/io/ObjectStreamField.java >> @@ -91,7 +91,7 @@ >> this.name = name; >> this.type = type; >> this.unshared = unshared; >> - signature = getClassSignature(type).intern(); >> + signature = ObjectStreamClass.getClassSignature(type).intern(); >> field = null; >> } >> >> @@ -137,7 +137,7 @@ >> name = field.getName(); >> Class<?> ftype = field.getType(); >> type = (showType || ftype.isPrimitive()) ? ftype : Object.class; >> - signature = getClassSignature(ftype).intern(); >> + signature = ObjectStreamClass.getClassSignature(ftype).intern(); >> } >> >> /** >> @@ -286,41 +286,4 @@ >> String getSignature() { >> return signature; >> } >> - >> - /** >> - * Returns JVM type signature for given class. >> - */ >> - private static String getClassSignature(Class<?> cl) { >> - StringBuilder sbuf = new StringBuilder(); >> - while (cl.isArray()) { >> - sbuf.append('['); >> - cl = cl.getComponentType(); >> - } >> - if (cl.isPrimitive()) { >> - if (cl == Integer.TYPE) { >> - sbuf.append('I'); >> - } else if (cl == Byte.TYPE) { >> - sbuf.append('B'); >> - } else if (cl == Long.TYPE) { >> - sbuf.append('J'); >> - } else if (cl == Float.TYPE) { >> - sbuf.append('F'); >> - } else if (cl == Double.TYPE) { >> - sbuf.append('D'); >> - } else if (cl == Short.TYPE) { >> - sbuf.append('S'); >> - } else if (cl == Character.TYPE) { >> - sbuf.append('C'); >> - } else if (cl == Boolean.TYPE) { >> - sbuf.append('Z'); >> - } else if (cl == Void.TYPE) { >> - sbuf.append('V'); >> - } else { >> - throw new InternalError(); >> - } >> - } else { >> - sbuf.append('L' + cl.getName().replace('.', '/') + ';'); >> - } >> - return sbuf.toString(); >> - } >> } >> *Gesendet:* Dienstag, 07. Januar 2014 um 10:05 Uhr >> *Von:* "Chris Hegarty" <chris.hegarty(a)oracle.com> >> *An:* "Robert Stupp" <snazy(a)gmx.de> >> *Cc:* "core-libs-dev(a)openjdk.java.net Libs" <core-libs-dev(a)openjdk.java.net> >> *Betreff:* Re: ObjectIn/OutputStream improvements >> On 15 Dec 2013, at 10:29, Robert Stupp <snazy(a)gmx.de> wrote: >> >> > Hi, >> > >> > I digged through the object serialization code and found some lines >> that could be optimized to reduce the number of calls to >> System.arraycopy() and temporary object allocations especially during >> string (de)serialization. >> > In short sentences the changes are: >> > ObjectInputStream: >> > - skip primitive/object reading if no primitive/objects in class >> (defaultReadFields method) >> > - use shared StringBuilder for string reading (prevent superfluous >> object allocations of one StingBuilder and one implicit char[] for each >> string being deserialized) >> > ObjectOutputStream: >> > - skip primitive/object writing if no primitive/objects in class >> (defaultWriteFields method) >> > - use unsafe access to calculate UTF-length >> > - use unsafe access in readBytes() and writeChars() methods to access >> String value field >> > - removed cbuf field >> > ObjectStreamClass/ObjectStreamField: >> > - minor improvement in getClassSignature ; share method code with >> ObjectStreamField (return constant string for primitives) >> > >> > I have tested the changes in a big Java installation at a customer >> (backported the Java8 ObjectIn/OutputStream including the changes to >> Java6) and a long running real application performance test resulted in >> reduced CPU usage (from about 60% per server to 50%). >> > The changes I made in openjdk8 pass all tests. >> > >> > Since I have no experience how to contribute code to openjdk in form >> of a push/changeset I have added the diff (hg export -g) to this email. >> >> Did you attach the diffs? I don’t see any attachment, it may be that the >> attachment was stripped. Can you try resending inline? >> >> You should take a look at the OpenJDK How to Contribute page [1]. Paying >> particular attention to the OCA, without it we will not be able to move >> your patch forward. >> >> Thanks, >> -Chris. >> >> [1] http://openjdk.java.net/contribute/ >> >> > >> > Robert >> > >> >

9 14