Take the 2-minute tour ×
Programmers Stack Exchange is a question and answer site for professional programmers interested in conceptual questions about software development. It's 100% free, no registration required.

My client is looking to standardize on its "helper" tools suite of applications to aid developers of a very large .NET project in debugging, profiling, finding memory leaks and performance bottlenecks, etc. kinds of issues

All developers use VS2010, target .NET 4.0, and support a large distributed system: Winform UI client (CAB framework), SQL2008 Backened, CSLA app-tier with Dataportal & remoting, and there is a large job-processing layer with Compute cluster pack (CCP) as well as a few dozen other peripheral technologies.

To give you an idea of the size, the system is probably north of 5M lines of code, has about 100 developers around the world and has been in development & production support for the last 5 years with this same team size.

Over the years, client did not have a single strategy that revolved around profiling tools of kinds. Client bought the tools when programmers said: "oh, this looks nice to trouble-shoot this particular problem I'm having".. So, now the client wants to standardize on a suite of tools.

What has worked so far: Ants for memory profiling. dotTrace for performance profiling. There is currently a serious consideration being given to CA Wiley for production monitoring.

VS2010 profiling has been deemed not good enough and not working well enough within the current system.

Can anyone recommend a single suite of tools that would be a good substitute for ALL the tools mentioned above? Integration with VS2010 is a must. All sorts of bells & whistles and ease-of-use and ability to drill-down into deepest levels to find the weirdest problems is required.

Thank you for your suggestions

share|improve this question

closed as off-topic by gnat, MichaelT, david.pfx, Bart van Ingen Schenau, Dynamic May 19 at 0:08

This question appears to be off-topic. The users who voted to close gave this specific reason:

  • "Questions asking us to recommend a tool, library or favorite off-site resource are off-topic for Programmers as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it." – gnat, MichaelT, david.pfx, Bart van Ingen Schenau, Dynamic
If this question can be reworded to fit the rules in the help center, please edit the question.

    
Have you tried perfmon? –  Doug T. Dec 13 '10 at 23:52

4 Answers 4

up vote 1 down vote accepted

I would recommend to stick with Redgate products since it has nice UI with good performance. They have .NET Bundle for performance & memory profiling.

http://www.red-gate.com/products/dotnet-development/dotnet-developer-bundle/

share|improve this answer
    
We are leaning toward that. How is Redgate performance profiler compared to dotTrace? I have not seem to be able to find a decent side-by-side comparison –  Igorek Dec 15 '10 at 5:25
    
I don't have direct comparison details with both of these software. However, both tools are popular in the market as well as some people feel good with red-gate and others find useful with dottrace. You have to use both and find useful which one is good for you. –  sankar Dec 15 '10 at 6:22

If this project already has 100 developers, why don't you survey them and find out what they like?

They should, of course, be willing to back up their opinions with intelligent arguments as to why their preferences are the best ones.

share|improve this answer
1  
Our 100 developers have 100 opinions :) But seriously, the key developers seem to only have experience with one product only. So, their opinions seem to be lopsided and divided. –  Igorek Dec 15 '10 at 5:26

I only have an opinion on how to find what are called "bottlenecks". For on-going monitoring of performance, and for finding memory leaks, etc., I have no opinion.

For finding performance problems, or, more positively, opportunities for optimization, profilers as a class differ widely. Here's a discussion of the issues.

Since there is so much general confusion about what profilers should do, you're not going to get much agreement out of 100 programmers on how it should be done. The method I use is not a tool, but a technique, called random-pausing. Whether people find it acceptable depends on whether they've tried it, and few have. Here are a few.

Here's a blow-by-blow example, in which a speedup of 43 times was done.

It works better on large systems. Or rather, large systems tend to be riddled with performance problems, which it easily finds. The reason, in my experience, is that as software grows, both logic bugs and performance bugs creep into it. Logic bugs demand to be fixed, but performance bugs don't, so they gradually accumulate and pile on top of each other.

In my experience, what limits the speedup you can get is not technical, but personal. When a performance bug is found and roughly quantified, it is up to the person who "owns" the code to perform the fix. If they are not willing to, for example if the fix runs against a strongly-held idea, or if there is a sense of criticism, then the process can stall. In such a group, leadership skills make all the difference.

There are certain categories of problems which it will not find, namely those in which the reason for the software being in some particular state is difficult or impossible to determine. This can happen in highly asynchronous systems where to make sense of it one has to track messages across processes. When I have to tune such a system I resort to more laborious methods which nevertheless work. For most problems, random-pausing does the trick.

So it's a good tool to have in your "kit", and it's free (if that's any motivation :)

share|improve this answer
1  
I don't really want to get into a long discussion about this, as this thread was not made for that. However, there are times when random-pausing is somewhat useless. Things like multi-threading, long running operations that have sequential chunks inside (depending when you'll randomly-break, you'll get a different long-running chunk, etc). Profilers are great at showing you how things relate to one another and whether it is even worth spending the effort on optimizing certain function when there are 2 others that maybe more important to attempt to optimize first. –  Igorek Dec 17 '10 at 3:54
    
@Igorek: For multi-threading, it works OK on a thread-by-thread basis. That's what we do - our app is 1 Meg-line. Where it is difficult is when the performance problem only happens sporadically. Then you either need lots of samples which you then ignore most of them, or figure out an alarm-clock timer way to trigger them when the problem's occurring. In any case, what I usually see in a big system like that is the main performance problem is runaway notifications. –  Mike Dunlavey Dec 17 '10 at 14:06

JetBrains (maker of Resharper) offer some profiling and coverage tools in the form of dotTrace and dotCover. They both integrate into VS, and have been useful to me.

share|improve this answer

Not the answer you're looking for? Browse other questions tagged or ask your own question.