Performance of ASPX Page when using Asynchronous Handlers

[Santa]

I am using Fritz Onion's "Asynchronous Pages" approach as mentioned in
the article http://msdn.microsoft.com/msdnmag/is...g/default.aspx
to increase the performance of my ASPX page.I am using the Custom
thread pool as given in the article's sample.

Implementation:
===============
In AsyncPage.aspx I inhereted AsyncPage class instead of
System.Web.UI.Page.
SyncPage.aspx is like any other Web page which inherits
System.Web.UI.Page.

Problem/Issue:
===============
When I run Application Center test (ACT) on two different environments
I am getting following test results.
Environment 1:
---------------
ACT client is running on Windows XP and Web server(where ASPX pages
are hosted) is running on Windows 2003 advanced server.
ACT is running for 5 minutes with 100 simultanious browser
connections.
Results on Environment 1:
--------------------------
AsyncPage.aspx page is processing a total of 7500 (approx.)requests.
SyncPage.aspx page is processing a total of 2500 (approx.)requests.
THESE ARE THE EXPECTED RESULTS.EVERYTHING IS WORKING AS EXPECTED.

Environment 2:
---------------
ACT client is running on Windows XP and Web server(where ASPX pages
are hosted) is running on Windows 2003 server/Windows 2000 Server.
ACT is running for 5 minutes with 100 simultanious browser
connections.
Results on Environment 2:
--------------------------
AsyncPage.aspx page is processing a total of 7500 (approx.)requests.
SyncPage.aspx page is processing a total of 7500 (approx.)requests.

IAM NOT ABLE TO RESOLVE THE ISSUE IN ENVIRONMENT 2.WHY BOTH THE PAGES
ARE ABLE TO PROCESS APPROXIMATELY SAME NUMBER OF REQUESTS?IS THERE ANY
TYPE OF CACHING ON CLIENT SIDE OR SERVER SIDE? PLEASE
SUGGEST..............

AsyncPage.aspx Code:
=======================
public Class AsyncPage : AsyncPage
{
private void Page_Load(object sender, System.EventArgs e)
{
System.Threading.Thread.Sleep(3000);
Response.Write("This is Async Page after 3 seconds sleep");
}
}
SyncPage.aspx Code:
=====================
public Class SyncPage : System.Web.UI.Page
{
private void Page_Load(object sender, System.EventArgs e)
{
System.Threading.Thread.Sleep(3000);
Response.Write("This is Sync Page after 3 seconds sleep");
}
}
ASyncPage class Code:
=====================
public class AsyncPage : Page, IHttpAsyncHandler
{
static protected DevelopMentor.ThreadPool _threadPool;

static AsyncPage()
{
_threadPool = new DevelopMentor.ThreadPool(2, 25, "AsyncPool");
_threadPool.PropogateCallContext = true;
_threadPool.PropogateThreadPrincipal = true;
_threadPool.PropogateHttpContext = true;
_threadPool.Start();
}

public new void ProcessRequest(HttpContext ctx)
{
// not used
}

public new bool IsReusable
{
get { return false;}
}

public IAsyncResult BeginProcessRequest(HttpContext ctx,
AsyncCallback cb, object obj)
{
AsyncRequestState reqState = new AsyncRequestState(ctx, cb, obj);
_threadPool.PostRequest(new
DevelopMentor.WorkRequestDelegate(ProcessRequest), reqState);

return reqState;
}

public void EndProcessRequest(IAsyncResult ar)
{
}

void ProcessRequest(object state, DateTime requestTime)
{
AsyncRequestState reqState = state as AsyncRequestState;

// Synchronously call base class Page.ProcessRequest
// as we are now on a thread pool thread. Once complete,
// call CompleteRequest to finish
base.ProcessRequest(reqState._ctx);

// tell asp.net we are finished processing this request
reqState.CompleteRequest();
}

}

class AsyncRequestState : IAsyncResult
{
public AsyncRequestState(HttpContext ctx, AsyncCallback cb,
object extraData )
{
_ctx = ctx;
_cb = cb;
_extraData = extraData;
}

internal HttpContext _ctx;
internal AsyncCallback _cb;
internal object _extraData;
private bool _isCompleted = false;
private ManualResetEvent _callCompleteEvent = null;

internal void CompleteRequest()
{
_isCompleted = true;
lock (this)
{
if (_callCompleteEvent != null)
_callCompleteEvent.Set();
}
// if a callback was registered, invoke it now
if (_cb != null)
_cb(this);
}

// IAsyncResult
//
public object AsyncState { get { return(_extraData); } }
public bool CompletedSynchronously { get { return(false); } }
public bool IsCompleted { get { return(_isCompleted); } }
public WaitHandle AsyncWaitHandle
{
get
{
lock( this )
{
if( _callCompleteEvent == null )
_callCompleteEvent = new ManualResetEvent(false);

return _callCompleteEvent;
}
}
}
}
====================== END OF
POST==============================================