| package org.apache.maven.surefire.junitcore.pc; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import org.apache.maven.surefire.junitcore.JUnitCoreParameters; |
| import org.apache.maven.surefire.api.testset.TestSetFailedException; |
| import org.junit.runner.Description; |
| |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Iterator; |
| |
| /** |
| * An algorithm which configures {@link ParallelComputer} with allocated thread resources by given |
| * {@link org.apache.maven.surefire.junitcore.JUnitCoreParameters}. |
| * The {@code AbstractSurefireMojo} has to provide correct combinations of thread-counts and |
| * configuration parameter {@code parallel}. |
| * |
| * @author Tibor Digana (tibor17) |
| * @see org.apache.maven.surefire.junitcore.pc.ParallelComputerBuilder |
| * @since 2.16 |
| */ |
| final class ParallelComputerUtil |
| { |
| private static final Collection<Description> UNUSED_DESCRIPTIONS = |
| Arrays.asList( null, Description.createSuiteDescription( "null" ), Description.TEST_MECHANISM, |
| Description.EMPTY ); |
| |
| private static int availableProcessors = Runtime.getRuntime().availableProcessors(); |
| |
| private ParallelComputerUtil() |
| { |
| throw new IllegalStateException( "Suppresses calling constructor, ensuring non-instantiability." ); |
| } |
| |
| /* |
| * For testing purposes. |
| */ |
| static void overrideAvailableProcessors( int availableProcessors ) |
| { |
| ParallelComputerUtil.availableProcessors = availableProcessors; |
| } |
| |
| /* |
| * For testing purposes. |
| */ |
| static void setDefaultAvailableProcessors() |
| { |
| ParallelComputerUtil.availableProcessors = Runtime.getRuntime().availableProcessors(); |
| } |
| |
| static Concurrency resolveConcurrency( JUnitCoreParameters params, RunnerCounter counts ) |
| throws TestSetFailedException |
| { |
| if ( !params.isParallelismSelected() ) |
| { |
| throw new TestSetFailedException( "Unspecified parameter '" + JUnitCoreParameters.PARALLEL_KEY + "'." ); |
| } |
| |
| if ( !params.isUseUnlimitedThreads() && !hasThreadCount( params ) && !hasThreadCounts( params ) ) |
| { |
| throw new TestSetFailedException( "Unspecified thread-count(s). " |
| + "See the parameters " |
| + JUnitCoreParameters.USEUNLIMITEDTHREADS_KEY + ", " |
| + JUnitCoreParameters.THREADCOUNT_KEY + ", " |
| + JUnitCoreParameters.THREADCOUNTSUITES_KEY + ", " |
| + JUnitCoreParameters.THREADCOUNTCLASSES_KEY + ", " |
| + JUnitCoreParameters.THREADCOUNTMETHODS_KEY + "." ); |
| } |
| |
| if ( params.isUseUnlimitedThreads() ) |
| { |
| return concurrencyForUnlimitedThreads( params ); |
| } |
| else if ( hasThreadCount( params ) ) |
| { |
| if ( hasThreadCounts( params ) ) |
| { |
| return isLeafUnspecified( params ) |
| ? concurrencyFromAllThreadCountsButUnspecifiedLeafCount( params, counts ) |
| : concurrencyFromAllThreadCounts( params ); |
| } |
| else |
| { |
| return estimateConcurrency( params, counts ); |
| } |
| } |
| else |
| { |
| return concurrencyFromThreadCounts( params ); |
| } |
| } |
| |
| static boolean isUnusedDescription( Description examined ) |
| { |
| if ( UNUSED_DESCRIPTIONS.contains( examined ) ) |
| { |
| return true; |
| } |
| else |
| { |
| // UNUSED_DESCRIPTIONS ensures that "examined" cannot be null |
| for ( Description unused : UNUSED_DESCRIPTIONS ) |
| { |
| if ( unused != null && unused.getDisplayName().equals( examined.getDisplayName() ) ) |
| { |
| return true; |
| } |
| } |
| return false; |
| } |
| } |
| |
| static void removeUnusedDescriptions( Collection<Description> examined ) |
| { |
| for ( Iterator<Description> it = examined.iterator(); it.hasNext(); ) |
| { |
| if ( isUnusedDescription( it.next() ) ) |
| { |
| it.remove(); |
| } |
| } |
| } |
| |
| private static Concurrency concurrencyForUnlimitedThreads( JUnitCoreParameters params ) |
| { |
| Concurrency concurrency = new Concurrency(); |
| concurrency.suites = params.isParallelSuites() ? threadCountSuites( params ) : 0; |
| concurrency.classes = params.isParallelClasses() ? threadCountClasses( params ) : 0; |
| concurrency.methods = params.isParallelMethods() ? threadCountMethods( params ) : 0; |
| concurrency.capacity = Integer.MAX_VALUE; |
| return concurrency; |
| } |
| |
| private static Concurrency estimateConcurrency( JUnitCoreParameters params, RunnerCounter counts ) |
| { |
| final Concurrency concurrency = new Concurrency(); |
| final int parallelEntities = countParallelEntities( params ); |
| concurrency.capacity = multiplyByCoreCount( params, params.getThreadCount() ); |
| if ( parallelEntities == 1 || counts == null || counts.classes == 0 ) |
| { |
| // Estimate parallel thread counts. |
| double ratio = 1d / parallelEntities; |
| int threads = multiplyByCoreCount( params, ratio * params.getThreadCount() ); |
| concurrency.suites = params.isParallelSuites() ? minSuites( threads, counts ) : 0; |
| concurrency.classes = params.isParallelClasses() ? minClasses( threads, counts ) : 0; |
| concurrency.methods = params.isParallelMethods() ? minMethods( threads, counts ) : 0; |
| if ( parallelEntities == 1 ) |
| { |
| concurrency.capacity = 0; |
| } |
| else |
| { |
| adjustLeaf( params, concurrency ); |
| } |
| } |
| else |
| { |
| // Try to allocate suites+classes+methods within threadCount, |
| concurrency.suites = params.isParallelSuites() ? toNonNegative( counts.suites ) : 0; |
| concurrency.classes = params.isParallelClasses() ? toNonNegative( counts.classes ) : 0; |
| concurrency.methods = |
| params.isParallelMethods() ? toNonNegative( Math.ceil( counts.methods / (double) counts.classes ) ) : 0; |
| double sum = toNonNegative( concurrency.suites + concurrency.classes + concurrency.methods ); |
| if ( concurrency.capacity < sum && sum != 0 ) |
| { |
| // otherwise allocate them using the weighting factor < 1. |
| double weight = concurrency.capacity / sum; |
| concurrency.suites *= weight; |
| concurrency.classes *= weight; |
| concurrency.methods *= weight; |
| } |
| adjustLeaf( params, concurrency ); |
| } |
| return concurrency; |
| } |
| |
| private static Concurrency concurrencyFromAllThreadCountsButUnspecifiedLeafCount( JUnitCoreParameters params, |
| RunnerCounter counts ) |
| { |
| Concurrency concurrency = new Concurrency(); |
| concurrency.suites = params.isParallelSuites() ? params.getThreadCountSuites() : 0; |
| concurrency.suites = params.isParallelSuites() ? multiplyByCoreCount( params, concurrency.suites ) : 0; |
| concurrency.classes = params.isParallelClasses() ? params.getThreadCountClasses() : 0; |
| concurrency.classes = params.isParallelClasses() ? multiplyByCoreCount( params, concurrency.classes ) : 0; |
| concurrency.methods = params.isParallelMethods() ? params.getThreadCountMethods() : 0; |
| concurrency.methods = params.isParallelMethods() ? multiplyByCoreCount( params, concurrency.methods ) : 0; |
| concurrency.capacity = multiplyByCoreCount( params, params.getThreadCount() ); |
| |
| if ( counts != null ) |
| { |
| concurrency.suites = toNonNegative( Math.min( concurrency.suites, counts.suites ) ); |
| concurrency.classes = toNonNegative( Math.min( concurrency.classes, counts.classes ) ); |
| } |
| |
| setLeafInfinite( params, concurrency ); |
| |
| return concurrency; |
| } |
| |
| private static Concurrency concurrencyFromAllThreadCounts( JUnitCoreParameters params ) |
| { |
| Concurrency concurrency = new Concurrency(); |
| concurrency.suites = params.isParallelSuites() ? params.getThreadCountSuites() : 0; |
| concurrency.classes = params.isParallelClasses() ? params.getThreadCountClasses() : 0; |
| concurrency.methods = params.isParallelMethods() ? params.getThreadCountMethods() : 0; |
| concurrency.capacity = params.getThreadCount(); |
| double all = sumThreadCounts( concurrency ); |
| |
| concurrency.suites = params.isParallelSuites() ? multiplyByCoreCount( params, concurrency.capacity * ( |
| concurrency.suites / all ) ) : 0; |
| |
| concurrency.classes = params.isParallelClasses() ? multiplyByCoreCount( params, concurrency.capacity * ( |
| concurrency.classes / all ) ) : 0; |
| |
| concurrency.methods = params.isParallelMethods() ? multiplyByCoreCount( params, concurrency.capacity * ( |
| concurrency.methods / all ) ) : 0; |
| |
| concurrency.capacity = multiplyByCoreCount( params, concurrency.capacity ); |
| adjustPrecisionInLeaf( params, concurrency ); |
| return concurrency; |
| } |
| |
| private static Concurrency concurrencyFromThreadCounts( JUnitCoreParameters params ) |
| { |
| Concurrency concurrency = new Concurrency(); |
| concurrency.suites = params.isParallelSuites() ? threadCountSuites( params ) : 0; |
| concurrency.classes = params.isParallelClasses() ? threadCountClasses( params ) : 0; |
| concurrency.methods = params.isParallelMethods() ? threadCountMethods( params ) : 0; |
| concurrency.capacity = toNonNegative( sumThreadCounts( concurrency ) ); |
| return concurrency; |
| } |
| |
| private static int countParallelEntities( JUnitCoreParameters params ) |
| { |
| int count = 0; |
| if ( params.isParallelSuites() ) |
| { |
| count++; |
| } |
| |
| if ( params.isParallelClasses() ) |
| { |
| count++; |
| } |
| |
| if ( params.isParallelMethods() ) |
| { |
| count++; |
| } |
| return count; |
| } |
| |
| private static void adjustPrecisionInLeaf( JUnitCoreParameters params, Concurrency concurrency ) |
| { |
| if ( params.isParallelMethods() ) |
| { |
| concurrency.methods = concurrency.capacity - concurrency.suites - concurrency.classes; |
| } |
| else if ( params.isParallelClasses() ) |
| { |
| concurrency.classes = concurrency.capacity - concurrency.suites; |
| } |
| } |
| |
| private static void adjustLeaf( JUnitCoreParameters params, Concurrency concurrency ) |
| { |
| if ( params.isParallelMethods() ) |
| { |
| concurrency.methods = Integer.MAX_VALUE; |
| } |
| else if ( params.isParallelClasses() ) |
| { |
| concurrency.classes = Integer.MAX_VALUE; |
| } |
| } |
| |
| private static void setLeafInfinite( JUnitCoreParameters params, Concurrency concurrency ) |
| { |
| if ( params.isParallelMethods() ) |
| { |
| concurrency.methods = Integer.MAX_VALUE; |
| } |
| else if ( params.isParallelClasses() ) |
| { |
| concurrency.classes = Integer.MAX_VALUE; |
| } |
| else if ( params.isParallelSuites() ) |
| { |
| concurrency.suites = Integer.MAX_VALUE; |
| } |
| } |
| |
| private static boolean isLeafUnspecified( JUnitCoreParameters params ) |
| { |
| int maskOfParallel = params.isParallelSuites() ? 4 : 0; |
| maskOfParallel |= params.isParallelClasses() ? 2 : 0; |
| maskOfParallel |= params.isParallelMethods() ? 1 : 0; |
| |
| int maskOfConcurrency = params.getThreadCountSuites() > 0 ? 4 : 0; |
| maskOfConcurrency |= params.getThreadCountClasses() > 0 ? 2 : 0; |
| maskOfConcurrency |= params.getThreadCountMethods() > 0 ? 1 : 0; |
| |
| maskOfConcurrency &= maskOfParallel; |
| |
| int leaf = Integer.lowestOneBit( maskOfParallel ); |
| return maskOfConcurrency == maskOfParallel - leaf; |
| } |
| |
| private static double sumThreadCounts( Concurrency concurrency ) |
| { |
| double sum = concurrency.suites; |
| sum += concurrency.classes; |
| sum += concurrency.methods; |
| return sum; |
| } |
| |
| private static boolean hasThreadCounts( JUnitCoreParameters jUnitCoreParameters ) |
| { |
| return ( jUnitCoreParameters.isParallelSuites() && jUnitCoreParameters.getThreadCountSuites() > 0 ) |
| || ( jUnitCoreParameters.isParallelClasses() && jUnitCoreParameters.getThreadCountClasses() > 0 ) |
| || ( jUnitCoreParameters.isParallelMethods() && jUnitCoreParameters.getThreadCountMethods() > 0 ); |
| } |
| |
| private static boolean hasThreadCount( JUnitCoreParameters jUnitCoreParameters ) |
| { |
| return jUnitCoreParameters.getThreadCount() > 0; |
| } |
| |
| private static int threadCountMethods( JUnitCoreParameters jUnitCoreParameters ) |
| { |
| return multiplyByCoreCount( jUnitCoreParameters, jUnitCoreParameters.getThreadCountMethods() ); |
| } |
| |
| private static int threadCountClasses( JUnitCoreParameters jUnitCoreParameters ) |
| { |
| return multiplyByCoreCount( jUnitCoreParameters, jUnitCoreParameters.getThreadCountClasses() ); |
| } |
| |
| private static int threadCountSuites( JUnitCoreParameters jUnitCoreParameters ) |
| { |
| return multiplyByCoreCount( jUnitCoreParameters, jUnitCoreParameters.getThreadCountSuites() ); |
| } |
| |
| private static int multiplyByCoreCount( JUnitCoreParameters jUnitCoreParameters, double threadsPerCore ) |
| { |
| double numberOfThreads = |
| jUnitCoreParameters.isPerCoreThreadCount() ? threadsPerCore * (double) availableProcessors : threadsPerCore; |
| |
| return numberOfThreads > 0 ? toNonNegative( numberOfThreads ) : Integer.MAX_VALUE; |
| } |
| |
| private static int minSuites( int threads, RunnerCounter counts ) |
| { |
| long count = counts == null ? Integer.MAX_VALUE : counts.suites; |
| return Math.min( threads, toNonNegative( count ) ); |
| } |
| |
| private static int minClasses( int threads, RunnerCounter counts ) |
| { |
| long count = counts == null ? Integer.MAX_VALUE : counts.classes; |
| return Math.min( threads, toNonNegative( count ) ); |
| } |
| |
| private static int minMethods( int threads, RunnerCounter counts ) |
| { |
| long count = counts == null ? Integer.MAX_VALUE : counts.methods; |
| return Math.min( threads, toNonNegative( count ) ); |
| } |
| |
| private static int toNonNegative( long num ) |
| { |
| return (int) Math.min( num > 0 ? num : 0, Integer.MAX_VALUE ); |
| } |
| |
| private static int toNonNegative( double num ) |
| { |
| return (int) Math.min( num > 0 ? num : 0, Integer.MAX_VALUE ); |
| } |
| } |
