Examples with Timer org.gradle.internal.time.Timer used on opensource projects

Example 16 with Timer

use of org.gradle.internal.time.Timer in project gradle by gradle.

the class SelectiveCompiler method execute.

@Override
public WorkResult execute(JavaCompileSpec spec) {
    Timer clock = Time.startTimer();
    CurrentCompilation currentCompilation = new CurrentCompilation(inputs, spec, jarClasspathSnapshotProvider);
    RecompilationSpec recompilationSpec = recompilationSpecProvider.provideRecompilationSpec(currentCompilation, previousCompilation);
    if (recompilationSpec.isFullRebuildNeeded()) {
        LOG.info("Full recompilation is required because {}. Analysis took {}.", recompilationSpec.getFullRebuildCause(), clock.getElapsed());
        return cleaningCompiler.execute(spec);
    }
    incrementalCompilationInitilizer.initializeCompilation(spec, recompilationSpec);
    if (spec.getSource().isEmpty() && spec.getClasses().isEmpty()) {
        LOG.info("None of the classes needs to be compiled! Analysis took {}. ", clock.getElapsed());
        return new RecompilationNotNecessary();
    }
    try {
        return cleaningCompiler.getCompiler().execute(spec);
    } finally {
        Collection<String> classesToCompile = recompilationSpec.getClassesToCompile();
        LOG.info("Incremental compilation of {} classes completed in {}.", classesToCompile.size(), clock.getElapsed());
        LOG.debug("Recompiled classes {}", classesToCompile);
    }
}

Example 17 with Timer

use of org.gradle.internal.time.Timer in project gradle by gradle.

the class JarClasspathSnapshotMaker method maybeInitialize.

private void maybeInitialize(Iterable<File> classpath) {
    if (jarClasspathSnapshot != null) {
        return;
    }
    Timer clock = Time.startTimer();
    Iterable<JarArchive> jarArchives = classpathJarFinder.findJarArchives(classpath);
    jarClasspathSnapshot = classpathSnapshotFactory.createSnapshot(jarArchives);
    int duplicatesCount = jarClasspathSnapshot.getData().getDuplicateClasses().size();
    String duplicateClassesMessage = duplicatesCount == 0 ? "" : ". " + duplicatesCount + " duplicate classes found in classpath (see all with --debug)";
    LOG.info("Created jar classpath snapshot for incremental compilation in {}{}.", clock.getElapsed(), duplicateClassesMessage);
    LOG.debug("While calculating jar classpath snapshot {} duplicate classes were found: {}.", duplicatesCount, jarClasspathSnapshot.getData().getDuplicateClasses());
}

Example 18 with Timer

use of org.gradle.internal.time.Timer in project gradle by gradle.

the class Binary2JUnitXmlReportGenerator method generate.

public void generate() {
    Timer clock = Time.startTimer();
    buildOperationExecutor.run(new RunnableBuildOperation() {

        @Override
        public void run(BuildOperationContext context) {
            File[] oldXmlFiles = testResultsDir.listFiles(new FilenameFilter() {

                @Override
                public boolean accept(File dir, String name) {
                    return name.startsWith("TEST") && name.endsWith(".xml");
                }
            });
            for (File oldXmlFile : oldXmlFiles) {
                GFileUtils.deleteQuietly(oldXmlFile);
            }
        }

        @Override
        public BuildOperationDescriptor.Builder description() {
            return BuildOperationDescriptor.displayName("Delete old JUnit XML results");
        }
    });
    buildOperationExecutor.runAll(new Action<BuildOperationQueue<JUnitXmlReportFileGenerator>>() {

        @Override
        public void execute(final BuildOperationQueue<JUnitXmlReportFileGenerator> queue) {
            testResultsProvider.visitClasses(new Action<TestClassResult>() {

                public void execute(final TestClassResult result) {
                    final File reportFile = new File(testResultsDir, getReportFileName(result));
                    queue.add(new JUnitXmlReportFileGenerator(result, reportFile, xmlWriter));
                }
            });
        }
    });
    LOG.info("Finished generating test XML results ({}) into: {}", clock.getElapsed(), testResultsDir);
}

Example 19 with Timer

use of org.gradle.internal.time.Timer in project gradle by gradle.

the class WorkerDaemonStarter method startDaemon.

public <T extends WorkSpec> WorkerDaemonClient startDaemon(Class<? extends WorkerProtocol<ActionExecutionSpec>> workerProtocolImplementationClass, DaemonForkOptions forkOptions) {
    LOG.debug("Starting Gradle worker daemon with fork options {}.", forkOptions);
    Timer clock = Time.startTimer();
    MultiRequestWorkerProcessBuilder<WorkerDaemonProcess> builder = workerDaemonProcessFactory.multiRequestWorker(WorkerDaemonProcess.class, WorkerProtocol.class, workerProtocolImplementationClass);
    builder.setBaseName("Gradle Worker Daemon");
    // NOTE: might make sense to respect per-compile-task log level
    builder.setLogLevel(loggingManager.getLevel());
    builder.applicationClasspath(forkOptions.getClasspath());
    builder.sharedPackages(forkOptions.getSharedPackages());
    JavaExecHandleBuilder javaCommand = builder.getJavaCommand();
    forkOptions.getJavaForkOptions().copyTo(javaCommand);
    WorkerDaemonProcess workerDaemonProcess = builder.build();
    WorkerProcess workerProcess = workerDaemonProcess.start();
    WorkerDaemonClient client = new WorkerDaemonClient(forkOptions, workerDaemonProcess, workerProcess, loggingManager.getLevel());
    LOG.info("Started Gradle worker daemon ({}) with fork options {}.", clock.getElapsed(), forkOptions);
    return client;
}

Example 20 with Timer

use of org.gradle.internal.time.Timer in project gradle by gradle.

the class ZincScalaCompilerFactory method getCompilerInterface.

// parallel safe version of Compiler.compilerInterface()
private static File getCompilerInterface(final Setup setup, final ScalaInstance instance, PersistentCache zincCache, final xsbti.Logger logger) {
    final String sbtInterfaceFileName = Compiler.interfaceId(instance.actualVersion()) + ".jar";
    final File compilerInterface = new File(setup.cacheDir(), sbtInterfaceFileName);
    if (compilerInterface.exists()) {
        return zincCache.useCache(new Factory<File>() {

            @Override
            public File create() {
                return compilerInterface;
            }
        });
    }
    try {
        // Compile the interface to a temp file and then copy it to the cache folder.
        // This avoids sporadic cache lock timeouts when the compiler interface JAR takes
        // a long time to generate while avoiding starving multiple compiler daemons.
        final File tmpDir = new File(zincCache.getBaseDir(), "tmp");
        tmpDir.mkdirs();
        final File tempFile = File.createTempFile("zinc", ".jar", tmpDir);
        final Timer timer = Time.startTimer();
        sbt.compiler.IC.compileInterfaceJar(sbtInterfaceFileName, setup.compilerInterfaceSrc(), tempFile, setup.sbtInterface(), instance, logger);
        final String interfaceCompletedMessage = String.format("Zinc interface compilation took %s", timer.getElapsed());
        if (timer.getElapsedMillis() > 30000) {
            LOGGER.warn(interfaceCompletedMessage);
        } else {
            LOGGER.debug(interfaceCompletedMessage);
        }
        return zincCache.useCache(new Factory<File>() {

            public File create() {
                // Avoid copying over same existing file to avoid locking problems
                if (!compilerInterface.exists()) {
                    GFileUtils.moveFile(tempFile, compilerInterface);
                } else {
                    GFileUtils.deleteQuietly(tempFile);
                }
                return compilerInterface;
            }
        });
    } catch (IOException e) {
        // fall back to the default logic
        return zincCache.useCache(new Factory<File>() {

            public File create() {
                return Compiler.compilerInterface(setup, instance, logger);
            }
        });
    }
}