JetBrains .NET Tools Blog

As some of you may have noticed, we have recently opened the EAP for dotTrace 5.0 Performance. It was a very quiet launch for a number of reasons, but now here we are talking about the new exciting version of the .NET performance profiling tool.

There’s a ton of new features in this release as outlined below and some of the major features we’ll get back to in future posts, covering them in full detail. For now, download dotTrace 5.0 Performance EAP, and read further to learn what you’re going to get with it.

Remote profiling enhancements

One of dotTrace Performance benefits is the ability to preform remote profiling of applications. This comes in very useful when instance you are trying to diagnose and issue on a machine that is in production. In dotTrace 5.0 Performance, we have enhanced this behavior to allow:

• Running the profiling agent as a regular service or ASP.NET Web Service.
• Remote profiling over HTTP. This effectively removes some of the common barriers encountered when trying to do remote profiling such as firewalls or VPNs.
• Less administrative permissions making it easier to use in more restricted environments.

Attach to a running process

A great new feature in dotTrace 5.0 Performance is the ability to attach the profiler to an existing process and run performance analysis on it. Once sufficient information has been collected, the profiler can then be detached. This allows us to open up new usage scenarios like taking a snapshot of an application that needs to be run for hours (or days) before it starts to display any performance issues.

Profiling API re-design

In dotTrace 4.5.1 Performance, we introduced a very early version of the profiling API which allows you to incorporate profiling capabilities inside your application. It was a rough-cut version and had one minor glitch: you could not detach the profiler once attached. This problem has now been solved as mentioned above, and the API has been overhauled to provide a much richer development experience.

Command line support

Version 5 also introduces support for running dotTrace Performance from the command line, including:

• A configuration helper for command line execution.
• Ability to integrate performance profiling into the Continuous Integration process (using TeamCity for example) via MSBuild or NAnt tasks.

dotPeek integration

If you are still not familiar with dotPeek, it is a free .NET decompiler tool which we opened the EAP several months ago. One of the core ideas of dotPeek is to offer integration with our other productivity tools, such as ReSharper, whereby you can decompile any assembly for which you do not have the sources, directly from within Visual Studio. We now offer the same experience with dotTrace 5.0 Performance (we have actually posted a preview of it several months ago.) While profiling an application, if you need to dig further into the code and you do not have the PDB’s, dotTrace Performance will decompile it for you in-place and present decompiled code in the source preview area.

Enhancements and additions for supported frameworks

This version will also provide support for CLR 4.5 as well as Windows 8. In addition to the new frameworks, dotTrace 5.0 Performance also provides side-by-side profiling of CLR 1/2 and CLR 4.0/4.5 frameworks.

Compatibility with TypeMock Isolator

In collaboration with our friends at TypeMock, we have made dotTrace Performance work seamlessly along with TypeMock Isolator. This allows you to easily profile your unit tests even when using TypeMock as a mocking framework. It also means that dotTrace Performance can now work in what’s called transparent mode, stepping back and allowing other engines to interleave between dotTrace and the target of the performance profile.

Improvements in Plain List View

Among the improvements is the ability to filter in-place, system functions in the Plain List View as well as group functions by assemblies:

Other features and improvements

dotTrace 5.0 Performance is packed with a ton of smaller features, bug fixes and performance improvements, including:

• Lower memory footprint during performance profiling.
• Support for IIS Express from within or outside of Visual Studio.
• Improvements on the UI for Adjust Time functionality, allowing control of non-user-defined functions.
• Up to 20 times performance improvement on plain list construction for larger snapshots.
• Threads with message pumping loop are now highlighted.
• Close to 40 bug fixes, including some important ones affecting callstacks.

Get your EAP build!

You can start playing with dotTrace 5.0 Performance by downloading the latest nightly build from the Early Access Program Page today!

Christmas is only a few days away and we’ve decided to celebrate it a little earlier by releasing not one, but all three of our main .NET tools: ReSharper 6.1, dotCover 1.2 and dotTrace 4.5.2 Performance.

ReSharper 6.1

As covered in previous posts, this release of ReSharper is much more than a few bug fixes.

Settings

In ReSharper 6.0 we laid the foundations for what would be the new settings management engine. This was quite a substantial change, both from an architectural point of view as well as functional. Unfortunately due to that pesky little annoyance called time, we did not manage to finish it for the 6.0 release. We have now though and ReSharper 6.1 introduces a wealth of new possibilities for sharing settings across solutions, teams, machines and even company-wide policies. And we’re still not done with settings, so keep your feedback coming for further releases.

Performance improvements

For every single release of ReSharper, we invest a large amount of time in performance improvements. This often isn’t an easy task since new releases also include new functionality. In 6.0 we had some serious performance issues with certain types of web projects. This has now thankfully been resolved in 6.1 and we’ve made 6.1 faster in many areas. Numbers are impressive: we have fixed 140 performance problems for 6.1.

Async and Visual Studio 11 support

Async support in C# is still in CTP stage. Visual Studio 11 is in early developer preview. Trying to support technology that is not entirely finished proves not only challenging but also risky. Any major changes could deem most of the work we’ve performed as obsolete. However, we know that you, our users, play with the early bits and miss ReSharper.

That’s why in 6.1 we provide support for Async features in C# and VB.NET, as well as initial experimental support for Visual Studio 11. Support for Metro style applications is not yet included, and in order to install ReSharper into VS11 Developer Preview, you have to use a separate .vsix installer available at ReSharper downloads.

Optimizing assembly references

Many users rely on ReSharper in streamlining their project maintenance tasks, and this new feature is a nice addition to the existing project-level toolset. In any project in your solution, ReSharper 6.1 detects assembly references that are not effectively used, and helps remove some or all of them.

SDK

During 6.0 development we invested heavily in trying to provide a better API for extending ReSharper. 6.1 also sees the birth of this effort. Along with an improved API, we also now provide a testing framework, Visual Studio templates for creating plug-ins, samples, as well as online documentation. ReSharper 6.1 SDK is available for download as a .msi or .zip package.

More awesome features

Here are a few more great features also added:

• Structural Search and Replace for HTML and ASP.NET. You can now use Custom Patterns to refactor both HTML and ASP.NET markup.
• Call tracking for ASP.NET MVC. Same call tracking features, extended to ASP.NET MVC 3.
• New code inspections. Access to disposed closures, covariant array conversions and more.

We have also fixed many outstanding issues. Look for more blog posts describing 6.1 features and improvements in future here on the JetBrains .NET tools blog.

dotCover 1.2 and dotTrace 4.5.2 Performance

These are mainly maintenance releases with a primary focus of supporting ReSharper 6.1. In addition, dotCover 1.2 works side-by-side with TypeMock 6.2.x, provides performance improvements in report generation, reduces HTML report size and memory consumption.

Note that we are already working on next major dotCover and dotTrace Performance releases. EAPs are expected soon, exposing a ton of new functionality and improvements, so stay tuned for that.

Download them all!

You can download ReSharper 6.1, dotCover 1.2 and dotTrace 4.5.2 Performance right now!

Last but not least, we’d like to wish everyone very Happy Holiday season. Stay safe and see you all in the New Year!

As you might know, dotPeek is our Free Decompiler which is currently available under the EAP program. The core engine for dotPeek is also included in ReSharper 6, allowing us to navigate and analyze assemblies for which we do not have the source code.

As could be expected, we will be including the same feature in dotTrace Performance. This potentially allows us to decompile any code we are profiling and examine if a potential issue could lie in this actual decompiled code.

Take the following sample application (in this case Nerddinner) :

When examining the list of functions, we might encounter a call that is part of a library. When trying to display the source, dotTrace would prompt us for the PDB files.

If, for whatever reason we do not have the PDB files, we can now click on the “Decompiled source” tab and have the dotPeek engine decompile the source code for us:

This makes it even easier to dig into third-party code to determine if there are any potential bottlenecks. This functionality will be available in the next major version of dotTrace and available soon when the EAP program opens.

dotCover 1.1.1 and dotTrace Performance 4.5.1 have been released!

dotCover 1.1.1

Despite the minor revision number, dotCover 1.1.1 introduces a ton of new features in the release.

ReSharper 6 Integration

With the recent release of ReSharper 6, we’ve been working hard to provide support for dotCover. As in previous versions, you can now run code coverage of tests directly from Visual Studio via the ReSharper test runner:

In addition, if you’re using ReSharper 6, you now get an additional icon () which allows you to cover all tests from the solution easily (accessible via the shortcut key Ctrl+U, K). Of course, ReSharper 5.x is also supported with this release.

Support for Dynamic NUnit Tests

dotCover now fully supports what are classified as dynamic tests in NUnit, i.e. those with variable input parameters and thus generated when tests are run. This includes the common TestCase attribute as well as Combinatorial, Sequential, TestCaseSource, Pairwise, Repeat as well as Random and Range attributes supported in method parameters.

This of course also allows a correct interpretation of tests covered by a certain section of code:

which corresponds to placing the cursor on the return statement and asking dotCover to Show covering tests (Ctrl+Alt+K). If we were to place the code on the exception we’d get:

as expected.

Exclusion/Inclusion Nodes Persistence

In dotCover 1.1 we added the possibility of excluding or including specific tests from coverage by selecting the node in the tree. We now provide persistence of these nodes between coverage runs (saved in *.settings file when saving snapshots), as well as support for Undo and Redo operations via the normal Ctrl+Z/Ctrl+Y key shortcuts.

Other Improvements

Apart from the previous, this release also includes

• Optimizations in the area of snapshot storage, memory consumption and performance of multi-threaded applications.
• Per-Snapshot settings, allowing snapshots to be saved along with node persistence exclusions as indicated previously (saved as *.dcvr and *.settings respectively).
• Improved notifications during coverage analysis
• Embedded progress bar in Unit Test Session Runner, as opposed to a modal dialogue
• Warnings when no coverage for a selected test is found

Download from here

dotTrace Performance 4.5.1

This release of dotTrace has primarily been focused on integration with ReSharper 6 and minor bug fixes and improvements. Much like dotCover, dotTrace also supports the possibility of profiling all tests with one button click ()  or using the shortcut key Ctrl+U, O. This feature is in fact available for any custom test host provider that use ReSharper’s test runner.

Other Improvements

This release also includes:

• Shortcut provided (Ctrl+R) for editing configuration used for profiling without having to first return to Welcome screen.
• Fix for OutOfMemory exception when constructing Hotspot Views
• Support for Opening all method instances merged (Ctrl+Shift+T) in Hotspots View
• Support for Adjust Time on special functions like Garbage Collector or Native Code
• Fix for Registry Cleanup allowing Windows services to work as intended
• Improved stability under IIS and ASP.NET
• Fix of the computation of the total time of Children nodes for a root constructed as implicit recursive node
• Work started on Profiling API

and more bug fixes.
Download from here

We have a new ReSharper build for you available: ReSharper 6.0 Release Candidate 2.

RC2 removes a few more outstanding cases of good-code-red, ensures that ReSharper takes the Suppress warnings project property into account, fixes a pack of issues related to the Find Code Issues window and solution-wide analysis.

In other news, we have opened Early Access Programs for dotCover 1.1.1 and dotTrace 4.5.1 Performance — new minor versions of the code coverage tool and the profiler tailored specifically to support ReSharper 6. We’ve received a lot of complaints on ReSharper 6 not being able to integrate with dotCover and dotTrace Performance, and these EAPs will hopefully take this pain away.

We’re releasing updates to our performance profiler and code coverage tool for .NET developers today: please download the release builds of dotTrace 4.5 Performance and dotCover 1.1.

We have blogged about the upcoming releases before but here’s an overview of the most important changes. New features in dotTrace 4.5 Performance include:

• Reworked presentation of profiling results: Better aligned icons, overall clearer call trees, quick folding of irrelevant nodes.
• New options to estimate potential performance gains: More different ways to adjust time of a function and see how it would affect overall application performance.
• Analyzing the performance of a certain class along the lines of its API: You can now open all public methods of a class in a separate tab.

Read more about improvements in dotTrace 4.5 Performance, or watch this screencast:

dotCover 1.1 highlights include:

• Generating code coverage reports as XML, HTML, JSON, and XML for NDepend.
• Per-solution coverage settings.
• Code coverage analysis results can be directly requested from a TeamCity server to Visual Studio.

Get more details about the advantages of dotCover 1.1, or, once again, watch how the new dotCover works in the following screencast:

dotTrace 4.5 Performance comes as a free upgrade for all dotTrace 4.0 Performance users, as well as for all dotTrace 3.x customers who have purchased the product after December 17, 2008.

dotCover 1.1 is a free upgrade for all its existing customers.

First of all, dotCover 1.1 RC and dotTrace 4.5 Performance RC builds are available starting today.

We’ve fixed a couple of issues since Beta 2 builds, such as buttons not working in some cases in dotCover’s Show Covering Tests pop-up, inaccurate system requirements check in dotTrace, and a pack of exceptions. Please help us verify that these release candidates are OK for public releases later this month.

If you face any serious bugs, please use the dotCover issue tracker and dotTrace issue tracker to report them.

There’s also something we should make you aware of regarding using dotCover 1.1 with MSTest. If you’re a MSTest user, you might have noticed that per-test statistics and incremental merge for MSTest tests executed with dotCover 1.1 from Visual Studio can sometimes be out of sync with actual results. This is due to the way that MSTest runner is implemented in ReSharper 5.x. The updated MSTest runner in ReSharper 6 will fix this issue, resulting in more accurate MSTest coverage results. dotCover 1.1.1 containing this fix will be available shortly after ReSharper 6 release this summer.

Following community feedback on the initial beta releases of dotCover 1.1 and dotTrace 4.5 Performance, we have prepared Beta 2 builds of these products for you to try:

• Download dotCover 1.1 Beta 2
• Download dotTrace 4.5 Performance Beta 2

Compared to the Beta 1 stage, here’s what sets dotCover 1.1 Beta 2 apart:

• In the console runner, configuration actions can now be taken from the command line (without using XML), and snapshots can be passed directly as arguments.
• Streamlined coverage analysis of web applications: specifically, errors are now better handled during analysis, and a snapshot is opened immediately after clicking “Get snapshot”.
• Bug fixes including those related to suspending and resuming dotCover.

Improvements in dotTrace 4.5 Performance Beta 2 include:

• No more loss of focus on applying zero folding.
• Constructors are now included when you choose to open all public methods of a class in a separate tab.
• Some less noticeable bug fixes and usability improvements.

Note that, due to a bug when switching between editions that we’re yet to resolve, dotTrace 4.5 Performance Beta 2 is released as a development build — that means, exceptions are not suppressed.

Enjoy the new builds, and please don’t forget to share any issues you may encounter using dotTrace issue tracker and dotCover issue tracker.

We are pleased to announce the immediate availability of dotCover 1.1 Beta and dotTrace 4.5 Performance Beta. Having opened Early Access Programs for both products just over a month ago, and based on the feedback received, we are now ready to push out the Beta’s for the products.

What’s new in dotCover 1.1 Beta

We have described many of the features in detail in the post on dotCover 1.1 and dotTrace 4.5 Performance EAP. Summary of these are:

• Improved presentation of class members in the coverage results tree
• Filtering coverage tree on-the-fly with recalculation of statistics
• Per-solution settings for coverage
• HTML/JSON report generator
• Two predefined color schemes for coverage highlighting
• On-demand license checking

In addition, this latest Beta release includes:

• Incremental update of coverage info when part of tests are rerun. Coverage information is calculating incrementally without requiring a full profiling on new runs, making the whole process much faster.
• NDepend integration. We now provide support for NDepend, allowing the possibility of exporting coverage reports in XML format suitable for NDepend:
  
• Integration with TeamCity Visual Studio plug-in for obtaining remote snapshots. You can now use TeamCity’s VS plug-in to connect to a TeamCity server and obtain snapshot information from a Continuous Integration coverage analysis run:
  

What’s new in dotTrace 4.5 Performance Beta

Once again, most dotTrace 4.5 Performance features are already described in the EAP announcement post. Here’s a summary of these:

• Less noise in call stacks and improved tree representation
• Putting all public methods of specific class in single tab
• Improved estimation of potential performance gains
• Source preview for .NET Framework assemblies
• Display of IL code in source view
• Performance improvements
• New floating license handling policy
• Welcome Page cosmetics

New addition in dotTrace 4.5 Performance Beta is that the Sampling is now the default profiling mode.

We have of course also focused on fixing issues that were reported during the EAP and earlier versions of the product.

You’re welcome to give the beta releases a try: download them from dotTrace web site and dotCover web site.

If you happen to see any bugs or glitches, please report them to dotTrace bug tracker and dotCover bug tracker.

Let’s say you’re trying to improve performance of some application that is doing poorly. You manage to find what could potentially be a bottleneck and decide that it needs fixing. Of course, Murphy’s Law dictates that the potential issue you’ve found is probably one of the harder problems to solve as it might involve improving a calculation algorithm or changing some third party framework.

This could turn into quite an expensive operation. It would be a shame to spend time and resources on it to not have a the desired impact on the overall system. In other words, it’s best to know you’re barking up the right tree.

What if…

That’s where dotTrace Adjust Time feature comes in very handy. By allowing us to adjust the amount of time spent in a particular spot of an application, we can simulate the overall impact it would if we were to perform optimizations in that area, without having to actually do them first.

Let’s take a look at the following call tree of a performance trace for a sample application

Looking at the call trace, we can see that the majority of the time spent is dedicated to IntersectRay. This method in turn calls Sphere.Intersect and Plane.Intersect. Out of the two, the first is the more time-consuming

What would happen if we were to now try and optimize the performance of Sphere.Intersect? What overall impact would it have if the time it takes to complete the call were reduced by 30%.

Now, instead of spending time on re-designing the method, we will use the simulation functionality in dotTrace to verify whether it’s worth a potential effort.

To simulate the improvement, we right-click on the Intersect line and select Adjust Time

We are then prompted by a dialog box that allows us to adjust the time by a factor of 0 to 100.

Apart from adjusting the time, we can indicate whether we want the adjustment to be only on the specified call stack that we are currently on (Selected Call Stack), applied it to all call stacks (All call stacks) of this method or call stacks with the calling method as the parent function (this last option is available in dotTrace 4.5 EAP only).

We can also specify whether we want the adjustment to effect the overall time of the function (the function itself and all functions it calls), only the function’s own time or all functions of the the specified class.

It is important when applying adjustments to take these options into account because selecting different values can have an impact not only on the current call stack we are trying to optimize but also on the entire application.

In our case, we are going to apply adjustments to all call stacks and to the function’s total time. We will apply a 30% reduction, which means we will enter 70 as the Factor value. This now produces the following result

First thing to notice is that the line where we’ve adjusted the time is crossed out. Next to each time, we now see a new amount in the color green and the original time in blue in brackets. Focusing on the IntersectRay method, a 30% improvement of Sphere.Intersect would lead to approximately 19% improvement on the call and an overall increase of 15% in terms of performance. Is that worth it?

Let’s dig deeper. Opening up Sphere.Intersect we see that 24% of the time is dedicated to the Vector.op_Multiply. What would happen if we were to focus our improvement exclusively on this method call? Applying the same 30% increase in performance, we’d end up with an overall increase of 14%

Despite representing only 1/3 of the total time of Sphere.Intersect, an improvement on that call alone will provide us with the same overall performance increase as concentrating on the complete method. In fact, it makes more sense to optimize the op_Multiply method since it’s used extensively throughout the application. That’s where we should focus our efforts!

Optimization Shortcuts in 4.5

dotTrace 4.5, which at the time of publishing this post is in EAP, introduces some shortcuts for time adjustment. When right-clicking on Adjust Time context menu, a submenu displays two additional options:

which allow us to quickly optimize the current (or all) instances of a specific method. Optimizing means setting the total time to 0.

Experimenting before committing

The reason for the Adjust Time feature in dotTrace is for experimenting with different calls before actually having to commit to changes. Often a 10% increase in one function can lead to a 20% overall improvement. Other times, it can lead to a 2% improvement. Knowing this before hand is very valuable since it provides us with something to balance against to see not only whether we’re barking up the wrong tree, but also if it’s worth barking at all.