Jason Crease

Testing the speed of ANTS Profiler 4

Jason Crease — Tue, 16 Sep 2008 19:55:00 GMT

Profiling and debugging code inevitably adds overhead, and I know that it can be really frustrating. The overhead can either be small, e.g. the Visual Studio debugger, or massive, as with most performance profilers. A developer may invest in a performance profiler to optimize an algorithm that takes 10 minutes to run, and finds that when profiled it takes 2 hours to run. A top priority in the development of ANTS Profiler 4 was to make it faster than its predecessor and faster than any other profiler on the market.

We have found ANTS Profiler 4 to be about eight times faster than its predecessor, ANTS Profiler 3. It is also 4 to 20 times faster at line-level profiling than other profilers on the market.

I did a few speed tests and I have made a video to show how ANTS Profiler 4 compares to the fastest-known other profiler:

ANTS Profiler 4 vs fastest known competitor

Here it is compared to ANTS Profiler 3:

ANTS Profiler 4 vs ANTS Profiler 3

If you want to try out ANTS Profiler 4, you can download it from the RedGate website

A Quick .NET Puzzle

Jason Crease — Thu, 17 Jul 2008 23:17:00 GMT

Just a quick .NET puzzle. Does this application ever throw that ApplicationException? If so, why?

using System; using System.Threading; class Program { static long Num = 0; static void Main(string[] args) { Thread t1 = new Thread(ModifyNum); t1.Start(); while (true) { long k = Num; if (k != -1 && k != 0) throw new ApplicationException( "k is not -1 or 0. It is " + k.ToString()); } } static void ModifyNum() { while (true) { if (Num == -1) Num = 0; else Num = -1; } } }

Stuck? Then here's a hint: if you change Num from a long to an int, it never throws the exception.

ANTS Performance Profiler 4 = Sexy Software!?

Jason Crease — Tue, 03 Jun 2008 22:46:00 GMT

I sit next to this guy called Stephen Chambers. He is the Usability Engineer working on our next version of our code profiler, ANTS Performance Profiler 4. He is completely revising the UI of ANTS Profiler, and spends most of his time phoning developers asking what they would like to see in the next version, and then designing the new UI based on the feedback he gets.

Occasionally, you’ll hear some outbursts such as: “It’s getting hotter and hotter round heeere!” If you ask him what he’s on about, he’ll reply in an apologetic tone, “I can’t help it…. It really is very sexy!” That’s when I realise he’s talking about ANTS Performance Profiler 4 (APP 4) and the new design he’s working on. He’s contemplating the slick interface and clean lines of the profiler, summoning passers-by to come and check out “How god damn sexy it looks!”

So, the other day I asked for more detail. What exactly makes Stephen so animated?

1. One-click profiling

He loves the one-click profiling concept. He spent a lot of time working on the opening dialog. No 52-step wizards - just a single screen. The opening dialog is implemented to allow immediate profiling. That way, users will be more inclined to use the tool a lot more frequently, because it’s so quick and easy.

Figure 1: Opening Dialog of ANTS Performance Profiler 4

2. Much greater control for the user

The decision to remove the concept of ‘snapshots’ has produced an entirely new way of interacting with the profiler. Why confine the user to ‘snapshots’ when he could just choose any arbitrary period of time? Simply highlight any period of time (e.g. the creation of a Form), and see profiling results for that period.

Figure 2: Timeline feature in ANTS Performance Profiler 4

With snapshots, you must remember to switch back to the profiler to take a snapshot, reset results, etc. The need to switch from a task to the profiler has now been removed. The user can perform any number of actions they wish and retrospectively analyze the performance of each task in as much depth as they wish.

3. Responsiveness of the interface

Stephen has so far organised over 15 hours of testing sessions with users of the Early Access Program of APP 4. I asked him about their feedback. It seems that participants to the usability sessions have been stunned by the speed at which the results for a given region are processed and displayed. This can equally be done while the profiled application is running or after it has exited.

4. Clear and simple interface

Given the inherent complications of performance profiling, creating a front end that keeps things simple and immediate was a priority for Stephen. The UI went through several iterations and one of the main achievements of the APP 4 development team has been the reduction of options and windows on the main UI. Stephen seems to be getting a satisfying feeling watching a participant in a feedback session of APP 4 install it, set-up a project to be profiled and locate a performance bottleneck within minutes. The power of the profiler is as it should be – hidden under the surface with just the right number of options at the right time to give the user the power to examine the data in any way they feel like.

5. Not throwing the baby out with the bathwater

Talking to existing users of ANTS Profiler 3 revealed a huge amount about not only what features people would like to see in a new version but also what they really liked about the existing version. ANTS Profiler is well-known for its slick line-level timings feature, and some were concerned a new versions may present a ‘change for the worse’. APP 4 represents innovation in many areas, but preserves the features that people found genuinely useful in ANTS Profiler 3. We originally considered dropping the ‘All Methods Grid’, but this decision was quickly reversed upon talking to customers. Instead of a removal or total re-design, a number of subtle tweaks were made to simply freshen up its appearance and extend its usefulness. For example performance bars were added to heighten the visibility of poorly performing methods.

Figure 3: The fresher ‘All Methods’ grid in ANTS Performance Profiler 4

The code view has retained the iconic ANTS Profiler 3 red bars but we have tweaked its functionality by showing the currently selected method.

I find Stephen’s passion for his work impressive. He gets amazing satisfaction from watching users understand the features and options available, and listening to users saying “oh wow, that’s what I call a responsive profiler!” or “very clean interface!” Admittedly, a lot of work went into these things, so I guess, I can understand that…but I can’t help feeling a little uneasy when I see Stephen dancing on his chair, singing “ANTS Performance Profiler, Sexy Software…”!

Order of Construction

Jason Crease — Mon, 02 Jun 2008 21:05:00 GMT

For me, inheritance is often a headache. In particular, in what order is everything initialized? Consider this short C# program. It creates an instance of Dog, which derives from Animal. Both Dog and Animal have an instance constructor, a class initializer (aka a static constructor), an instance variable, and a static variable.

using System;



namespace CtorOrder

{

    class Animal

    {

        public int instanceAnimal = Program.Print("Animal.instanceAnimal");

        public static int staticAnimal = Program.Print("Animal.staticAnimal");

        public Animal()

        {

            Console.WriteLine("Animal constructor");

        }

        static Animal()

        {

            Console.WriteLine("Animal class constructor");

        }

    }

    class Dog : Animal

    {

        public int instanceDog = Program.Print("Dog.instanceDog");

        public static int staticDog = Program.Print("Dog.staticDog");

 

        public Dog()

        {

            Console.WriteLine("Dog constructor");

        }

        static Dog()

        {

            Console.WriteLine("Dog class constructor");

        }

    }

 

    class Program

    {

        public static int Print(string s)

        {

            Console.WriteLine(s);

            return 0;

        }

        static void Main(string[] args)

        {

            Dog d = new Dog();

            Console.WriteLine("\nPress enter to continue");

            Console.ReadLine();

        }

    }

}

There are eight activities here:

Dog instance constructor
Dog class constructor
Dog instance variable
Dog static variable
Animal instance constructor
Animal class constructor
Animal instance variable
Animal static variable

The question is: ‘In what order are the eight activities run?’ Try working it out. Anyway, the answer is:

Dog static variable
Dog class constructor
Dog instance variable
Animal static variable
Animal class constructor
Animal instance variable
Animal instance constructor
Dog instance constructor

There are two things I find surprising about this:

Why do static constructors run from most derived class to least derived class, i.e. Dog then Animal?
Why do instance variables get initialized before calling the parent’s instance constructor?

The answer to question 1 is that Dog’s class initializer has to be run since we are running Dog’s instance constructor, but execution of any type's class initializer method will not trigger automatic execution of any class initializer methods defined by its base type. Indeed, why should it?

The answer to question 2 is complicated. Constructing instance fields in the most derived class first is the only way to ensure that readonly fields are initialized and then not changed. Check out Eric Lippert’s blog for a decent explanation: http://blogs.msdn.com/ericlippert/archive/2008/02/15/why-do-initializers-run-in-the-opposite-order-as-constructors-part-one.aspx

Using the Exception Hunter Command Line to find All Methods that throw a given Exception

Jason Crease — Thu, 31 Jan 2008 18:01:00 GMT

Red-Gate's new .NET tool - Exception Hunter - shows you the exceptions that can be thrown by a .NET method. However, many users would like to see this the other way round, i.e. pick an exception and see which methods throw that exception. We will endeavour to put this in the next version of Exception Hunter.

However, for the moment this functionality is available via the Exception Hunter command line. I've recorded a 5-minute video where I demonstrate how to use the command-line to find all methods that throw IO exceptions in a simple application. Have a look...

http://www.simple-talk.com/blogbits/jason_crease/Exception_Hunter_Command_Line_demo_skin.swf

To download the 14-day free-trial of the .NET Developer Bundle, which includes Exception Hunter, go to:

Download .NET Developer Bundle