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 

    56     public static void main(String args[]) throws Throwable {

    57         run(args, null);

    58     }

    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 {

   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;

   137     ParallelLoadThread(int thread_id) {

   138         this.thread_id = thread_id;

   139     }

   140 

   141     public void run() {

   142         try {

   143             run0();

   144         } catch (Throwable t) {

   145             t.printStackTrace();

   146             System.exit(1);

   147         }

   148     }

   149 

   150     private static void log(String msg, Object... args) {

   151         String msg0 = "ParallelLoadThread: " + String.format(msg, args);

   152         System.out.println(msg0);

   153     }

   154 

   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 

   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 

   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