It does seem to have helped.
Here's another tree I'd like to bark up
The 'Mud servers are in Reno and I'm in Gainesville, so the latency for connections is like 110ms on average. Mud also doesn't use KeepAlive connections, so I have to re-establish a new connection for every request (I'd say I average 30 per page view)
I understand why you're running the server this way; it's understandable because mud has ~1000 active users right now for example. Currently apache2.2 on Mud is using the prefork MPM. The prefork MPM is fine, but it spawns and kills an entire httpd process for
each request.

Given the number of requests per second the server must get, it means at any given time the server is using huge amounts of ram just to load enough httpd processes to handle the queue of requests.
However, the server is running on a SMP x86_64 based kernel and has multiple cores on which it can execute code, and apache2 has a
better threaded MPM called worker which is optimized for servers with high loads and multiple cores. It spawns a a few httpd processes (as many as needed, again) but with a listener thread and multiple server threads. This means that a single httpd process can handle multiple requests from different hosts, yet they all share the same memory inside the process. The savings in memory are enormous, and this allows a server that was bottlenecked by memory to begin to balance out and load the processors more. I've seen people who switch to the worker MPM who find that the memory cost-per-request is 10% or less of what it was with the prefork model. That is
huge memory savings.
Using the worker MPM would free up the server to handle more requests per second
and allow you to use conservative KeepAlive connections which will speed up page loads. All of which is going to mean a faster browsing experience for the user and a more efficient server.
There is a catch though (there always is). Although PHP itself can be compiled to operate in a threaded environment (I run the PHP5 apache2 module and apache2 with the worker MPM, so both operate threaded) various PHP modules are
not necessarily thread-safe. This means that running php as an apache module with the worker MPM can lead to segfaults or memory corruption inside the process. The
solution is to run PHP via FastCGI, which executes it in it's own process and keeps it out of the threaded environment. FastCGI is roughly as fast as the PHP apache module.
The end result would mean getting/installing the mod_fcgid package for apache (its in the fedora repos) and using the worker MPM httpd (set it in /etc/sysconfig/httpd, the httpd.worker comes with the fedora httpd package and exists at /usr/bin/httpd.worker), as well as compiling PHP5 with FastCGI support instead of the apache module and configuring Apache to invoke PHP via FastCGI rather than the apache php module.
It would be a good time to build the newest stable version of PHP anyways; building should be easy because PHP will tell you it's configure flags (just run phpinfo()). This would also be a good time to
add the flag --enable-inline-optimization when configuring php to build.
It would also be a good time to clean the unused modules out of the apache httpd.conf, which will further cut down on the size of each httpd process.
Once switched over to the worker MPM it would be prudent to double check a few configuration settings in httpd.conf (MaxClients, StartServers, etc) and enable KeepAlive with a 1s or 2s timeout and play around with MaxKeepAliveRequests in the unlikely even that the server can't keep up with the # of requests.
I have a hunch that the aforementioned changes will decrease the memory load on the web-server quite a bit, and by using KeepAlive connections the browsing experience should pick up a notch or two too. Yes Claudia, these are the server upgrades designed to make things
faster.
