1 /*
2  * Copyright (c) 2016, 2017, 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 import java.io.*;
26 import java.net.*;
27 import java.lang.reflect.Field;
28 
29 
30 // This test helper is parameterized by:
31 // - class transformation mode: property "appcds.parallel.transform.mode"
32 // - class loader test types
33 //
34 // In the case of transformMode == "cflh", the transformation is performed
35 // by AppCDS/jvmti/TransformerAgent.java. The classes to be transformed, such as
36 // ParallelClassTr0, are defined in ./jvmti/parallelLoad/ParallelClasses.java
37 
38 public class ParallelLoad {
39     public static int MAX_CLASSES = 40;
40     public static int NUM_THREADS = 4;
41 
42     public final static int SYSTEM_LOADER = 0;
43     public final static int SINGLE_CUSTOM_LOADER = 1;
44     public final static int MULTI_CUSTOM_LOADER = 2;
45 
46     public static final int FINGERPRINT_MODE = 1;
47     public static final int API_MODE         = 2;
48 
49     public static int loaderType = SYSTEM_LOADER;
50     public static ClassLoader classLoaders[];
51     public static int mode = FINGERPRINT_MODE;
52 
53     public static float timeoutFactor =
54         Float.parseFloat(System.getProperty("test.timeout.factor", "1.0"));
55 
main(String args[])56     public static void main(String args[]) throws Throwable {
57         run(args, null);
58     }
run(String args[], ClassLoader loaders[])59     public static void run(String args[], ClassLoader loaders[]) throws Throwable {
60         String customJar = null;
61         System.out.println("ParallelLoad: timeoutFactor = " + timeoutFactor);
62 
63         if (args.length >= 1) {
64             if ("SINGLE_CUSTOM_LOADER".equals(args[0])) {
65                 loaderType = SINGLE_CUSTOM_LOADER;
66                 customJar = args[2];
67             } else if ("MULTI_CUSTOM_LOADER".equals(args[0])) {
68                 loaderType = MULTI_CUSTOM_LOADER;
69                 customJar = args[2];
70             } else if ("SYSTEM_LOADER".equals(args[0])) {
71                 loaderType = SYSTEM_LOADER;
72             } else {
73                 throw new RuntimeException("Unexpected loaderType" + args[0]);
74             }
75         }
76 
77         if (customJar != null) {
78             if ("FINGERPRINT_MODE".equals(args[1])) {
79                 mode = FINGERPRINT_MODE;
80                 classLoaders = new ClassLoader[NUM_THREADS];
81                 for (int i=0; i<NUM_THREADS; i++) {
82                     URL url = new File(customJar).toURI().toURL();
83                     URL[] urls = new URL[] {url};
84                     classLoaders[i] = new URLClassLoader(urls);
85                 }
86             } else {
87                 // Loaders must be supplied by caller of the run() method
88                 mode = API_MODE;
89                 classLoaders = loaders;
90             }
91         }
92 
93         System.out.println("Start Parallel Load ...");
94 
95         Thread thread[] = new Thread[NUM_THREADS];
96         for (int i=0; i<NUM_THREADS; i++) {
97             Thread t = new ParallelLoadThread(i);
98             t.start();
99             thread[i] = t;
100         }
101 
102         Thread watchdog = new ParallelLoadWatchdog();
103         watchdog.setDaemon(true);
104         watchdog.start();
105 
106         for (int i=0; i<NUM_THREADS; i++) {
107             thread[i].join();
108         }
109         System.out.println("Parallel Load ... done");
110         System.exit(0);
111     }
112 }
113 
114 
115 class ParallelLoadWatchdog extends Thread {
run()116     public void run() {
117         try {
118             long timeout = (long) (20 * 1000 * ParallelLoad.timeoutFactor);
119             Thread.sleep(timeout);
120             System.out.println("ParallelLoadWatchdog: Timeout reached: timeout(ms) = " + timeout);
121             System.exit(1);
122         } catch (Throwable t) {
123             t.printStackTrace();
124             System.exit(1);
125         }
126     }
127 };
128 
129 
130 class ParallelLoadThread extends Thread {
131     static int num_ready[] = new int[ParallelLoad.MAX_CLASSES];
132     static Object lock = new Object();
133     static String transformMode =
134         System.getProperty("appcds.parallel.transform.mode", "none");
135 
136     int thread_id;
ParallelLoadThread(int thread_id)137     ParallelLoadThread(int thread_id) {
138         this.thread_id = thread_id;
139     }
140 
run()141     public void run() {
142         try {
143             run0();
144         } catch (Throwable t) {
145             t.printStackTrace();
146             System.exit(1);
147         }
148     }
149 
log(String msg, Object... args)150     private static void log(String msg, Object... args) {
151         String msg0 = "ParallelLoadThread: " + String.format(msg, args);
152         System.out.println(msg0);
153     }
154 
run0()155     private void run0() throws Throwable {
156         for (int i=0; i<ParallelLoad.MAX_CLASSES; i++) {
157             synchronized(lock) {
158                 num_ready[i] ++;
159                 while (num_ready[i] < ParallelLoad.NUM_THREADS) {
160                     lock.wait();
161                 }
162                 lock.notifyAll();
163             }
164             log("this = %s %d", this, i);
165             String className = "ParallelClass" + i;
166             if (transformMode.equals("cflh"))
167                 className = "ParallelClassTr" + i;
168 
169             Class clazz = null;
170 
171             switch (ParallelLoad.loaderType) {
172             case ParallelLoad.SYSTEM_LOADER:
173                 clazz = Class.forName(className);
174                 break;
175             case ParallelLoad.SINGLE_CUSTOM_LOADER:
176                 clazz = ParallelLoad.classLoaders[0].loadClass(className);
177                 break;
178             case ParallelLoad.MULTI_CUSTOM_LOADER:
179                 clazz = ParallelLoad.classLoaders[thread_id].loadClass(className);
180                 break;
181             }
182 
183             log("clazz = %s", clazz);
184             testTransformation(clazz);
185         }
186     }
187 
testTransformation(Class c)188     private void testTransformation(Class c) throws Exception {
189         if (transformMode.equals("none"))
190             return;
191 
192         // currently only cflh transform mode is supported
193         if (!transformMode.equals("cflh")) {
194             String msg = "wrong transform mode: " + transformMode;
195             throw new IllegalArgumentException(msg);
196         }
197 
198         Field[] fields = c.getFields();
199         boolean fieldFound = false;
200         for (Field f : fields) {
201             if (f.getName().equals("testString")) {
202                 checkTransformationString(c, (String) f.get(null));
203                 fieldFound = true;
204             }
205         }
206 
207         if (!fieldFound)
208             throw new RuntimeException ("Expected field 'testString' not found");
209     }
210 
checkTransformationString(Class c, String actual)211     private void checkTransformationString(Class c, String actual) throws Exception {
212         String expected = "class-transform-check: this-has-been--transformed";
213         if (!actual.equals(expected)) {
214             String msg1 = "Transformation failed for class" + c.getName();
215             String msg2 = String.format("Expected: %s, actual: %s", expected, actual);
216             throw new RuntimeException(msg1 + "\n" + msg2);
217         }
218     }
219 }
220 
221