Hi James,

The purpose of a web server is to server pages.  Studies indicate that if a
user doesn’t get a response back quickly (at most 3 seconds); they lose
interest and will go someplace else.  So you really want your web servers to
focus on serving pages to keep your users coming back.  As people add more
web applications and web services, the server CPU(s) are busy with
non-web-based work.  You can continue to add hardware to your web farms, but
for some companies that isn’t an option.  The other thing to consider is how
many machines you really need; you certainly want to have enough processing
power to accommodate peak times, but those machines may be idle far more than
you want them to be.  A viable solution to this problem is a compute grid.

We have several customers who have put a compute grid behind their web
servers to improve performance.  For example, one of our customers is an
event company and they create a PDF file on-the-fly
(http://www.digipede.net/products/case_pacevents.html.)  When they had this
functionality on the web server, the web server’s response time was sluggish
during peak times.  Because of the flexibility of a compute grid, the company
was able to create their compute grid using existing machines (that weren’t
in the server room) and move the PDF creation there.  Read the case study
because it explains it much better than I am.

As for short running tasks vs. long running tasks.  Short running tasks
aren’t a problem unless you get a lot of them.  Individually the short tasks
would finish quickly, but when they come in a swarm the processor(s) can
quickly get pegged.  Long running tasks become a problem much sooner.  I
wouldn’t say that you’re off-base because so much of the literature on grid
computing talks about these long running tasks.  But parallelizable work is
parallelizable work, in my mind a short running task is usually best suited
for a thread, unless you are expecting to get a lot of them.  Anytime you are
building a concurrent system you need to do performance tests.  As I see it
.NET developers currently have two concurrency tools at their disposal:
threads and grid objects.  Testing will tell you whether the parallelizable
work can be done on the main machine (using threads) or if your system
performs and scales better by moving that work onto the grid (grid objects.)

I hope that answers your questions and if I missed something please let me
know...it’s after 2am right now.  :-)

Kim Greenlee