Scalable to Huge Solutions

CodeRush by DevExpress provides stable functioning, efficient memory usage, and fast performance when working with both small and large solutions. You can judge the CodeRush efficiency by looking at the results of its performance and memory consumption measurements mentioned below.

We tested three of our internal DevExpress solutions. Two of these solutions are among our largest: DX Controls and XAF. The third is a medium-sized project, XtraScheduler. The table below gives you an idea of their respective sizes using a variety of metrics:

Some details on the test machine:

• Processor - Intel Core 2 Duo E6400, 2.13 GHz
• Memory - 2 GB
• Hard disk drive - Seagate st3250824as, 7200 RPM (8ms average seek time, 9ms average write time)
• Operating system - 32-bit Vista, SP1

Efficient Memory Usage

CodeRush is notable for the low memory consumption. This is obtained due to perfect runtime objects structure and resource consumption management. For example, CodeRush does not consume memory to hold all project symbols, because they are only loaded from cache when needed. CodeRush also keeps only recently-accessed members in memory, while stale members are aggressively released.

The data below shows total Task Manager memory (in megabytes) after loading a large solutions and reaching that point where we are able to refactor anywhere in the solution (all source code has been parsed).

The savings in memory is huge, especially considering the size of these projects and the fact that this memory also holds all the assemblies required simply to keep CodeRush running.

The percentage numbers in white near the top of each bar show how much additional memory is required by CodeRush (to represent the entire solution as well as its referenced assemblies) as a percentage of that needed by Visual Studio alone (if you didn't have CodeRush installed).

Fast Performance

When you write code with CodeRush, it executes hundreds of operations without any significant performance impairment. Only an identifier renaming may take a few seconds or minutes, depending on the solution size. But, note that CodeRush renaming is anyway faster than the same feature in any CodeRush-like product.

The important CodeRush performance characteristic is solution load time. We minimized the time it takes to go from specifying a solution to open in Visual Studio to the ability to refactor anywhere that a solution (we call this "zero-to-refactor" time). Refactoring anywhere means CodeRush has a full understanding of all the code in the entire solution.

When you first open a solution, CodeRush parses it and caches important information using a background thread (the back row in purple on the chart below).

Notice that once the cache is built, subsequent times to load a solution and get from zero-to-refactoring for CodeRush (middle row in red) approach those of Visual Studio's normal load time for the solution (front row in blue).

By the way, if you are looking at that 200-second parse and cache-building time for the DX Controls project and on the verge of freaking out, you may find relief in the following:

• That time is from zero (no solution open) to the ability to instantly initiate a refactoring anywhere (no build required).
• This is all happening in a background thread. Visual Studio remains responsive during this time.
• The DX Controls solution declares over seventeen thousand types and over two hundred thousand members. It's 84MB of source code and nearly two million lines of code long. This solution is significantly larger than most solutions out there.
• This cache-construction stage only occurs once - the first time you open a solution without a cache.
• This zero-to-refactor performance for first-time solution loads is actually comparable if not significantly faster than the competition.

Unit Test Runner Performance

The CodeRush Test Runner is the fastest test runner available for .NET. With our new multi-threaded run option, you can run tests in multiple assemblies in separate threads, resulting in a test run that is up to three times as fast as any similar product.