1/*
2 * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24/**
25 * @test
26 * @summary smoke tests for CallSite
27 *
28 * @build indify.Indify
29 * @compile CallSiteTest.java
30 * @run main/othervm/timeout=3600 -XX:+IgnoreUnrecognizedVMOptions -XX:-VerifyDependencies
31 *      indify.Indify
32 *      --expand-properties --classpath ${test.classes}
33 *      --java test.java.lang.invoke.CallSiteTest
34 */
35
36package test.java.lang.invoke;
37
38import java.io.*;
39
40import java.lang.invoke.*;
41import static java.lang.invoke.MethodHandles.*;
42import static java.lang.invoke.MethodType.*;
43
44public class CallSiteTest {
45    private static final Class<?> CLASS = CallSiteTest.class;
46
47    private static CallSite mcs;
48    private static CallSite vcs;
49    private static MethodHandle mh_foo;
50    private static MethodHandle mh_bar;
51
52    static {
53        try {
54            mh_foo = lookup().findStatic(CLASS, "foo", methodType(int.class, int.class, int.class));
55            mh_bar = lookup().findStatic(CLASS, "bar", methodType(int.class, int.class, int.class));
56            mcs = new MutableCallSite(mh_foo);
57            vcs = new VolatileCallSite(mh_foo);
58        } catch (Exception e) {
59            e.printStackTrace();
60        }
61    }
62
63    public static void main(String... av) throws Throwable {
64        testMutableCallSite();
65        testVolatileCallSite();
66    }
67
68    private static final int N = Integer.MAX_VALUE / 100;
69    private static final int RESULT1 = 762786192;
70    private static final int RESULT2 = -21474836;
71
72    private static void assertEquals(int expected, int actual) {
73        if (expected != actual)
74            throw new AssertionError("expected: " + expected + ", actual: " + actual);
75    }
76
77    private static void testMutableCallSite() throws Throwable {
78        // warm-up
79        for (int i = 0; i < 20000; i++) {
80            mcs.setTarget(mh_foo);
81        }
82        // run
83        for (int n = 0; n < 2; n++) {
84            mcs.setTarget(mh_foo);
85            for (int i = 0; i < 5; i++) {
86                assertEquals(RESULT1, runMutableCallSite());
87            }
88            mcs.setTarget(mh_bar);
89            for (int i = 0; i < 5; i++) {
90                assertEquals(RESULT2, runMutableCallSite());
91            }
92        }
93    }
94    private static void testVolatileCallSite() throws Throwable {
95        // warm-up
96        for (int i = 0; i < 20000; i++) {
97            vcs.setTarget(mh_foo);
98        }
99        // run
100        for (int n = 0; n < 2; n++) {
101            vcs.setTarget(mh_foo);
102            for (int i = 0; i < 5; i++) {
103                assertEquals(RESULT1, runVolatileCallSite());
104            }
105            vcs.setTarget(mh_bar);
106            for (int i = 0; i < 5; i++) {
107                assertEquals(RESULT2, runVolatileCallSite());
108            }
109        }
110    }
111
112    private static int runMutableCallSite() throws Throwable {
113        int sum = 0;
114        for (int i = 0; i < N; i++) {
115            sum += (int) INDY_mcs().invokeExact(i, i+1);
116        }
117        return sum;
118    }
119    private static int runVolatileCallSite() throws Throwable {
120        int sum = 0;
121        for (int i = 0; i < N; i++) {
122            sum += (int) INDY_vcs().invokeExact(i, i+1);
123        }
124        return sum;
125    }
126
127    static int foo(int a, int b) { return a + b; }
128    static int bar(int a, int b) { return a - b; }
129
130    private static MethodType MT_bsm() {
131        shouldNotCallThis();
132        return methodType(CallSite.class, Lookup.class, String.class, MethodType.class);
133    }
134
135    private static CallSite bsm_mcs(Lookup caller, String name, MethodType type) throws ReflectiveOperationException {
136        return mcs;
137    }
138    private static MethodHandle MH_bsm_mcs() throws ReflectiveOperationException {
139        shouldNotCallThis();
140        return lookup().findStatic(lookup().lookupClass(), "bsm_mcs", MT_bsm());
141    }
142    private static MethodHandle INDY_mcs() throws Throwable {
143        shouldNotCallThis();
144        return ((CallSite) MH_bsm_mcs().invoke(lookup(), "foo", methodType(int.class, int.class, int.class))).dynamicInvoker();
145    }
146
147    private static CallSite bsm_vcs(Lookup caller, String name, MethodType type) throws ReflectiveOperationException {
148        return vcs;
149    }
150    private static MethodHandle MH_bsm_vcs() throws ReflectiveOperationException {
151        shouldNotCallThis();
152        return lookup().findStatic(lookup().lookupClass(), "bsm_vcs", MT_bsm());
153    }
154    private static MethodHandle INDY_vcs() throws Throwable {
155        shouldNotCallThis();
156        return ((CallSite) MH_bsm_vcs().invoke(lookup(), "foo", methodType(int.class, int.class, int.class))).dynamicInvoker();
157    }
158
159    private static void shouldNotCallThis() {
160        // if this gets called, the transformation has not taken place
161        throw new AssertionError("this code should be statically transformed away by Indify");
162    }
163}
164