On 10/29/2014 02:08 PM, Joel Borggrén-Franck wrote:
Hi Peter,
I’m not entirely convinced this is a bug.
The lookup order for getMethod has for a long time been walk up superclasses
and return what you find there first without even looking at interfaces. It
might be desirable to change that but I’m not sure.
Hi Joel,
It has been for a long time like that as you say, but for a long time
Java did not have default methods. It's unexpected for getMethod() to
return a method that is not contained in getMethods() result.
Anyway, I have created a bug to track this:
https://bugs.openjdk.java.net/browse/JDK-8062389
For next iteration of the getMethods() O(n^2) fix, I used a slightly
different approach, which you might like more or not. Instead of using
linked-lists of Method objects as values of a LinkedHashMap I created a
special Key object, holding a reference to Method object and an
additional 'seq' int field, which discriminates among methods with same
signature. Values of LinkedHashMap are Method objects themselves:
http://cr.openjdk.java.net/~plevart/jdk9-dev/Class.getMethods/webrev.03/
I have encapsulated this functionality into a package-private
java.lang.MethodTable. The implementation of this API can be easily
changed to using linked-lists as values of LinkedHashMap if desired. The
performance characteristics are similar, with hardly measurable
advantage of this latest approach as can be seen from
http://cr.openjdk.java.net/~plevart/jdk9-dev/Class.getMethods/GetAllRtMethods.java
benchmark:
Original code:
19658 classes loaded in 2.071013902 seconds.
494392 methods obtained in 1.089983418 seconds.
494392 methods obtained in 0.952488497 seconds.
494392 methods obtained in 0.912878317 seconds.
494392 methods obtained in 0.940293784 seconds.
494392 methods obtained in 0.987640733 seconds.
494392 methods obtained in 0.925393355 seconds.
494392 methods obtained in 0.89397002 seconds.
494392 methods obtained in 0.915042463 seconds.
494392 methods obtained in 0.897669082 seconds.
494392 methods obtained in 0.878140502 seconds.
Patched code:
19658 classes loaded in 2.153024197 seconds.
494392 methods obtained in 0.875651469 seconds.
494392 methods obtained in 0.791937742 seconds.
494392 methods obtained in 0.780995693 seconds.
494392 methods obtained in 0.759593461 seconds.
494392 methods obtained in 0.766528355 seconds.
494392 methods obtained in 0.756567663 seconds.
494392 methods obtained in 0.739177848 seconds.
494392 methods obtained in 0.729245613 seconds.
494392 methods obtained in 0.74081083 seconds.
494392 methods obtained in 0.731749505 seconds.
Martin's ManyMethodsBenchmark shows this algorithm has O(n) time
complexity too:
Original:
Base class load time: 131.95 ms
getDeclaredMethods: 65521 methods, 32.00 ms total time, 0.0005 ms per method
getMethods : 65530 methods, 44.24 ms total time, 0.0007 ms per method
Derived class load time: 32525.23 ms
getDeclaredMethods: 65521 methods, 30.37 ms total time, 0.0005 ms per method
getMethods : 65530 methods, 7897.03 ms total time, 0.1205 ms per
method
Patched:
Base class load time: 129.72 ms
getDeclaredMethods: 65521 methods, 32.76 ms total time, 0.0005 ms per method
getMethods : 65530 methods, 42.68 ms total time, 0.0007 ms per method
Derived class load time: 31620.47 ms
getDeclaredMethods: 65521 methods, 30.49 ms total time, 0.0005 ms per method
getMethods : 65530 methods, 88.23 ms total time, 0.0013 ms per method
I have also run Martin's LoadAllClassesAndMethods test (Thanks Martin, I
changed it slightly so that exceptions are collected and reported at the
end instead of bailing-out on first exception).
Original LoadAllClassesAndMethods write classlist.txt:
class load: 23052 classes, 1563.75 ms total time, 0.0678 ms per class
4 exceptions encountered:
java.lang.IncompatibleClassChangeError:
jdk.nashorn.internal.codegen.CompilationPhase$10 and
jdk.nashorn.internal.codegen.CompilationPhase$10$1 disagree on
InnerClasses attribute
java.lang.IncompatibleClassChangeError:
jdk.nashorn.internal.codegen.CompilationPhase$5 and
jdk.nashorn.internal.codegen.CompilationPhase$5$1 disagree on
InnerClasses attribute
java.lang.IncompatibleClassChangeError:
java.security.ProtectionDomain$3 and java.security.ProtectionDomain$3$1
disagree on InnerClasses attribute
java.lang.IncompatibleClassChangeError: java.lang.Compiler and
java.lang.Compiler$1 disagree on InnerClasses attribute
getMethods: 23052 classes, 831.87 ms total time, 0.0361 ms per class
Patched LoadAllClassesAndMethods diff classlist.txt:
class load: 23051 classes, 1596.58 ms total time, 0.0693 ms per class
5 exceptions encountered:
java.lang.IncompatibleClassChangeError:
jdk.nashorn.internal.codegen.CompilationPhase$10 and
jdk.nashorn.internal.codegen.CompilationPhase$10$1 disagree on
InnerClasses attribute
java.lang.IncompatibleClassChangeError:
jdk.nashorn.internal.codegen.CompilationPhase$5 and
jdk.nashorn.internal.codegen.CompilationPhase$5$1 disagree on
InnerClasses attribute
java.lang.IncompatibleClassChangeError: java.lang.Class and
java.lang.Class$MethodArray disagree on InnerClasses attribute
java.lang.IncompatibleClassChangeError:
java.security.ProtectionDomain$3 and java.security.ProtectionDomain$3$1
disagree on InnerClasses attribute
java.lang.IncompatibleClassChangeError: java.lang.Compiler and
java.lang.Compiler$1 disagree on InnerClasses attribute
getMethods: 23051 classes, 799.99 ms total time, 0.0347 ms per class
The following classes were expected, but not found:
[java.lang.Class$MethodArray]
The reason for Class$MethodArray to not be loaded by patched code is the
way I tested patched j.l.Class. I prepended the boot classpath with a
directory holding patched Class/MethodTable. Martin's
LoadAllClassesAndMethods tries to load Class$MethodArray anyway, since
it's in rt.jar, but this class is gone in patched j.l.Class, so
"IncompatibleClassChangeError: java.lang.Class and
java.lang.Class$MethodArray disagree on InnerClasses attribute" is
expected in this case. Otherwise this test shows that original and
patched code agree on results returned from getMethods() for all system
and extension JDK classes.
All 86 jtreg tests in java/lang/Class/ and java/lang/reflect/ pass.
I still have to create a test case for inconsistency I discovered in
previous iteration.
Regards, Peter
cheers
/Joel
On 29 okt 2014, at 12:26, Peter Levart <peter.lev...@gmail.com> wrote:
Hi Joel,
I found an inconsistency between getMethod() and getMethods() results that is
present in current JDK8/9 code and in my latest webrev.02. The following
program:
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class GetMethodTest {
static void test(Class<?> clazz) throws Exception {
System.out.println(clazz.getName() + ".class.getMethods(): " +
Stream
.of(clazz.getMethods())
.filter(m -> m.getDeclaringClass() !=
Object.class)
.collect(Collectors.toList()));
System.out.println(clazz.getName() + ".class.getMethod(\"m\"): " +
clazz.getMethod("m"));
System.out.println();
}
public static void main(String[] args) throws Exception {
test(I.class);
test(J.class);
test(A.class);
test(B.class);
}
}
interface I {
void m();
}
interface J extends I {
default void m() {}
}
abstract class A implements I {}
abstract class B extends A implements J {}
prints:
I.class.getMethods(): [public abstract void I.m()]
I.class.getMethod("m"): public abstract void I.m()
J.class.getMethods(): [public default void J.m()]
J.class.getMethod("m"): public default void J.m()
A.class.getMethods(): [public abstract void I.m()]
A.class.getMethod("m"): public abstract void I.m()
B.class.getMethods(): [public default void J.m()]
B.class.getMethod("m"): public abstract void I.m()
B.class.getMethods() reports default method J.m() (which I think is correct), but
B.class.getMethod("m") reports the abstract I.m() inherited from A, because
here the getMethod0() algorithm stops searching for and consolidating any methods in
(super)interfaces. Do you agree that this is a bug?
Regards, Peter
On 10/27/2014 02:45 PM, Joel Borggrén-Franck wrote:
Hi Peter,
As always, thanks for doing this! It has been on my todolist for a while but
never quite bubbling up to the top.
I don’t have time to look att his right now, but I expect to have some free
time next week, but i have two short comments
First, I have been thinking about moving MethodArray to its’s own top-level
class, isn’t it about time?
Second I would expect testing for the missing cases you uncovered (good catch!).
I’ll try to get back to you asap.
cheers
/Joel
On 26 okt 2014, at 23:53, Peter Levart <peter.lev...@gmail.com> wrote:
On 10/26/2014 09:25 PM, Peter Levart wrote:
19657 classes loaded in 1.987373401 seconds.
494141 methods obtained in 1.02493941 seconds.
vs.
19657 classes loaded in 2.084409717 seconds.
494124 methods obtained in 0.915928578 seconds.
Hi,
As you might have noticed, the number of methods obtained from patched code
differed from original code. I have investigated this and found that original
code treats abstract class methods the same as abstract interface methods as
far as multiple inheritance is concerned (it keeps them together in the
returned array). So I fixed this and here's new webrev which behaves the same
as original code:
http://cr.openjdk.java.net/~plevart/jdk9-dev/Class.getMethods/webrev.02/
Comparing original vs. patched code still shows speed-up:
Original:
19657 classes loaded in 1.980493029 seconds.
494141 methods obtained in 0.976318927 seconds.
494141 methods obtained in 0.886504437 seconds.
494141 methods obtained in 0.911153722 seconds.
494141 methods obtained in 0.880550509 seconds.
494141 methods obtained in 0.875526704 seconds.
494141 methods obtained in 0.877258894 seconds.
494141 methods obtained in 0.871794344 seconds.
494141 methods obtained in 0.884159644 seconds.
494141 methods obtained in 0.892648522 seconds.
494141 methods obtained in 0.884581841 seconds.
Patched:
19657 classes loaded in 2.055697675 seconds.
494141 methods obtained in 0.853922188 seconds.
494141 methods obtained in 0.776203794 seconds.
494141 methods obtained in 0.858774803 seconds.
494141 methods obtained in 0.778178867 seconds.
494141 methods obtained in 0.760043997 seconds.
494141 methods obtained in 0.756352444 seconds.
494141 methods obtained in 0.740826372 seconds.
494141 methods obtained in 0.744264782 seconds.
494141 methods obtained in 0.73805894 seconds.
494141 methods obtained in 0.746852752 seconds.
55 java/lang/reflect jtreg tests still pass. As they did before, which means
that we don't have a coverage for such cases. I'll see where I can add such a
case (EnumSet for example, which inherits from Set interface and
AbstractColection class via two different paths, so Set.size()/iterator() and
AbstractCollection.size()/iterator() are both returned from getMethods())...
Regards, Peter
