Greetings, Apache developers! For my master's in CS, I'm doing some work in language extensions for so-called "performance programming". Basically, the idea is that performance properties, requirements, etc., are encoded as first-class semantic properties of the program via a series of C-like language extensions.
We'd really like to use Apache to demonstrate some of the capabilities of these language extensions. However, we're not very familiar with some of the down-and-dirty performance issues that might be exposed in the user-code itself. We've read a number of papers that do in-depth analysis of Apache (in particular, "Measurement, Analysis and Performance Improvement of the Apache Web Server" by Yiming Hu et al.), but most of the things they suggest to improve the overhead of application-level tasks (as opposed to kernel and network layer overhead) revolve around implementation-heavy mechanisms such as mmaping large files, caching file states, DNS queries, URI parse results, etc. These sorts of "extra/better mechanisms for XYZ" aren't really the kind of thing that we're looking for. So, I wanted to ask the Apache development community the following question, and I do realize that it's somewhat vague. If you could encode some performance requirements and/or use some performance metrics at the language-level, what ways might you use this ability in the Apache application code itself? Here are a few examples of the kind of things that we've been able to think of: * Monitor memory cache (i.e. number of L1/L2 misses) behavior over a particular region of source code. * Invoke some adaptive behavior (assuming that there are some runtime "knobs" in Apache that can be used to affect such adaptation) when some "performance assertion" is violated. One example of this is tweaking some runtime parameters when server throughput drops below some expected value. * Trigger more in-depth performance analysis when some "high-level" performance assertion is violated. What we have in mind here is something along the following lines: server throughput drops below some minimally acceptable threshold, and we want to dynamically enable instrumentation that was previously disabled (for example, start tracking cache behavior, I/O overhead, network interface overhead, etc.), and then later report on these values. The intent here is to provide correlative data to help performance tuners narrow down the search space quickly when poor performance is encountered. Anyway, if anyone has comments on the above or might be willing to posit other ways in which such a language capability could help in detecting performance bottlenecks and/or helping to guarantee some minimally acceptable runtime behavior across platforms, please let me know. The primary reason for posting to this list is that we're not very familiar with the Apache code itself, and don't have the much-needed intuitive grasp about where such language constructs may be of use to Apache application developers / performance tuners. I'm more than willing to exchange dialogue about this either on the list or via private e-mail. Thanks very much for your time, Joel -- Joel Stanley * [EMAIL PROTECTED]
