PerfWorld.com

How can I disable batch compilation for my ASP.NET web pages so that the first user accessing the web site doesn’t experience slow performance?

Reuben Frost — Thu, 14 Jan 2010 02:36:00 GMT

The batch property of the compilation element, which is enabled by default in ASP.NET, is used to control whether the initial page request will continue to compile additional files in the same directory before completing the original request. This can cause significant delay to the first several initial requests when enabled on moderately-sized web sites. Once a page has been compiled during the first request, all subsequent requests are performed without any compilation delay. In most cases, I recommend disabling this property by setting the batch compilation property value to “false” in the web.config file. Changing this value is not necessary if you precompile your ASP.NET web site with the “updatable” flag set to false.

File: Web.config

For more information on precompiling pages for better performance:
http://blogs.msdn.com/perfworld/archive/2009/01/29/how-can-i-precompile-my-asp-net-web-pages-so-that-the-first-user-accessing-the-web-site-doesn-t-experience-slow-performance.aspx

For more information on the compilation element:
http://msdn.microsoft.com/en-us/library/s10awwz0.aspx

How can I improve the performance of ASP.NET by adjusting the CLR thread throttling properties?

Reuben Frost — Thu, 14 Jan 2010 01:22:00 GMT

This post applies to: .NET 2.0, 3.0 & 3.5.

The CLR uses an adjustable threshold property called minWorkerThreads and minIoThreads to control when to introduce throttling to thread creation. The idea behind the delay is to prevent a burst in request load from quickly creating additional threads that will later lead to excessive thread context switching and negatively impact performance.

In ASP.NET, the CLR defaults both the minWorkerThreads and minIoThreads properties to 1. This number is then multiplied by the number of logical processors you have so a 2 core server with default settings (minWorkerThreads=1, minIoThreads=1) would have a worker thread minimum limit of 2 and completion port minimum limit of 2. I would recommend changing both properties to a number between 1 – 50. The best way that I have found to determine the optimal number of minWorkerThreads is to take a user mode process dump of the W3wp.exe process during typical load and use the Worker Threads Total from the !threadpool command as a starting point.

Here is an example of the !threadpool command output:

0:000> .loadby sos mscorwks

0:000> !threadpool
CPU utilization 38%
Worker Thread: Total: 160 Running: 24 Idle: 136 MaxLimit: 3200 MinLimit: 32
Work Request in Queue: 0
--------------------------------------
Number of Timers: 70
--------------------------------------
Completion Port Thread:Total: 3 Free: 3 MaxFree: 96 CurrentLimit: 3 MaxLimit: 3200 MinLimit: 32

So if your web site typically runs with a worker thread total of 160, then 160 divided by the number of logical processors would be a great place to set minWorkerThreads and minIoThreads to. So in the example above, with 32 logical processors, the minWorkerThreads and minIoThreads should be set to 5 (5 * 32 cores = 160 which is the current worker thread total).
After setting the value to 5, understand that this will not automatically create 160 threads nor guarantee to maintain 160 threads while the process is running. What this will actually do is allow the process to create up to 160 threads before introducing throttling to thread creation. Think of these properties as if they were named minWorkerThreadsBeforeThrottling and minIoThreadsBeforeThrottling. A word of caution; if you change the minimum threads to a value greater than the maximum (default is 100) then the value will be ignored and the default minimum of 1 thread will be used.

File: Machine.config

There are times then you need to adjust the CLR threading in code rather than in the Machine.config. Here is an example in C#:

const int MinimumClrThreads = 5; //use this value to control the threads

//get number of logical processors to simulate default asp.net behavior

int logicalProcessors = System.Environment.ProcessorCount;

int minWorkerThreads = MinimumClrThreads * logicalProcessors;

int minIoThreads = MinimumClrThreads * logicalProcessors;

//set the minumum number of worker and IO threads

ThreadPool.SetMinThreads(minWorkerThreads, minIoThreads);

For more information on the ProcessModelSection class:
http://msdn.microsoft.com/en-us/library/system.web.configuration.processmodelsection.aspx

How can I throw an exception without losing the original stack trace information in .NET?

Reuben Frost — Tue, 16 Jun 2009 00:31:00 GMT

Use the "throw" keyword in place of "throw ex" to perserve the original stack trace information.

When you throw an exception using “throw ex” instead of “throw” you override the original stack trace with a new stack trace that starts from the throwing method. This can make tracking down the root causes of exceptions much more difficult. Take a look at the example below in order to see the differences in the stack traces depending on which option you use.

class ExceptionallySpeaking
{

    static void Main(string[] args)
    {
        try
        {
            MethodA();
        }
        catch (Exception ex)
        {
            //Option 1 - Showing overridden exception stack with MethodA instead of MethodB on top
            //Exception: System.NotImplementedException: The method or operation is not implemented.
            //   at ExceptionallySpeaking.MethodA()
            //   at ExceptionallySpeaking.Main(String[] args)

            //Option 2 - Showing original exception stack with MethodB on top
            //Exception: System.NotImplementedException: The method or operation is not implemented.
            //   at ExceptionallySpeaking.MethodB()
            //   at ExceptionallySpeaking.MethodA()
            //   at ExceptionallySpeaking.Main(String[] args)

            //Option 3 - Showing original exception stack with MethodB on top plus additional information
            //Exception: System.Exception: Additional information... ---> System.NotImplementedException: The method or operation is not implemented.
            //   at ExceptionallySpeaking.MethodB()
            //   at ExceptionallySpeaking.MethodA()
            //   --- End of inner exception stack trace ---
            //   at ExceptionallySpeaking.MethodA()
            //   at ExceptionallySpeaking.Main(String[] args)

Console.WriteLine("Exception: {0}", ex.ToString());

}
}

    public static void MethodA()
    {

        try
        {
            MethodB();
        }
        catch (Exception ex)
        {
            //Option 1 - Overrides original stack trace
            throw ex;

//Option 2 - Keeps original stack trace
throw;

//Option 3 - Keeps original stack trace and adds aditional information
throw new Exception("Additional information...", ex);

        }
    }

    public static void MethodB()
    {
        throw new System.NotImplementedException();
    }

}

Let's dig a little deeper on this topic and discover the mystery behind Throw vs. Throw ex and the shrinking stack trace.

In Microsoft intermediate language (MSIL), the "throw ex" in C# will be converted into "throw" while "throw" in C# will be converted into "rethrow". This difference is what causes "throw ex" to contain less stack trace information since it will restart the exception throwing process from MethodA instead of continuing to rethrow the original exception from MethodB.

Option 1 - MethodA catch block using "throw ex" in MSIL

catch [mscorlib]System.Exception
{
    IL_000b: stloc.0
    IL_000c: nop
    IL_000d: ldloc.0
    IL_000e: throw
} // end handler

Option 2 - MethodA catch block using "throw" in MSIL

catch [mscorlib]System.Exception
{
    IL_000b: stloc.0
    IL_000c: nop
    IL_000d: rethrow
} // end handler

How can I use WMI and Powershell to determine if a computer running a 32-bit operating system can support a 64-bit operating system?

Reuben Frost — Fri, 27 Feb 2009 23:02:00 GMT

Below is a sample Powershell (Windows Powershell - WPS) script that will detect if a computer that is running a 32-bit operating system will support a 64-bit operating system using WMI (Windows Management Instrumentation).

$strComputerName = "."
$strCpuArchitecture = ""
$intCurrentAddressWidth = 0
$intSupportableAddressWidth = 0

$objWmi = Get-WmiObject -class "Win32_Processor" -namespace "root\cimV2" -computer $strComputerName

$intCurrentAddressWidth = $objWmi.AddressWidth
$intSupportableAddressWidth = $objWmi.DataWidth

switch ($objWmi.Architecture)
{
0 {$strCpuArchitecture = "x86"}
1 {$strCpuArchitecture = "MIPS"}
2 {$strCpuArchitecture = "Alpha"}
3 {$strCpuArchitecture = "PowerPC"}
6 {$strCpuArchitecture = "Itanium"}
9 {$strCpuArchitecture = "x64"}
}

if ($intCurrentAddressWidth -eq $intSupportableAddressWidth)
{
"System Type: $intCurrentAddressWidth-bit operating system - Processor Architecture: $strCpuArchitecture"
}
else
{
"System Type: $intCurrentAddressWidth-bit operating system ($intSupportableAddressWidth-bit capable) - Processor Architecture: $strCpuArchitecture"
}

Sample Output (32-bit Windows Vista with a 64-bit capable CPU):

System Type: 32-bit operating system (64-bit capable) - Processor Architecture: x64

For more information on Windows Powershell:
http://www.microsoft.com/windowsserver2003/technologies/management/powershell/default.mspx

For more information on downloading Windows Powershell v1:
http://www.microsoft.com/windowsserver2003/technologies/management/powershell/download.mspx

How can I deploy a single ASP.NET web page to a web site that is precompiled?

Reuben Frost — Fri, 30 Jan 2009 01:49:00 GMT

Every now and then, you may find yourself in the situation where you need to deploy a single file on a precompiled web site. I know I certainly have.

Here are the steps that I would use to accomplish this:

Build and precompile your whole web site as usual;
Search in the "Bin" folder of the build output web site folder for the file you want to deploy with a .compiled file extension;
Once found, open the file in a text editor like Notepad.exe (The .compiled file should contain an XML element called preserve that lists the assembly name and the virtual path where you can verify you have the file you want to deploy);
Copy the .dll assembly file named in the XML and the .compiled file to the "Bin" folder of the web site that you want to deploy to;
Done.

Example of XML contents of a file called default.aspx.cdcab7d2.compiled:

In the example above, the following two files would be copied to the Bin folder of the web site being deployed to:
App_Web_default.aspx.cdcab7d2.dll
default.aspx.cdcab7d2.compiled

For more information on precompiling a web site:
http://blogs.msdn.com/perfworld/archive/2009/01/29/how-can-i-precompile-my-asp-net-web-pages-so-that-the-first-user-accessing-the-web-site-doesn-t-experience-slow-performance.aspx

How can I precompile my ASP.NET web pages so that the first user accessing the web site doesn’t experience slow performance?

Reuben Frost — Thu, 29 Jan 2009 23:13:00 GMT

Precompiling your ASP.NET web pages is a great way to increase the performance of your web site. Once your web site has been precompiled, all of the content of your .ASPX, ASMX, ASAX, etc. files will be transformed into DLLs and placed in the "Bin" folder of your web site.

If you were to open one of these files after your web site has been precompiled, they would contain just one line that reads, “This is a marker file generated by the precompilation tool, and should not be deleted!”.

Aspnet_Compiler Command-line Example:

Aspnet_compiler –p c:\WebSiteFolder –v / C:\PrecompiledOutputFolder -f –fixednames

Visual Studio 2005/2008 example using the Publish feature:

Right-click on your Web Site in Solution Explorer and click Publish Web Site

Uncheck the "Allow this precompiled site to be updatable" checkbox
Check the "Use fixed naming and single page assemblies" checkbox

Note: The key things to remember when precompiling your web pages are to enable the use fixed names flag and disable the updatable flag.

For more information on deploying single ASP.NET web page to a web site that is precompiled:
http://blogs.msdn.com/perfworld/archive/2009/01/29/how-can-i-deploy-a-single-asp-net-web-page-to-a-web-site-that-is-precompiled.aspx

For more information on the ASP.NET compilation tool:
http://msdn.microsoft.com/en-us/library/ms229863(VS.80).aspx

How do I prevent ASP.NET trace and debug flags from being left enabled inadvertently in a production environment?

Reuben Frost — Wed, 28 Jan 2009 03:43:00 GMT

In the Maching.config file, there is a "deployment" element that you can add and set that will help in this area. Once set, this element will tell the ASP.NET process ignore several security and performance related settings that may have been left enabled inadvertently in the web.config and deployed in a production environment. Adding this element on all of your production servers results in the following:

The compiler "debug" flag will be set to "false", ignoring all web.config files
The trace “enabled” flag will be set to "false", ignoring all web.config files
The customErrors "mode" flag will be set to "On", ignoring all web.config files
The “ScriptMode” flag of the AJAX ScriptManager and ScriptReference controls will render release versions of the client scripts to the browser while ignoring all control level settings

File: Machine.config

For more information on the deployment element:
http://msdn.microsoft.com/en-us/library/ms228298(VS.80).aspx

For more information on the ScriptMode property:
http://msdn.microsoft.com/en-us/library/bb344940.aspx

For more information on how and why Microsoft.com uses the deployment element across the enterprise:
http://technet.microsoft.com/en-us/magazine/cc160896.aspx

How do I enable GZip compression for my web server in IIS?

Reuben Frost — Tue, 27 Jan 2009 22:58:00 GMT

GZip/Deflate compression will compress the response payload from the IIS web server to the browser. Pages that seem to run fast on the server but run slow over the network will see a big speed increase. I typically see around a 60% to 70% reduction in network traffic with GZip enabled. This could mean transfer rates to the browser up to 4x faster! Best of all, GZip/Deflate compression is built-in IIS out-of-the-box!

Who uses GZip compression for their web site:
- Microsoft.com
- Google.com
- Yahoo.com
- CNN.com
- eBay.com
- Facebook.com
- well, just about everyone.

Command-line example of typical usage settings to enable GZip compression for both dynamic and static content (from within Inetpub\AdminScripts and running IIS 6.0):

cscript adsutil.vbs set W3Svc/Filters/Compression/Parameters/HcDoDynamicCompression true
cscript adsutil.vbs set W3Svc/Filters/Compression/Parameters/HcDoStaticCompression true
cscript adsutil.vbs set W3Svc/Filters/Compression/GZip/HcDynamicCompressionLevel 7
cscript adsutil.vbs set W3Svc/Filters/Compression/GZip/HcScriptFileExtensions "asp" "dll" "exe" "aspx"
cscript adsutil.vbs set W3Svc/Filters/Compression/GZip/HcOnDemandCompLevel 7
cscript adsutil.vbs set W3Svc/Filters/Compression/GZip/HcFileExtensions "txt" "htm" "html" "js" "htc"
cscript adsutil.vbs set W3Svc/Filters/Compression/Deflate/HcDynamicCompressionLevel 7
cscript adsutil.vbs set W3Svc/Filters/Compression/Deflate/HcFileExtensions "txt" "htm" "html" "js" "htc"
cscript adsutil.vbs set W3Svc/Filters/Compression/Deflate/HcOnDemandCompLevel 7
cscript adsutil.vbs set W3Svc/Filters/Compression/Deflate/HcScriptFileExtensions "asp" "dll" "exe" "aspx"
cscript adsutil.vbs set W3Svc/Filters/Compression/Parameters/HcNoCompressionForHttp10 true
cscript adsutil.vbs set W3Svc/Filters/Compression/Parameters/HcNoCompressionForProxies true
IISReset

Setting Definitions for IIS 6.0

Enable compression for application files with dynamic content i.e. ASP, ASPX (default is false):
cscript adsutil.vbs set W3Svc/Filters/Compression/Parameters/HcDoDynamicCompression true
Enable compression for static files i.e. HTM, JS, CSS (default is false):
cscript adsutil.vbs set w3svc/filters/compression/parameters/HcDoStaticCompression true
The following lines will leave the default and add support for ASP.NET .ASPX file extension which is dynamic content (default file extionsions for dynamic content are .ASP, .DLL, .EXE):
cscript adsutil.vbs set W3Svc/Filters/Compression/Gzip/HcScriptFileExtensions "asp" "dll" "exe" "aspx"
cscript adsutil.vbs set W3Svc/Filters/Compression/Deflate/HcScriptFileExtensions "asp" "dll" "exe" "aspx"
The following lines will leave the default and add support for JavaScript file extension which is static content (default file extionsions for static content are .TXT, .HTM, .HTML):
cscript adsutil.vbs set W3Svc/Filters/Compression/GZip/HcFileExtensions "txt" "htm" "html" "js"
cscript adsutil.vbs set W3Svc/Filters/Compression/Deflate/HcFileExtensions "txt" "htm" "html" "js"
The following will set the compression level which is a range from 0 to 10 for dynamic content (default is 0 which requires the lowest amount of CPU - i prefer level 7)
cscript adsutil.vbs set W3Svc/Filters/Compression/GZip/HcDynamicCompressionLevel 7
cscript adsutil.vbs set W3Svc/Filters/Compression/Deflate/HcDynamicCompressionLevel 7
The following will set the compression level which is a range from 0 to 10 for static content (default is 10 - i prefer level 7)
cscript adsutil.vbs set W3Svc/Filters/Compression/GZip/HcOnDemandCompLevel 7
cscript adsutil.vbs set W3Svc/Filters/Compression/Deflate/HcOnDemandCompLevel 7
If you are concerned with older proxy servers that claim to support the HTTP 1.0 specification but may not support compression you may want to use the following to only support HTTP 1.1 specification - only needed if having issues (default is false):
cscript adsutil.vbs set W3Svc/Filters/Compression/Parameters/HcNoCompressionForHttp10 true
If you want to completely disable compression for requests that come through proxy servers - only needed if having issues (default is false):
cscript adsutil.vbs set W3Svc/Filters/Compression/Parameters/HcNoCompressionForProxies true

NOTE: After making these Metabase changes, you will need to restart IIS. Also, if you are using load balancers for your web servers, it may be preferable to offload GZip compression to them.

For more information on Using HTTP compression:
http://technet.microsoft.com/en-us/library/cc778828.aspx

For more information on enabling/disabling HTTP compression on an individual web site or web site folder basis:
http://technet.microsoft.com/en-us/library/cc782942.aspx

For more information on Using HTTP compression for Faster Downloads:
http://technet.microsoft.com/en-us/library/cc756725.aspx

For more information on Changes to Compression in IIS7
http://blogs.iis.net/ksingla/archive/2006/06/13/changes-to-compression-in-iis7.aspx

What are the basic performance counters that I should care about to measure the performance of my ASP.NET web site?

Reuben Frost — Wed, 21 Jan 2009 02:30:00 GMT

Review the ASP.NET Applications\Requests/Sec counter to determine how fast you are able to process work per second. Higher is better.
Revew the ASP.NET Applications\Request Execution Time counter to determine how fast a page takes to execute. Lower is better.
Review the ASP.NET Applications\Requests In Application Queue counter to determine if any requests are waiting at the application level. Lower is better.
Review the ASP.NET Applications\Errors Total/Sec counter to determine if you have a high rate off errors. If so, fix the errors and check this counter again. Lower is better.