There is common problem with these types of requests and that is serialisation.  IIS will serialise all requests to the same ASP.NET session for pages that have read /write access to the Session state.

The example blow shows an ASP.NET MVC 3 application which performs 5 Ajax requests simultaneously. 1 to the SlowPost() action and 4 to the FastPost() action.

SlowPost() – performs a thread sleep for 8 seconds and returns
FastPost()  – returns instantly

As you can see from the screen shot taken from HttpWatch all requests take about 8 seconds to complete this is because the 4 FastPost() requests were queued behind the initial SlowPost() request that was made.

There are several options available to us to work around this serialisation behaviour. The first is to disable or make read-only the session state for a particular page or controller. This allows all requests that don’t require write access to the session state to run asynchronously.

To make an MVC controller’s access to the session state read-only add the following to the top of the controller class.

[SessionState(SessionStateBehavior.ReadOnly)] – See SessionStateBehaviour for more information.

As you can see from the HttpWatch screen shot below by adding the ReadOnly option to the controller all the FastPost() actions completed instantly and do not block waiting for the SlowPost() action to complete.

But what if your actions require read/write access to the session state?

The SessionStateBehaviour.ReadOnly option does not prevent you writing to the session state, it just causes the ASP.NET engine to apply a read-only lock to the request. If multiple requests write to the session state when in read-only mode corruption can occur as updates can happen at the same time from different requests.

To work around this I have developed an asynchronous session state class which gives the developer the choice of when to lock and unlock access to the session state per request.

Often for requests that take some time to execute, access to the session state is not required all the time.

For example a request may read a variable from the session state, perform a database query and then write something back to the session state. The only time we need to block access to the session state is during the initial read and then the write at the end, not during the database query.

ASyncSession.cs provides access to the Application state and Session state objects but also has a Lock() and Unlock() method to control access from multiple requests.

To use ASyncSession in your application code simply do the following.

- Initialise the code in your global.asax file

- Use the ASyncSession object in your ActionMethods

The below example Locks the session, reads an integer from the SessionState, increments it, puts it back and Unlocks the session.

Download my example MVC 3 application which demonstrates the use of the ASyncSession class.

Download

Download ASyncSession Example v1.00

SplitMon has been developed to solve the spanning issue with RDP 5.1 when remotely connecting to a Windows XP machine. As the RDP protocol within Windows XP has no concept of multi displays, only a single monitor on your client can be used. The /span switch in the RDP client gives you the option of spanning the session across multiple screens but this is still viewed as one large display and does not mimic the multi monitor display setup you have on your client.

The screen shots below show the display properties of a physical XP machine with 2 displays and an XP machine remotely connected using the /span option of the RDP client from a client with 2 displays.

 
Configuration

SplitMon runs as a Windows Service and can be installed and configured with the following command line options.

Example: To install SplitMon with 2 virtual displays of size 1280×768 which controls the Microsoft RDP and Citrix ICA clients use the following command line.

SplitMon.exe -install -mc 2 -mr1 0,0,1280,1024,0,0,1280,996 -mr2 1280,0,2560,1280,1280,0,2560,1024 -ip mstsc.exe,pn.exe,wfica32.exe,wfcrun32.exe -er

System Requirements

Client : Windows 7, Windows Vista, Windows XP
Server : Windows Server 2008 R2, Windows Server 2008, Windows Server 2003
 

Download

Download SplitMon v1.2

ThreadInfo details which process a thread belongs to, the processes base priority and the threads current running priority along with the percentage of CPU it consumed during the sample period.

Usage

Usage: ThreadInfo [-a][-v][-pid x][-r] [-t x][-admin]

 
System Requirements

Download

Download ThreadInfo v1.00

On a 32-bit Windows operating system, every process is allocated a 4Gb virtual address space. On a standard system configuration this is split into 2 equal parts.

0×00000000 – 0x7FFFFFF – 2Gb of user mode virtual address space applications can allocate for their own use.
0×80000000 – 0xFFFFFFFF – 2Gb of kernel mode virtual address space which contains the operating system image, device drivers, page frame umber (PFN) database, system page table entries (PTE’s), paged and nonpaged memory pools.

The user mode portion of the address space is unique to every running process giving every process up to 2Gb of memory to consume.

The kernel mode portion is shared and is mapped into every process. It’s for this reason people refer to the 32-bit 2Gb kernel memory limit as one of the main resource limitations in a Terminal Server / Citrix environment. Hundreds of users can be running thousands of processes all with their own 2Gb user mode address space, but all sharing the same 2Gb kernel mode space.

The /3GB boot.ini switch can alter the split giving each processes a 3Gb user mode virtual address space, limiting the shared kernel mode address space to 1Gb.

With 64-Bit Windows, virtual address space sizes have increased significantly. The current size of the user mode address space is 8192GB and system PTE, system cache, paged pool and nonpaged pool all having a 128GB allocation in kernel mode.

What is Fragmentation?

Fragmentation of any virtual address space occurs over time as more and more blocks of memory are allocated and freed. Memory allocations can only succeed in contiguous blocks of memory, for example if a 2mb allocation was requested it would be allocated from a complete contiguous 2mb block of virtual memory and not from a 1mb block at the start of the pool and a 1mb block at the end.

When a virtual address space is initially created all of it is available for allocation and requests are simply satisfied from the next available virtual address.

(Fig 1 – 3 memory allocations consuming 80mb of a 160mb virtual address space)

Fragmentation only begins to occur when memory allocations are freed.

(Fig 2 – 2 more blocks have been allocated and a 3rd 20mb block freed)

Fig 2 shows a single fragmentation of 20Mb. Blocks of free space in between allocations can be reused providing the requested allocation is small enough to fit. Figure 3 below shows the 20mb fragmentation reused by 2 additional 10mb allocations.

(Fig 3 – 2 additional 10mb allocations have reused the 20mb fragmentation)

So when does fragmentation become a problem?

(Fig 4 – 7 allocations consuming 80mb of the 160mb virtual address space)

When an address space becomes very fragmented it can cause larger memory allocations to fail as there is not enough contiguous space to satisfy the request. Take Figure 4 as an example, as the address space is fairly fragmented the largest single allocation possible is 30mb, anything larger would fail even though there is a total of 80mb available for allocation in the address space. 8 allocations of 10mb would succeed where as 2 allocations of 40mb would fail.

Is this a problem?

Typically a user would never have problems with fragmentation, in user mode a process would need to allocate close to the 2Gb limit (x86), before experiencing any problems, it also depends on how an application developer has written their application. For example a 10kb buffer is required to perform an operation which will be repeated several thousand times. Does the developer allocate the 10kb buffer once when the program starts, or does it get allocated and freed each time it is required. The more memory allocations an application performs the more fragmented the address space can become.

Memory allocation failures due to fragmentation are most often seen in the kernel mode address space specifically in the paged and nonpaged system memory pools. As these 2 pools are used by almost every component in all operations performed in kernel mode they can become exhausted and very fragmented especially under workloads such as Terminal Services. I have seen examples of users failing to connect to a Citrix XenApp server because the ICA remote display driver could not allocate 400Kb of paged pool memory even though there was more than 30mb available at the time.

What can be done?

Today there is not a lot that can be done to resolve this. When memory allocations succeed a pointer to the start of the memory block is returned, if Microsoft were to implement background memory defragmentation routines, the original returned memory pointers would change as a result. There are no notification methods available in Windows to signal processes that memory allocations have moved. Windows applications assume the address given after a successful memory allocation is valid and will not change until it is freed.

Paged and nonpaged pool are both regions of virtual memory located in the system part of address space. Kernel mode components such as device drivers use these pools to allocate system memory. These two pools are often one of the first resources to become exhausted in a Terminal Server environment, in fact with today’s hardware they are often the limiting factor to how many concurrent users can be logged on to a server.

There are several tools available to determine the size and available memory from each pool such as WinDbg and Poolmon. However it is not always possible to allocate all the available memory. See my article on virtual memory fragmentation to understand why it may not be possible to allocate all available virtual memory.

Configuration

The configuration dialog allows you to select either paged or nonpaged pool memory, the number of allocations to perform and the size of each allocation. Allocate Pool reports on the number of allocations which succeed and fail.

System Requirements

Download

Download AllocatePool v1.00

Select any window on your desktop and using your 2 registered hot keys you can force the window to be always on top or to follow the windows z-order.

Configuration

The configuration dialog allows you to select 2 system-wide host keys of your choice. When the dialog is closed the selected hot keys are immediately activated.

A notification area balloon tip provides details of the windows you make OnTop.

System Requirements

Client : Windows 7, Windows Vista, Windows XP

Server : Windows Server 2008 R2, Windows Server 2008, Windows Server 2003
 

Download

Download OnTop v1.00

There are 3 defined views. Normal mode which combines the spectrum analyser and play list, Compact mode which hides the play list and a Mini mode which displays a smaller spectrum analyser window. Although GMP has these 3 built-in views the window is completely resizable.

Spectrum Analyser

Band 0 contains frequencies 123.470Hz – 138.590Hz, band 1 contains frequencies 138.591Hz – 155.563Hz and so on. A semitone calculated in Hz is a twelfth root of two, or written in C as dbSemiTone = pow( 2.0f, ( 1.0f / 12.0f ) );.

The table below shows the frequency range of each band:-

Spectral Leakage is a term given to the effect of applying an FFT on an incomplete or offset sign wave; the calculated frequencies appear to span several frequency bands making it impossible to determine its exact frequency. Ideally when applying an FFT, the sample data will contain sign waves that start and end at 0. As this is not always the case a windowing algorithm is applied to the sample before it is put through an FFT. The effect of the windowing function reduces spectral leakage resulting in a more accurate frequency conversion.

GMP currently implements two different windowing functions. The left channel uses a 3-term Blackman-Harris window and the right channel uses a Hanning window.

System Requirements

Download

Download Graphical Media Player v1.00