Worked example: Profiling performance of an algorithm - ANTS Performance Profiler

This worked example shows how you can use ANTS Performance Profiler to identify the most time-critical parts of a demonstration application, particularly where two different approaches to a problem are optimal in different circumstances.

Note that the demonstration application used in this worked example is supplied with ANTS Performance Profiler 6.3 and later. If you have an earlier version of ANTS Performance Profiler, either upgrade to version 6.3, or see the Mandelbrot worked example for version 6.2.

Introducing TimeLineDemo

This worked example uses TimeLineDemo.

TimeLineDemo is a simple Windows application that checks which of a set of numbers are prime.

There are two different versions of TimeLineDemo:

In Brute Force configuration, a brute-force method is used to check whether the number is prime.
The Brute Force build of TimeLineDemo is found in %Program Files%\Red Gate\ANTS Performance Profiler 7\Tutorials\CS\Precompiled\TimeLine\BruteForce\
In Miller-Rabin configuration, the Miller-Rabin algorithm is used to check whether the number is prime.
The Miller-Rabin build of TimeLineDemo is found in %Program Files%\Red Gate\ANTS Performance Profiler 7\Tutorials\CS\Precompiled\TimeLine\MillerRabin\

The application has two options:

Max Random
Sample Size

When TimeLineDemo first starts, it creates a list of as many prime numbers as possible in 15 seconds.

When you click Go, TimeLineDemo creates a list of positive integers, which is Sample Size items long. All of the integers are random numbers between 1 and Max Random. For each integer in the list, TimeLineDemo checks whether the number is prime, using the following algorithm:

If the number is in the list created in the first 15 seconds, it is prime.
If a number in the list created in the first 15 seconds is a factor of the current number, the current number is not prime.
In all other cases, use either a brute-force mechanism or the Miller-Rabin algorithm to check whether the number is prime (depending on the build in use).

Note: Strictly speaking, the Miller-Rabin algorithm is probabilistic. For the purposes of this demonstration, however, the algorithm can be assumed to be deterministic. This is because the algorithm's results are exact for integers which are smaller than the largest integer that the field accepts.

Walkthrough

Start ANTS Performance Profiler
Select .NET executable
Enter the path to the brute-force build of TimeLineDemo.exe
Click Start Profiling
If required by your configuration, grant elevation permission
The demo application starts and goes through initial (start-up) phase
The application is shown and processor use decreases
Click the ANTS Performance Profiler logo
Set MaxRandom to 500,000 and SampleSize to 500,000
Click OK
Click Go
The application performs the calculations
To see the expensive calculation methods, drag over that phase in the timeline
In the Call tree, select RedGate.Demo.MainWindow.<GoButtonClick>
The calculations took 1029 milliseconds; that's quick enough
Open the File menu and click New Profiling Session...
Click Start Profiling
When TimeLineDemo has started, click the ANTS Performance Profiler logo
Set MaxRandom to 2000000000 and SampleSize to 5000000
Click OK
Click Go and wait for the calculations to finish
Select the calculation phase in the timeline, then RedGate.Demo.MainWindow.<GoButtonClick>
The calculations took 175,252 milliseconds or nearly 3 minutes. That's too slow.
To see the brute-force method, open TimeLineDemo.csproj in Visual Studio
In APP, right-click ResultSet.Generate() and select Open with (Solution)
If prompted to elevate Visual Studio, click Ignore.
VS shows the expensive line. Right-click the method. Select Go to Declaration.
The Generate() method is displayed
The brute-force method is in use. Try the Miller-Rabin algorithm instead.
To switch to Miller-Rabin, click Debug and select Configuration Manager...
Next to TimeLineDemo, click Debug and select MillerRabin. Rebuild the demo.
In APP, open the File menu and click New Profiling session...
Change the .NET executable to the Miller-Rabin build
Click Start Profiling and wait for the demo to initialize
Click the ANTS Performance Profiler logo
Set MaxRandom to 2000000000 and SampleSize to 5000000
Click Go
Select the calculation phase on the timeline as before
The calculations took 66,149 milliseconds, about 66% faster than brute-force
Is Miller-Rabin always faster than brute-force? Profile TimeLineDemo again.
Set MaxRandom to 500000 and SampleSize to 500000 again
The calculations took 1,545 milliseconds, which is slower than brute-force

Conclusion

This walkthrough has demonstrated a realistic programming scenario. It has compared two methods for testing if a number is prime and shown that Miller-Rabin is more efficient than the brute force approach when the number being tested is large.

app_worked_example_1_results

This walkthrough has also demonstrated that you can select just a portion of the timeline when analyzing results, allowing you to ignore a slow initialization phase, for example.

Learning more

To perform the task demonstrated in this walkthrough more efficiently, you can use the following additional functionality:

To help you identify the section of the timeline to select, you can refer to the Event markers in the Events bar.
You can name and bookmark sections of the timeline.

For more information, see Working with the timeline.

Was this article helpful?

Search support