httpd-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Joel Stanley <jstan...@cs.uiuc.edu>
Subject Performance instrumentation of Apache
Date Sat, 21 Jun 2003 21:33:33 GMT
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 * jstanley@cs.uiuc.edu



Mime
View raw message