February 2012 - core-libs-dev

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

Code review request: 6282196 There should be Math.mod(number, modulo) methods
by Roger Riggs 18 Apr '12

18 Apr '12

Hi, 6282196 There should be Math.mod(number, modulo) methods <http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6282196> Requests that floor and modulus methods be provided for primitive types. Floor division is pretty straight-forward, rounding toward minus infinity. For modulus of int and long, the sign and range follow the exiting floor method in java.util.Math and satisfy the relation that mod(x, y) = (x - floorDiv(x, y) * y). Please review and comment, http://cr.openjdk.java.net/~rriggs/6282196.1/ Thanks, Roger

5 9

Code review request: 7088502 Security libraries don't build with javac -Werror
by Kurchi Hazra 02 Mar '12

02 Mar '12

Hi, The following webrev removes warnings in sun.rmi.* packages. I have neglected nearly all deprecation warnings, since this code uses deprecated classes such as java.rmi.server.LogStream with no suggested replacements. I have included -Xlint:all,-deprecation as an option instead in the appropriate Makefiles. Bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7146763 Webrev: http://cr.openjdk.java.net/~khazra/7146763/webrev.00/ Thanks, Kurchi

5 16

JEP 150: JSR 310: Date and Time API
by mark.reinhold＠oracle.com 29 Feb '12

29 Feb '12

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

1 0

JEP 149: Reduce Core-Library Memory Usage
by mark.reinhold＠oracle.com 29 Feb '12

29 Feb '12

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

1 0

RFR 7149320: Move sun.misc.VM.booted() to end of System.initializeSystemClass()
by Mike Duigou 29 Feb '12

29 Feb '12

Hello all; This issue is a patch for review that I have split out of a larger issue I'll be submitting later. WEBREV @ http://cr.openjdk.java.net/~mduigou/7149320/0/webrev/ sun.misc.VM.booted() is currently called before setJavaLangAccess(). For code which uses the JavaLangAccess shared secrets it's convenient to be able to check whether the secrets are initialized without having to call sun.misc.SharedSecrets.getJavaLangAccess() every time the secrets are used and checking for null. In particular with the static inner class holder idiom it would be desirable to do : static class Holder { final sun.misc.JavaLangAccess ACCESS = sun.misc.SharedSecrets.getJavaLangAccess(); } ... if(sun.misc.VM.isBooted() && Holder.ACCESS... In my research on this issue I was unable to determine why sun.misc.VM.booted() isn't the currently the last activity in System.initSystemClass(). Neither of the two tasks which currently follow it depend upon booted state in any way that I could determine. I am tempted, thinking about it, to add a comment to System.initSystemClass before the call to sun.misc.VM.booted() asking future maintainers to leave boot() as the last activity or explain why not. I have done JTReg runs on linux x86, linux x64 and Solaris 64 which incorporated this change without any problems encountered. It's rather difficult to write a unit test for this issue as it requires a class that is initialized after java.lang.System but before java.lang.System.initSystemClass() and uses JavaLangAccess. Thanks, Mike

3 5

hg: jdk8/tl/jdk: 7148499: Stack size in tools/launcher/Settings.java needs to be increased
by kumar.x.srinivasan＠oracle.com 29 Feb '12

29 Feb '12

Changeset: bd43a6f59c9b Author: ksrini Date: 2012-02-29 08:20 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/bd43a6f59c9b 7148499: Stack size in tools/launcher/Settings.java needs to be increased Reviewed-by: alanb ! test/ProblemList.txt ! test/tools/launcher/Settings.java

1 0

Please review fix for: 7148499
by Kumar Srinivasan 29 Feb '12

29 Feb '12

Hi, Please review fix for launcher tests, the JVM requires a higher stack size for 64bit systems, this fixes increases the stack size and removes the test from the problem list. fyi, The stack size is specified here so that the launcher flag under test, parses and scales these options for human readability. http://cr.openjdk.java.net/~ksrini/7148499/webrev.0/ Thanks Kumar

3 3

hg: jdk8/tl/jdk: 18 new changesets
by lana.steuck＠oracle.com 29 Feb '12

29 Feb '12

Changeset: 7d683ab46571 Author: katleman Date: 2012-02-23 12:03 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/7d683ab46571 Added tag jdk8-b27 for changeset c68342532e2e ! .hgtags Changeset: 2152ac3e4575 Author: dl Date: 2011-10-12 16:33 +0100 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/2152ac3e4575 7082299: AtomicReferenceArray should ensure that array is Object[] Reviewed-by: chegar, dholmes, alanb ! src/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java Changeset: 23c3d1a0e150 Author: amenkov Date: 2011-10-26 14:00 +0400 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/23c3d1a0e150 7088367: JavaSound security issue (12865443) Reviewed-by: denis ! src/share/classes/com/sun/media/sound/DirectAudioDevice.java ! src/share/classes/com/sun/media/sound/SoftMixingSourceDataLine.java + test/javax/sound/sampled/DataLine/DataLine_ArrayIndexOutOfBounds.java Changeset: 3ee041967af6 Author: smarks Date: 2011-11-11 15:22 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/3ee041967af6 7110700: Enhance exception throwing mechanism in ObjectStreamClass Reviewed-by: dmeetry, hawtin ! src/share/classes/java/io/ObjectStreamClass.java ! test/java/io/Serializable/expectedStackTrace/ExpectedStackTrace.java Changeset: 18335c98ab8b Author: smarks Date: 2011-11-17 15:04 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/18335c98ab8b 7112267: clean up fix for 7110700 Reviewed-by: dmeetry ! test/java/io/Serializable/expectedStackTrace/ExpectedStackTrace.java Changeset: 4b98d2682c31 Author: okutsu Date: 2011-12-14 11:23 +0900 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/4b98d2682c31 6351654: Problem with java/classes_util_i18n Reviewed-by: hawtin, coffeys ! make/java/java/FILES_java.gmk ! src/share/classes/java/util/TimeZone.java ! src/share/classes/sun/awt/AppContext.java + src/share/classes/sun/misc/JavaAWTAccess.java ! src/share/classes/sun/misc/SharedSecrets.java Changeset: 5d7e49a3a2f9 Author: bagiras Date: 2011-12-14 14:43 +0400 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/5d7e49a3a2f9 7112642: Incorrect checking for graphics rendering object Reviewed-by: art, bae ! src/share/classes/sun/java2d/SunGraphics2D.java ! src/share/classes/sun/java2d/opengl/OGLRenderer.java ! src/share/classes/sun/java2d/pipe/BufferedContext.java ! src/windows/classes/sun/java2d/d3d/D3DRenderer.java ! src/windows/classes/sun/java2d/windows/GDIRenderer.java ! src/windows/native/sun/java2d/windows/GDIRenderer.cpp Changeset: a7cb0afadbee Author: sherman Date: 2011-12-15 14:18 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/a7cb0afadbee 7118283: Better input parameter checking in zip file processing Summary: Fixed off-by-one bug in zip_util.c Reviewed-by: alanb ! src/share/native/java/util/zip/zip_util.c Changeset: d544965b59fe Author: bagiras Date: 2011-12-28 14:26 +0400 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/d544965b59fe 7121482: some sun/java2d and sun/awt tests failed with InvalidPipeException since 1.7.0_03b02, 6u31b02 Reviewed-by: art, bae ! src/share/classes/sun/java2d/SunGraphics2D.java Changeset: 5e6f3c8646cf Author: xuelei Date: 2012-01-09 20:55 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/5e6f3c8646cf 7123519: problems with certification path Summary: Also including the contribution from Dennis Gu Reviewed-by: mullan, weijun ! src/share/classes/sun/security/provider/certpath/ForwardBuilder.java ! src/share/classes/sun/security/provider/certpath/ForwardState.java ! src/share/classes/sun/security/provider/certpath/PKIXCertPathValidator.java ! src/share/classes/sun/security/provider/certpath/ReverseBuilder.java ! src/share/classes/sun/security/provider/certpath/ReverseState.java ! src/share/classes/sun/security/provider/certpath/SunCertPathBuilder.java + src/share/classes/sun/security/provider/certpath/UntrustedChecker.java + src/share/classes/sun/security/util/UntrustedCertificates.java ! src/share/classes/sun/security/validator/SimpleValidator.java ! src/share/classes/sun/security/validator/ValidatorException.java + test/sun/security/provider/certpath/X509CertPath/ForwardBuildCompromised.java + test/sun/security/provider/certpath/X509CertPath/ReverseBuildCompromised.java + test/sun/security/provider/certpath/X509CertPath/ValidateCompromised.java + test/sun/security/ssl/com/sun/net/ssl/internal/ssl/X509TrustManagerImpl/ComodoHacker.java Changeset: d9897e95323c Author: chegar Date: 2012-01-18 15:35 +0000 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/d9897e95323c 7126960: Add property to limit number of request headers to the HTTP Server Reviewed-by: michaelm ! src/share/classes/sun/net/httpserver/Request.java ! src/share/classes/sun/net/httpserver/ServerConfig.java Changeset: 7699f0a9c6d7 Author: asaha Date: 2012-02-20 11:31 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/7699f0a9c6d7 Merge ! make/java/java/FILES_java.gmk ! src/share/classes/java/io/ObjectStreamClass.java ! src/share/classes/java/util/TimeZone.java ! src/share/classes/java/util/concurrent/atomic/AtomicReferenceArray.java ! src/share/classes/sun/awt/AppContext.java ! src/share/classes/sun/java2d/SunGraphics2D.java ! src/share/classes/sun/misc/SharedSecrets.java ! src/share/classes/sun/net/httpserver/Request.java ! src/share/classes/sun/net/httpserver/ServerConfig.java ! src/share/classes/sun/security/provider/certpath/ForwardBuilder.java ! src/share/classes/sun/security/provider/certpath/ForwardState.java ! src/share/classes/sun/security/provider/certpath/PKIXCertPathValidator.java ! src/share/classes/sun/security/provider/certpath/ReverseState.java ! src/share/classes/sun/security/validator/SimpleValidator.java Changeset: f525c1e9e12c Author: lana Date: 2012-02-23 00:14 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/f525c1e9e12c Merge Changeset: fcdd5a4bae0e Author: lana Date: 2012-02-23 07:54 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/fcdd5a4bae0e Merge Changeset: ca2218135bac Author: asaha Date: 2012-02-24 17:31 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/ca2218135bac 7148758: Resolve merge issue which caused testcase failure Reviewed-by: alanb, chegar ! src/share/classes/sun/net/httpserver/ServerConfig.java Changeset: 39dcb3264fb3 Author: lana Date: 2012-02-24 17:38 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/39dcb3264fb3 Merge Changeset: 1e1d41daaded Author: lana Date: 2012-02-24 18:24 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/1e1d41daaded Merge Changeset: 61c36875de46 Author: lana Date: 2012-02-28 18:01 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/jdk/rev/61c36875de46 Merge

1 0

hg: jdk8/tl/langtools: 6 new changesets
by lana.steuck＠oracle.com 29 Feb '12

29 Feb '12

Changeset: 8503479162bd Author: katleman Date: 2012-02-23 12:03 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/langtools/rev/8503479162bd Added tag jdk8-b27 for changeset be456f9c64e8 ! .hgtags Changeset: 3b168225dfc0 Author: asaha Date: 2012-02-14 10:29 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/langtools/rev/3b168225dfc0 Merge - src/share/classes/com/sun/tools/javac/Launcher.java Changeset: d903497bf389 Author: asaha Date: 2012-02-17 14:59 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/langtools/rev/d903497bf389 Merge Changeset: a696a8610b2a Author: lana Date: 2012-02-23 07:53 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/langtools/rev/a696a8610b2a Merge Changeset: 5bed623b0c77 Author: lana Date: 2012-02-24 18:24 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/langtools/rev/5bed623b0c77 Merge Changeset: 3d3350aea968 Author: lana Date: 2012-02-28 18:04 -0800 URL: http://hg.openjdk.java.net/jdk8/tl/langtools/rev/3d3350aea968 Merge

1 0