Java Profiler.start方法代码示例

import edu.umd.cs.findbugs.log.Profiler; //导入方法依赖的package包/类
/**
 * Analyze a method.
 *
 * @param classContext
 *            ClassContext storing method analysis objects for method's
 *            class
 * @param analysisClass
 *            class the method analysis object should belong to
 * @param methodDescriptor
 *            method descriptor identifying the method to analyze
 * @return the computed analysis object for the method
 * @throws CheckedAnalysisException
 */
@SuppressWarnings("unchecked")
private <E> E analyzeMethod(ClassContext classContext, Class<E> analysisClass, MethodDescriptor methodDescriptor)
        throws CheckedAnalysisException {
    IMethodAnalysisEngine<E> engine = (IMethodAnalysisEngine<E>) methodAnalysisEngineMap.get(analysisClass);
    if (engine == null) {
        throw new IllegalArgumentException("No analysis engine registered to produce " + analysisClass.getName());
    }
    Profiler profiler = getProfiler();
    profiler.start(engine.getClass());
    try {
        return engine.analyze(this, methodDescriptor);
    } finally {
        profiler.end(engine.getClass());
    }
}
 

import edu.umd.cs.findbugs.log.Profiler; //导入方法依赖的package包/类
public When validate(Object constantValue) {
    if (validator == null)
        throw new IllegalStateException("No validator");
    IAnalysisCache analysisCache = Global.getAnalysisCache();
    Profiler profiler = analysisCache.getProfiler();
    profiler.start(validator.getClass());
    AtomicBoolean performing = performingValidation.get();
    try {
        if (!performing.compareAndSet(false, true)) {
            throw new IllegalStateException("recursive validation");
        }

        return validator.forConstantValue(proxy, constantValue);
    } catch (Exception e) {
        AnalysisContext.logError("Error executing custom validator for " + typeQualifier + " " + constantValue, e);
        return When.UNKNOWN;
    } finally {
        if (!performing.compareAndSet(true, false)) {
            throw new IllegalStateException("performingValidation not set when validation completes");
        }
        profiler.end(validator.getClass());

    }
}
 

import edu.umd.cs.findbugs.log.Profiler; //导入方法依赖的package包/类
public void analyzeMethod(ClassContext classContext, Method method, ResourceTrackerType resourceTracker,
        ResourceCollection<Resource> resourceCollection) throws CFGBuilderException, DataflowAnalysisException {

    MethodGen methodGen = classContext.getMethodGen(method);
    if (methodGen == null)
        return;
    try {
        CFG cfg = classContext.getCFG(method);
        DepthFirstSearch dfs = classContext.getDepthFirstSearch(method);

        if (DEBUG)
            System.out.println(SignatureConverter.convertMethodSignature(methodGen));

        for (Iterator<Resource> i = resourceCollection.resourceIterator(); i.hasNext();) {
            Resource resource = i.next();

            ResourceValueAnalysis<Resource> analysis = new ResourceValueAnalysis<Resource>(methodGen, cfg, dfs,
                    resourceTracker, resource);
            Dataflow<ResourceValueFrame, ResourceValueAnalysis<Resource>> dataflow = new Dataflow<ResourceValueFrame, ResourceValueAnalysis<Resource>>(
                    cfg, analysis);

            Profiler profiler = Global.getAnalysisCache().getProfiler();
            profiler.start(resourceTracker.getClass());
            try {
                dataflow.execute();
            } finally {
                profiler.end(resourceTracker.getClass());
            }
            inspectResult(classContext, methodGen, cfg, dataflow, resource);
        }
    } catch (RuntimeException e) {
        AnalysisContext.logError("Exception while analyzing " + methodGen.getClassName() + "." + methodGen.getName() + ":"
                + methodGen.getSignature(), e);
    }
}
 

import edu.umd.cs.findbugs.log.Profiler; //导入方法依赖的package包/类
public ObligationDataflow analyze(IAnalysisCache analysisCache, MethodDescriptor methodDescriptor)
        throws CheckedAnalysisException {
    CFG cfg = analysisCache.getMethodAnalysis(CFG.class, methodDescriptor);
    DepthFirstSearch dfs = analysisCache.getMethodAnalysis(DepthFirstSearch.class, methodDescriptor);
    XMethod xmethod = XFactory.createXMethod(methodDescriptor);
    ConstantPoolGen cpg = analysisCache.getClassAnalysis(ConstantPoolGen.class, methodDescriptor.getClassDescriptor());

    ObligationPolicyDatabase database = analysisCache.getDatabase(ObligationPolicyDatabase.class);

    TypeDataflow typeDataflow = analysisCache.getMethodAnalysis(TypeDataflow.class, methodDescriptor);
    IsNullValueDataflow invDataflow = analysisCache.getMethodAnalysis(IsNullValueDataflow.class, methodDescriptor);

    ObligationFactory factory = database.getFactory();

    ObligationAnalysis analysis = new ObligationAnalysis(dfs, xmethod, cpg, factory, database, typeDataflow, invDataflow,
            analysisCache.getErrorLogger());
    ObligationDataflow dataflow = new ObligationDataflow(cfg, analysis);

    Profiler profiler = analysisCache.getProfiler();
    profiler.start(analysis.getClass());
    try {
        dataflow.execute();
    } finally {
        profiler.end(analysis.getClass());
    }

    if (DEBUG_PRINTCFG) {
        System.out.println("Dataflow CFG:");
        DataflowCFGPrinter.printCFG(dataflow, System.out);
    }

    return dataflow;
}
 

import edu.umd.cs.findbugs.log.Profiler; //导入方法依赖的package包/类
public static AbstractScannableCodeBase makeZipCodeBase(ICodeBaseLocator codeBaseLocator, File file) throws IOException {
    Profiler profiler = Global.getAnalysisCache().getProfiler();
    profiler.start(ZipCodeBaseFactory.class);
    try {
        return countUsingZipFile(codeBaseLocator, file);
    } finally {
        profiler.end(ZipCodeBaseFactory.class);
    }
}
 

import edu.umd.cs.findbugs.log.Profiler; //导入方法依赖的package包/类
public void visitClass(ClassDescriptor classDescriptor) throws CheckedAnalysisException {

        // Just get the ClassContext from the analysis cache
        // and apply the detector to it.

        IAnalysisCache analysisCache = Global.getAnalysisCache();
        ClassContext classContext = analysisCache.getClassAnalysis(ClassContext.class, classDescriptor);
        Profiler profiler = analysisCache.getProfiler();
        profiler.start(detector.getClass());
        try {
            detector.visitClassContext(classContext);
        } finally {
            profiler.end(detector.getClass());
        }
    }
 

import edu.umd.cs.findbugs.log.Profiler; //导入方法依赖的package包/类
public NullnessAnnotation getResolvedAnnotation(Object o, boolean getMinimal) {
    Profiler profiler = Global.getAnalysisCache().getProfiler();
    profiler.start(this.getClass());
    try {

        if (DEBUG) {
            System.out.println("getResolvedAnnotation: o=" + o + "...");
        }

        TypeQualifierAnnotation tqa = null;

        if (o instanceof XMethodParameter) {
            XMethodParameter param = (XMethodParameter) o;

            tqa = TypeQualifierApplications.getEffectiveTypeQualifierAnnotation(param.getMethod(),
                    param.getParameterNumber(), nonnullTypeQualifierValue);
        } else if (o instanceof XMethod || o instanceof XField) {
            tqa = TypeQualifierApplications.getEffectiveTypeQualifierAnnotation((AnnotatedObject) o,
                    nonnullTypeQualifierValue);
        }

        NullnessAnnotation result = toNullnessAnnotation(tqa);
        if (DEBUG) {
            if (result == null)
                System.out.println("   ===> not found");
            else
                System.out.println("   ===> " + tqa + "/" + result.toString() );
        }
        return result;
    } finally {
        profiler.end(this.getClass());
    }
}
 

import edu.umd.cs.findbugs.log.Profiler; //导入方法依赖的package包/类
public static <E> List<E> sortByCallGraph(Collection<E> elements, OutEdges<E> outEdges) {
    Profiler profile = Global.getAnalysisCache().getProfiler();
    profile.start(TopologicalSort.class);
    try {
        SortAlgorithm<E> instance = new Worker2<E>(elements, outEdges);
        return instance.compute();
    } finally {
        profile.end(TopologicalSort.class);
    }
}
 

import edu.umd.cs.findbugs.log.Profiler; //导入方法依赖的package包/类
public static AbstractScannableCodeBase makeZipCodeBase(ICodeBaseLocator codeBaseLocator, File file) throws IOException {
    Profiler profiler = Global.getAnalysisCache().getProfiler();
    profiler.start(ZipCodeBaseFactory.class);
    try {
        return new ZipFileCodeBase(codeBaseLocator, file);
    } catch (ZipException e) {
       // May be too many zip entries
       return new ZipInputStreamCodeBase(codeBaseLocator, file);
    } finally {
        profiler.end(ZipCodeBaseFactory.class);
    }
}
 

import edu.umd.cs.findbugs.log.Profiler; //导入方法依赖的package包/类
public When validate(@CheckForNull Object constantValue) {
    if (validator == null)
        throw new IllegalStateException("No validator");
    IAnalysisCache analysisCache = Global.getAnalysisCache();
    Profiler profiler = analysisCache.getProfiler();
    profiler.start(validator.getClass());
    try {
        return ValidationSecurityManager.sandboxedValidation(proxy, validator, constantValue);
    } catch (Exception e) {
        AnalysisContext.logError("Error executing custom validator for " + typeQualifier + " " + constantValue, e);
        return When.UNKNOWN;
    } finally {
        profiler.end(validator.getClass());
    }
}
 

import edu.umd.cs.findbugs.log.Profiler; //导入方法依赖的package包/类
public @CheckForNull NullnessAnnotation getInheritedAnnotation(XMethod m, int parameter) {
    Profiler profiler = Global.getAnalysisCache().getProfiler();
    profiler.start(this.getClass());
    try {
        TypeQualifierAnnotation tqa
        = TypeQualifierApplications.getInheritedTypeQualifierAnnotation(m,
               parameter, nonnullTypeQualifierValue);
        NullnessAnnotation result = toNullnessAnnotation(tqa);
        return result;
    } finally {
        profiler.end(this.getClass());
    }
}
 

import edu.umd.cs.findbugs.log.Profiler; //导入方法依赖的package包/类
public @CheckForNull NullnessAnnotation getDirectAnnotation(Object o) {
    Profiler profiler = Global.getAnalysisCache().getProfiler();
    profiler.start(this.getClass());
    try {

        if (DEBUG) {
            System.out.println("getDirectAnnotation: o=" + o + "...");
        }

        TypeQualifierAnnotation tqa = null;

        if (o instanceof XMethodParameter) {
            XMethodParameter param = (XMethodParameter) o;
            tqa = TypeQualifierApplications.getDirectTypeQualifierAnnotation(param.getMethod(),
                    param.getParameterNumber(), nonnullTypeQualifierValue);
        } else if (o instanceof XMethod || o instanceof XField) {
            tqa = TypeQualifierApplications.getEffectiveTypeQualifierAnnotation((AnnotatedObject) o,
                    nonnullTypeQualifierValue);
        }

        NullnessAnnotation result = toNullnessAnnotation(tqa);
        if (DEBUG) {
            if (result == null)
                System.out.println("   ===> not found");
            else
                System.out.println("   ===> " + tqa + "/" + result.toString() );
        }
        return result;
    } finally {
        profiler.end(this.getClass());
    }
}