PerformanceProfiler (ImageJ2 Javadocs 0-SNAPSHOT API)

java.lang.Object
- net.imagej.patcher.PerformanceProfiler

All Implemented Interfaces:

javassist.Translator
```
public class PerformanceProfiler
extends Object
implements javassist.Translator
```
A Javassist-backed performance profiler.
This class implements an easy-to-use, relatively light-weight performance profiler that does not need operating system support or special start-up parameters to the Java Virtual Machine.
Use it in one of the following ways:
- insert the following line at the start of the main() method calling the code to profile:
  if (PerformanceProfiler.startProfiling(args)) return;
  Subsequently, you can start/stop profiling by calling setActive(boolean), print a report using report(PrintStream), or print a report to a file with report(File, int).
  
  Printing a report will reset the counters and stop profiling. If you want to make sure the counters are reset and profiling is stopped, but not to print anything, just call PerformanceProfiler.report(null);.
- Call PerformanceProfiler as main class, passing as parameter the name of the main class to profile and optionally any parameters you want to pass to that main class.
The idea behind the profiler is that a Javassist-specific class Loader with a Translator is used to load the main class and all its dependent classes. The translator instruments every method such that a method-specific counter is incremented, and the total time spent in the method is recorded, too. A list of instrumented methods with their counters is maintained globally.

To record the time spent in a method, either the getNanos() method (thread-specific, but unfortunately very, very slow) or the getNanosQnD() (not thread-specific, but does not dominate even small methods' timing) is used. The latter is the default.
Author:

Johannes Schindelin

Field Summary

Fields
Modifier and Type Field and Description

protected static boolean debug

protected static Method realReport

Fields
Modifier and Type	Field and Description
`protected static boolean`	`debug`
`protected static Method`	`realReport`

Constructor Summary

Constructors
Constructor and Description

PerformanceProfiler()
The constructor.

Constructors
Constructor and Description
`PerformanceProfiler()` The constructor.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static long`	`getNanos()` Gets nanoseconds per thread for relative time measurements
`static long`	`getNanosQnD()` A much faster, but less accurate version of `getNanos()` The problem with this is that it does not measure the current Thread's CPU cycles.
`static boolean`	`isActive()` Reports whether profiling is in progress
`static void`	`main(String... args)` The main method.
`void`	`onLoad(javassist.ClassPool pool, String classname)`
`static void`	`report(File file, int column)` Writes a profile report to a file.
`static void`	`report(PrintStream writer)` Writes a report.
`static void`	`report(PrintStream writer, int column)` Writes a report.
`protected static void`	`reportCaller(PrintStream writer, int level)` Reports a caller.
`static void`	`setActive(boolean active)` Start or stop profiling This method initializes the profiling class loader if necessary.
`void`	`start(javassist.ClassPool pool)`
`static boolean`	`startProfiling(String mainClass, String... args)` Convenience method to call in your main(String[]) method.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - debug
```
protected static final boolean debug
```
    See Also:
    
    Constant Field Values
  - realReport
```
protected static Method realReport
```
- Constructor Detail
  - PerformanceProfiler
```
public PerformanceProfiler()
```
    The constructor. It will look for a white-space-delimited list of classes to profile in the environment variable PERFORMANCE_PROFILE_ONLY.
- Method Detail
  - startProfiling
```
public static boolean startProfiling(String mainClass,
                                     String... args)
                              throws Throwable
```
    Convenience method to call in your main(String[]) method. Use it like this: if (PerformanceProfiler.startProfiling(null, args)) return; It will start the profiling class loader, run the main method of the calling class (which will call startProfiling() again, but that will now return false since it is already profiling) and return true.
    
    Parameters:
    
    mainClass - the main class, or null to refer to the caller's class
    
    args - the arguments for the main method
    
    Returns:
    
    true if profiling was started, false if profiling is already active
    
    Throws:
    
    Throwable
  - main
```
public static void main(String... args)
                 throws Throwable
```
    The main method. Use the class as a main class to start profiling any other main class contained in the class path.
    
    Parameters:
    
    args - the main class to profile, followed by the arguments to pass to the main method
    
    Throws:
    
    Throwable
  - setActive
```
public static void setActive(boolean active)
```
    Start or stop profiling This method initializes the profiling class loader if necessary.
    
    Parameters:
    
    active -
  - isActive
```
public static boolean isActive()
```
    Reports whether profiling is in progress
    
    Returns:
    
    whether we're profilin'
  - report
```
public static void report(File file,
                          int column)
                   throws FileNotFoundException
```
    Writes a profile report to a file. This method simply calls report(PrintStream, int).
    
    Parameters:
    
    file - where to write to
    
    column - what column to sort by
    
    Throws:
    
    FileNotFoundException
  - report
```
public static void report(PrintStream writer)
```
    Writes a report. The methods are sorted by the total time spent in them or the methods they called.
    
    Parameters:
    
    writer - where to write to.
  - report
```
public static void report(PrintStream writer,
                          int column)
```
    Writes a report. The methods can be sorted by:
    - the name (column == 0)
    - the number they were called (column == 1)
    - the average time in nanoseconds (column == 2)
    - the total time in nanoseconds (column = 3)
    Parameters:
    
    writer - where to write to.
  - getNanos
```
public static final long getNanos()
```
    Gets nanoseconds per thread for relative time measurements
    
    Returns:
    
    nanocseconds
  - getNanosQnD
```
public static final long getNanosQnD()
```
    A much faster, but less accurate version of getNanos() The problem with this is that it does not measure the current Thread's CPU cycles.
    
    Returns:
    
    nanoseconds for relative time measurements
  - start
```
public void start(javassist.ClassPool pool)
           throws javassist.NotFoundException,
                  javassist.CannotCompileException
```
    Specified by:
    
    start in interface javassist.Translator
    
    Throws:
    
    javassist.NotFoundException
    
    javassist.CannotCompileException
  - onLoad
```
public void onLoad(javassist.ClassPool pool,
                   String classname)
            throws javassist.NotFoundException
```
    Specified by:
    
    onLoad in interface javassist.Translator
    
    Throws:
    
    javassist.NotFoundException
  - reportCaller
```
protected static void reportCaller(PrintStream writer,
                                   int level)
```
    Reports a caller.
    
    Parameters:
    
    writer - where to write to
    
    level - how many levels to go back in the stack trace

Class PerformanceProfiler

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

debug

realReport

Constructor Detail

PerformanceProfiler

Method Detail

startProfiling

main

setActive

isActive

report

report

report

getNanos

getNanosQnD

start

onLoad

reportCaller