jdk8-mips64-public/langtools: test/tools/javac/lib/JavacTestingAbstractThreadedTest.java@cbcd9b484759 (annotated)

test/tools/javac/lib/JavacTestingAbstractThreadedTest.java@cbcd9b484759 (annotated)

test/tools/javac/lib/JavacTestingAbstractThreadedTest.java

Sun, 27 Jan 2013 19:38:44 +0000

author: vromero
date: Sun, 27 Jan 2013 19:38:44 +0000
changeset 1528: cbcd9b484759
parent 1520: 5c956be64b9e
child 2525: 2eb010b6cb22
permissions: -rw-r--r--

8006944: javac, combo tests should print out the number of threads used
Reviewed-by: mcimadamore

 /*
  * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 import javax.tools.JavaCompiler;
 import javax.tools.StandardJavaFileManager;
 import javax.tools.ToolProvider;
 /**
  * An abstract superclass for threaded tests.
  *
  * This class will try to read a property named test.concurrency.
  * The property can be provided by passing this option to jtreg:
  * -javaoption:-Dtest.concurrency=#
  *
  * If the property is not set the class will use a heuristic to determine the
  * maximum number of threads that can be fired to execute a given test.
  *
  * This code will have to be revisited if jprt starts using concurrency for
  * for running jtreg tests.
  */
 public abstract class JavacTestingAbstractThreadedTest {
     protected static AtomicInteger numberOfThreads = new AtomicInteger();
     protected static int getThreadPoolSize() {
         Integer testConc = Integer.getInteger("test.concurrency");
         if (testConc != null) return testConc;
         int cores = Runtime.getRuntime().availableProcessors();
         numberOfThreads.set(Math.max(2, Math.min(8, cores / 2)));
         return numberOfThreads.get();
     }
     protected static void checkAfterExec() throws InterruptedException {
         checkAfterExec(true);
     };
     protected static boolean throwAssertionOnError = true;
     protected static boolean printAll = false;
     protected static StringWriter errSWriter = new StringWriter();
     protected static PrintWriter errWriter = new PrintWriter(errSWriter);
     protected static StringWriter outSWriter = new StringWriter();
     protected static PrintWriter outWriter = new PrintWriter(outSWriter);
     protected static void checkAfterExec(boolean printCheckCount)
             throws InterruptedException {
         pool.shutdown();
         pool.awaitTermination(15, TimeUnit.MINUTES);
         if (errCount.get() > 0) {
             if (throwAssertionOnError) {
                 closePrinters();
                 System.err.println(errSWriter.toString());
                 throw new AssertionError(
                     String.format("%d errors found", errCount.get()));
             } else {
                 System.err.println(
                         String.format("%d errors found", errCount.get()));
             }
         } else if (printCheckCount) {
             outWriter.println("Total check executed: " + checkCount.get());
         }
         /*
          * This output is for supporting debugging. It does not mean that a given
          * test had executed that number of threads concurrently. The value printed
          * here is the maximum possible amount.
          */
         closePrinters();
         if (printAll) {
             System.out.println(errSWriter.toString());
             System.out.println(outSWriter.toString());
         }
         System.out.println("Total number of threads in thread pool: " +
                 numberOfThreads.get());
     }
     protected static void closePrinters() {
         errWriter.close();
         outWriter.close();
     }
     protected static void processException(Throwable t) {
         errCount.incrementAndGet();
         t.printStackTrace(errWriter);
         pool.shutdown();
     }
     //number of checks executed
     protected static AtomicInteger checkCount = new AtomicInteger();
     //number of errors found while running combo tests
     protected static AtomicInteger errCount = new AtomicInteger();
     //create default shared JavaCompiler - reused across multiple compilations
     protected static JavaCompiler comp = ToolProvider.getSystemJavaCompiler();
     protected static ExecutorService pool = Executors.newFixedThreadPool(
             getThreadPoolSize(), new ThreadFactory() {
         @Override
         public Thread newThread(Runnable r) {
             Thread t = new Thread(r);
             t.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
                 @Override
                 public void uncaughtException(Thread t, Throwable e) {
                     pool.shutdown();
                     errCount.incrementAndGet();
                     e.printStackTrace(System.err);
                 }
             });
             return t;
         }
     });
     /*
      * File manager is not thread-safe so it cannot be re-used across multiple
      * threads. However we cache per-thread FileManager to avoid excessive
      * object creation
      */
     protected static final ThreadLocal<StandardJavaFileManager> fm =
         new ThreadLocal<StandardJavaFileManager>() {
             @Override protected StandardJavaFileManager initialValue() {
                 return comp.getStandardFileManager(null, null, null);
             }
         };
 }

Mercurial > jdk8-mips64-public > langtools / annotate

test/tools/javac/lib/JavacTestingAbstractThreadedTest.java@cbcd9b484759 (annotated)

test/tools/javac/lib/JavacTestingAbstractThreadedTest.java