home *** CD-ROM | disk | FTP | other *** search
/ PC World 2003 May / PCWorld_2003-05_cd.bin / Komunik / apache / apache_2.0.45-win32-x86-no_ssl.msi / Data.Cab / F232768_perftuning.html.en < prev    next >
Extensible Markup Language  |  2003-03-30  |  50KB  |  998 lines

  1. <?xml version="1.0" encoding="ISO-8859-1"?>
  2. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
  3. <html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en"><head><!--
  4.         XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  5.               This file is generated from xml source: DO NOT EDIT
  6.         XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  7.       -->
  8. <title>Apache Performance Tuning - Apache HTTP Server</title>
  9. <link href="../style/css/manual.css" rel="stylesheet" media="all" type="text/css" title="Main stylesheet" />
  10. <link href="../style/css/manual-loose-100pc.css" rel="alternate stylesheet" media="all" type="text/css" title="No Sidebar - Default font size" />
  11. <link href="../style/css/manual-print.css" rel="stylesheet" media="print" type="text/css" />
  12. <link href="../images/favicon.ico" rel="shortcut icon" /></head>
  13. <body id="manual-page"><div id="page-header">
  14. <p class="menu"><a href="../mod/">Modules</a> | <a href="../mod/directives.html">Directives</a> | <a href="../faq/">FAQ</a> | <a href="../glossary.html">Glossary</a> | <a href="../sitemap.html">Sitemap</a></p>
  15. <p class="apache">Apache HTTP Server Version 2.0</p>
  16. <img alt="" src="../images/feather.gif" /></div>
  17. <div class="up"><a href="./"><img title="<-" alt="<-" src="../images/left.gif" /></a></div>
  18. <div id="path">
  19. <a href="http://www.apache.org/">Apache</a> > <a href="http://httpd.apache.org/">HTTP Server</a> > <a href="http://httpd.apache.org/docs-project/">Documentation</a> > <a href="../">Version 2.0</a> > <a href="./">Miscellaneous Documentation</a></div><div id="page-content"><div id="preamble"><h1>Apache Performance Tuning</h1>
  20.  
  21.     <div class="warning"><h3>Warning:</h3>
  22.       <p>This document has not been fully updated
  23.       to take into account changes made in the 2.0 version of the
  24.       Apache HTTP Server. Some of the information may still be
  25.       relevant, but please use it with care.</p>
  26.     </div>
  27.  
  28.     <p>Orignally written by Dean Gaudet.</p>
  29.  
  30.     <p>Apache 2.0 is a general-purpose webserver, designed to
  31.     provide a balance of flexibility, portability, and performance.
  32.     Although it has not been designed specifically to set benchmark
  33.     records, Apache 2.0 is capable of high performance in many
  34.     real-world situations.</p>
  35.  
  36.     <p>Compared to Apache 1.3, release 2.0 contains many additional
  37.     optimizations to increase throughput and scalability. Most of
  38.     these improvements are enabled by default. However, there are
  39.     compile-time and run-time configuration choices that can
  40.     significantly affect performance. This document describes the
  41.     options that a server administrator can configure to tune the
  42.     performance of an Apache 2.0 installation. Some of these
  43.     configuration options enable the httpd to better take advantage
  44.     of the capabilities of the hardware and OS, while others allow
  45.     the administrator to trade functionality for speed.</p>
  46.  
  47.   </div>
  48. <div id="quickview"><ul id="toc"><li><img alt="" src="../images/down.gif" /> <a href="#hardware">Hardware and Operating System Issues</a></li>
  49. <li><img alt="" src="../images/down.gif" /> <a href="#runtime">Run-Time Configuration Issues</a></li>
  50. <li><img alt="" src="../images/down.gif" /> <a href="#compiletime">Compile-Time Configuration Issues</a></li>
  51. <li><img alt="" src="../images/down.gif" /> <a href="#trace">Appendix: Detailed Analysis of a Trace</a></li>
  52. </ul></div>
  53. <div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
  54. <div class="section">
  55. <h2><a name="hardware" id="hardware">Hardware and Operating System Issues</a></h2>
  56.  
  57.     
  58.  
  59.     <p>The single biggest hardware issue affecting webserver
  60.     performance is RAM. A webserver should never ever have to swap,
  61.     as swapping increases the latency of each request beyond a point
  62.     that users consider "fast enough". This causes users to hit
  63.     stop and reload, further increasing the load. You can, and
  64.     should, control the <code class="directive"><a href="../mod/mpm_common.html#maxclients">MaxClients</a></code> setting so that your server
  65.     does not spawn so many children it starts swapping. This procedure
  66.     for doing this is simple: determine the size of your average Apache
  67.     process, by looking at your process list via a tool such as
  68.     <code>top</code>, and divide this into your total available memory,
  69.     leaving some room for other processes.</p>
  70.  
  71.     <p>Beyond that the rest is mundane: get a fast enough CPU, a
  72.     fast enough network card, and fast enough disks, where "fast
  73.     enough" is something that needs to be determined by
  74.     experimentation.</p>
  75.  
  76.     <p>Operating system choice is largely a matter of local
  77.     concerns. But some guidelines that have proven generally
  78.     useful are:</p>
  79.  
  80.     <ul>
  81.       <li>
  82.         <p>Run the latest stable release and patchlevel of the
  83.         operating system that you choose. Many OS suppliers have
  84.         introduced significant performance improvements to their
  85.         TCP stacks and thread libraries in recent years.</p>
  86.       </li>
  87.  
  88.       <li>
  89.         <p>If your OS supports a <code>sendfile(2)</code> system
  90.         call, make sure you install the release and/or patches
  91.         needed to enable it. (With Linux, for example, this means
  92.         using Linux 2.4 or later. For early releases of Solaris 8,
  93.         you may need to apply a patch.) On systems where it is
  94.         available, <code>sendfile</code> enables Apache 2 to deliver
  95.         static content faster and with lower CPU utilization.</p>
  96.       </li>
  97.     </ul>
  98.  
  99.   </div><div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
  100. <div class="section">
  101. <h2><a name="runtime" id="runtime">Run-Time Configuration Issues</a></h2>
  102.  
  103.     
  104.  
  105.     <table class="related"><tr><th>Related Modules</th><th>Related Directives</th></tr><tr><td><ul><li><code class="module"><a href="../mod/mod_dir.html">mod_dir</a></code></li><li><code class="module"><a href="../mod/mpm_common.html">mpm_common</a></code></li><li><code class="module"><a href="../mod/mod_status.html">mod_status</a></code></li></ul></td><td><ul><li><code class="directive"><a href="../mod/core.html#allowoverride">AllowOverride</a></code></li><li><code class="directive"><a href="../mod/mod_dir.html#directoryindex">DirectoryIndex</a></code></li><li><code class="directive"><a href="../mod/core.html#hostnamelookups">HostnameLookups</a></code></li><li><code class="directive"><a href="../mod/core.html#enablemmap">EnableMMAP</a></code></li><li><code class="directive"><a href="../mod/core.html#enablesendfile">EnableSendfile</a></code></li><li><code class="directive"><a href="../mod/core.html#keepalivetimeout">KeepAliveTimeout</a></code></li><li><code class="directive"><a href="../mod/prefork.html#maxspareservers">MaxSpareServers</a></code></li><li><code class="directive"><a href="../mod/prefork.html#minspareservers">MinSpareServers</a></code></li><li><code class="directive"><a href="../mod/core.html#options">Options</a></code></li><li><code class="directive"><a href="../mod/mpm_common.html#startservers">StartServers</a></code></li></ul></td></tr></table>
  106.  
  107.     <h3><a name="dns" id="dns">HostnameLookups and other DNS considerations</a></h3>
  108.  
  109.       
  110.  
  111.       <p>Prior to Apache 1.3, <code class="directive"><a href="../mod/core.html#hostnamelookups">HostnameLookups</a></code> defaulted to <code>On</code>.
  112.       This adds latency to every request because it requires a
  113.       DNS lookup to complete before the request is finished. In
  114.       Apache 1.3 this setting defaults to <code>Off</code>. If you need
  115.       to have addresses in your log files resolved to hostnames, use the
  116.       <a href="../programs/logresolve.html"><code>logresolve</code></a>
  117.       program that comes with Apache, on one of the numerous log
  118.       reporting packages which are available.</p>
  119.  
  120.       <p>It is recommended that you do this sort of postprocessing of
  121.       your log files on some machine other than the production web
  122.       server machine, in order that this activity not adversely affect
  123.       server performance.</p>
  124.  
  125.       <p>If you use any <code><code class="directive"><a href="../mod/access.html#allow">Allow</a></code> 
  126.       from domain</code> or <code><code class="directive"><a href="../mod/access.html#deny">Deny</a></code> from domain</code> 
  127.       directives (i.e., using a hostname, or a domain name, rather than
  128.       an IP address) then you will pay for
  129.       a double reverse DNS lookup (a reverse, followed by a forward
  130.       to make sure that the reverse is not being spoofed). For best
  131.       performence, therefore, use IP addresses, rather than names, when
  132.       using these directives, if possible.</p>
  133.  
  134.       <p>Note that it's possible to scope the directives, such as
  135.       within a <code><Location /server-status></code> section.
  136.       In this case the DNS lookups are only performed on requests
  137.       matching the criteria. Here's an example which disables lookups
  138.       except for <code>.html</code> and <code>.cgi</code> files:</p>
  139.  
  140.       <div class="example"><p><code>
  141.         HostnameLookups off<br />
  142.         <Files ~ "\.(html|cgi)$"><br />
  143.         <span class="indent">
  144.           HostnameLookups on<br />
  145.         </span>
  146.         </Files>
  147.       </code></p></div>
  148.  
  149.       <p>But even still, if you just need DNS names in some CGIs you
  150.       could consider doing the <code>gethostbyname</code> call in the
  151.       specific CGIs that need it.</p>
  152.  
  153.     
  154.  
  155.     <h3><a name="symlinks" id="symlinks">FollowSymLinks and SymLinksIfOwnerMatch</a></h3>
  156.  
  157.       
  158.  
  159.       <p>Wherever in your URL-space you do not have an <code>Options
  160.       FollowSymLinks</code>, or you do have an <code>Options
  161.       SymLinksIfOwnerMatch</code> Apache will have to issue extra
  162.       system calls to check up on symlinks. One extra call per
  163.       filename component. For example, if you had:</p>
  164.  
  165.       <div class="example"><p><code>
  166.         DocumentRoot /www/htdocs<br />
  167.         <Directory /><br />
  168.         <span class="indent">
  169.           Options SymLinksIfOwnerMatch<br />
  170.         </span>
  171.         </Directory>
  172.       </code></p></div>
  173.  
  174.       <p>and a request is made for the URI <code>/index.html</code>.
  175.       Then Apache will perform <code>lstat(2)</code> on
  176.       <code>/www</code>, <code>/www/htdocs</code>, and
  177.       <code>/www/htdocs/index.html</code>. The results of these
  178.       <code>lstats</code> are never cached, so they will occur on
  179.       every single request. If you really desire the symlinks
  180.       security checking you can do something like this:</p>
  181.  
  182.       <div class="example"><p><code>
  183.         DocumentRoot /www/htdocs<br />
  184.         <Directory /><br />
  185.         <span class="indent">
  186.           Options FollowSymLinks<br />
  187.         </span>
  188.         </Directory><br />
  189.         <br />
  190.         <Directory /www/htdocs><br />
  191.         <span class="indent">
  192.           Options -FollowSymLinks +SymLinksIfOwnerMatch<br />
  193.         </span>
  194.         </Directory>
  195.       </code></p></div>
  196.  
  197.       <p>This at least avoids the extra checks for the
  198.       <code class="directive"><a href="../mod/core.html#documentroot">DocumentRoot</a></code> path.
  199.       Note that you'll need to add similar sections if you
  200.       have any <code class="directive"><a href="../mod/mod_alias.html#alias">Alias</a></code> or
  201.       <code class="directive"><a href="../mod/mod_rewrite.html#rewriterule">RewriteRule</a></code> paths
  202.       outside of your document root. For highest performance,
  203.       and no symlink protection, set <code>FollowSymLinks</code>
  204.       everywhere, and never set <code>SymLinksIfOwnerMatch</code>.</p>
  205.  
  206.     
  207.  
  208.     <h3><a name="htacess" id="htacess">AllowOverride</a></h3>
  209.  
  210.       
  211.  
  212.       <p>Wherever in your URL-space you allow overrides (typically
  213.       <code>.htaccess</code> files) Apache will attempt to open
  214.       <code>.htaccess</code> for each filename component. For
  215.       example,</p>
  216.  
  217.       <div class="example"><p><code>
  218.         DocumentRoot /www/htdocs<br />
  219.         <Directory /><br />
  220.         <span class="indent">
  221.           AllowOverride all<br />
  222.         </span>
  223.         </Directory>
  224.       </code></p></div>
  225.  
  226.       <p>and a request is made for the URI <code>/index.html</code>.
  227.       Then Apache will attempt to open <code>/.htaccess</code>,
  228.       <code>/www/.htaccess</code>, and
  229.       <code>/www/htdocs/.htaccess</code>. The solutions are similar
  230.       to the previous case of <code>Options FollowSymLinks</code>.
  231.       For highest performance use <code>AllowOverride None</code>
  232.       everywhere in your filesystem.</p>
  233.  
  234.     
  235.  
  236.     <h3><a name="negotiation" id="negotiation">Negotiation</a></h3>
  237.  
  238.       
  239.  
  240.       <p>If at all possible, avoid content-negotiation if you're
  241.       really interested in every last ounce of performance. In
  242.       practice the benefits of negotiation outweigh the performance
  243.       penalties. There's one case where you can speed up the server.
  244.       Instead of using a wildcard such as:</p>
  245.  
  246.       <div class="example"><p><code>
  247.         DirectoryIndex index
  248.       </code></p></div>
  249.  
  250.       <p>Use a complete list of options:</p>
  251.  
  252.       <div class="example"><p><code>
  253.         DirectoryIndex index.cgi index.pl index.shtml index.html
  254.       </code></p></div>
  255.  
  256.       <p>where you list the most common choice first.</p>
  257.  
  258.       <p>Also note that explicitly creating a <code>type-map</code>
  259.       file provides better performance than using
  260.       <code>MultiViews</code>, as the necessary information can be
  261.       determined by reading this single file, rather than having to
  262.       scan the directory for files.</p>
  263.  
  264.     <p>If your site needs content negotiation consider using
  265.     <code>type-map</code> files, rather than the <code>Options
  266.     MultiViews</code> directive to accomplish the negotiation. See the
  267.     <a href="../content-negotiation.html">Content Negotiation</a>
  268.     documentation for a full discussion of the methods of negotiation,
  269.     and instructions for creating <code>type-map</code> files.</p>
  270.  
  271.     
  272.  
  273.     <h3>Memory-mapping</h3>
  274.  
  275.       
  276.  
  277.       <p>In situations where Apache 2.0 needs to look at the contents
  278.       of a file being delivered--for example, when doing server-side-include
  279.       processing--it normally memory-maps the file if the OS supports
  280.       some form of <code>mmap(2)</code>.</p>
  281.  
  282.       <p>On some platforms, this memory-mapping improves performance.
  283.       However, there are cases where memory-mapping can hurt the performance
  284.       or even the stability of the httpd:</p>
  285.  
  286.       <ul>
  287.         <li>
  288.           <p>On some operating systems, <code>mmap</code> does not scale
  289.           as well as <code>read(2)</code> when the number of CPUs increases.
  290.           On multiprocessor Solaris servers, for example, Apache 2.0 sometimes
  291.           delivers server-parsed files faster when <code>mmap</code> is disabled.</p>
  292.         </li>
  293.  
  294.         <li>
  295.           <p>If you memory-map a file located on an NFS-mounted filesystem
  296.           and a process on another NFS client machine deletes or truncates
  297.           the file, your process may get a bus error the next time it tries
  298.           to access the mapped file content.</p>
  299.         </li>
  300.       </ul>
  301.  
  302.       <p>For installations where either of these factors applies, you
  303.       should use <code>EnableMMAP off</code> to disable the memory-mapping
  304.       of delivered files. (Note: This directive can be overridden on
  305.       a per-directory basis.)</p>
  306.  
  307.     
  308.  
  309.     <h3>Sendfile</h3>
  310.  
  311.       
  312.  
  313.       <p>In situations where Apache 2.0 can ignore the contents of the file
  314.       to be delivered -- for example, when serving static file content -- 
  315.       it normally uses the kernel sendfile support the file if the OS 
  316.       supports the <code>sendfile(2)</code> operation.</p>
  317.  
  318.       <p>On most platforms, using sendfile improves performance by eliminating
  319.       separate read and send mechanics.  However, there are cases where using
  320.       sendfile can harm the stability of the httpd:</p>
  321.  
  322.       <ul>
  323.         <li>
  324.           <p>Some platforms may have broken sendfile support that the build
  325.           system did not detect, especially if the binaries were built on
  326.           another box and moved to such a machine with broken sendfile support.</p>
  327.         </li>
  328.         <li>
  329.           <p>With an NFS-mounted files, the kernel may be unable 
  330.           to reliably serve the network file through it's own cache.</p>
  331.         </li>
  332.       </ul>
  333.  
  334.       <p>For installations where either of these factors applies, you
  335.       should use <code>EnableSendfile off</code> to disable sendfile
  336.       delivery of file contents. (Note: This directive can be overridden 
  337.       on a per-directory basis.)</p>
  338.  
  339.     
  340.  
  341.     <h3><a name="process" id="process">Process Creation</a></h3>
  342.  
  343.       
  344.  
  345.       <p>Prior to Apache 1.3 the <code class="directive"><a href="../mod/prefork.html#minspareservers">MinSpareServers</a></code>, <code class="directive"><a href="../mod/prefork.html#maxspareservers">MaxSpareServers</a></code>, and <code class="directive"><a href="../mod/mpm_common.html#startservers">StartServers</a></code> settings all had drastic effects on
  346.       benchmark results. In particular, Apache required a "ramp-up"
  347.       period in order to reach a number of children sufficient to serve
  348.       the load being applied. After the initial spawning of
  349.       <code class="directive"><a href="../mod/mpm_common.html#startservers">StartServers</a></code> children,
  350.       only one child per second would be created to satisfy the
  351.       <code class="directive"><a href="../mod/prefork.html#minspareservers">MinSpareServers</a></code>
  352.       setting. So a server being accessed by 100 simultaneous
  353.       clients, using the default <code class="directive"><a href="../mod/mpm_common.html#startservers">StartServers</a></code> of <code>5</code> would take on
  354.       the order 95 seconds to spawn enough children to handle
  355.       the load. This works fine in practice on real-life servers,
  356.       because they aren't restarted frequently. But does really
  357.       poorly on benchmarks which might only run for ten minutes.</p>
  358.  
  359.       <p>The one-per-second rule was implemented in an effort to
  360.       avoid swamping the machine with the startup of new children. If
  361.       the machine is busy spawning children it can't service
  362.       requests. But it has such a drastic effect on the perceived
  363.       performance of Apache that it had to be replaced. As of Apache
  364.       1.3, the code will relax the one-per-second rule. It will spawn
  365.       one, wait a second, then spawn two, wait a second, then spawn
  366.       four, and it will continue exponentially until it is spawning
  367.       32 children per second. It will stop whenever it satisfies the
  368.       <code class="directive"><a href="../mod/prefork.html#minspareservers">MinSpareServers</a></code>
  369.       setting.</p>
  370.  
  371.       <p>This appears to be responsive enough that it's almost
  372.       unnecessary to twiddle the <code class="directive"><a href="../mod/prefork.html#minspareservers">MinSpareServers</a></code>, <code class="directive"><a href="../mod/prefork.html#maxspareservers">MaxSpareServers</a></code> and <code class="directive"><a href="../mod/mpm_common.html#startservers">StartServers</a></code> knobs. When more than 4 children are
  373.       spawned per second, a message will be emitted to the
  374.       <code class="directive"><a href="../mod/core.html#errorlog">ErrorLog</a></code>. If you
  375.       see a lot of these errors then consider tuning these settings.
  376.       Use the <code class="module"><a href="../mod/mod_status.html">mod_status</a></code> output as a guide.</p>
  377.  
  378.     <p>Related to process creation is process death induced by the
  379.     <code class="directive"><a href="../mod/mpm_common.html#maxrequestsperchild">MaxRequestsPerChild</a></code>
  380.     setting. By default this is <code>0</code>,
  381.     which means that there is no limit to the number of requests
  382.     handled per child. If your configuration currently has this set
  383.     to some very low number, such as <code>30</code>, you may want to bump this
  384.     up significantly. If you are running SunOS or an old version of
  385.     Solaris, limit this to <code>10000</code> or so because of memory leaks.</p>
  386.  
  387.     <p>When keep-alives are in use, children will be kept busy
  388.     doing nothing waiting for more requests on the already open
  389.     connection. The default <code class="directive"><a href="../mod/core.html#keepalivetimeout">KeepAliveTimeout</a></code> of <code>15</code>
  390.     seconds attempts to minimize this effect. The tradeoff here is
  391.     between network bandwidth and server resources. In no event
  392.     should you raise this above about <code>60</code> seconds, as <a href="http://www.research.digital.com/wrl/techreports/abstracts/95.4.html">
  393.     most of the benefits are lost</a>.</p>
  394.  
  395.     
  396.  
  397.   </div><div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
  398. <div class="section">
  399. <h2><a name="compiletime" id="compiletime">Compile-Time Configuration Issues</a></h2>
  400.  
  401.     
  402.  
  403.     <h3>Choosing an MPM</h3>
  404.  
  405.       
  406.  
  407.       <p>Apache 2.x supports pluggable concurrency models, called
  408.       <a href="../mpm.html">Multi-Processing Modules</a> (MPMs).
  409.       When building Apache, you must choose an MPM to use.  There
  410.       are platform-specific MPMs for some platforms:
  411.       <code class="module"><a href="../mod/beos.html">beos</a></code>, <code class="module"><a href="../mod/mpm_netware.html">mpm_netware</a></code>,
  412.       <code class="module"><a href="../mod/mpmt_os2.html">mpmt_os2</a></code>, and <code class="module"><a href="../mod/mpm_winnt.html">mpm_winnt</a></code>.  For
  413.       general Unix-type systems, there are several MPMs from which
  414.       to choose.  The choice of MPM can affect the speed and scalability
  415.       of the httpd:</p>
  416.  
  417.       <ul>
  418.  
  419.         <li>The <code class="module"><a href="../mod/worker.html">worker</a></code> MPM uses multiple child
  420.         processes with many threads each.  Each thread handles
  421.         one connection at a time.  Worker generally is a good
  422.         choice for high-traffic servers because it has a smaller
  423.         memory footprint than the prefork MPM.</li>
  424.  
  425.         <li>The <code class="module"><a href="../mod/prefork.html">prefork</a></code> MPM uses multiple child
  426.         processes with one thread each.  Each process handles
  427.         one connection at a time.  On many systems, prefork is
  428.         comparable in speed to worker, but it uses more memory.
  429.         Prefork's threadless design has advantages over worker
  430.         in some situations: it can be used with non-thread-safe
  431.         third-party modules, and it is easier to debug on platforms
  432.         with poor thread debugging support.</li>
  433.  
  434.       </ul>
  435.  
  436.       <p>For more information on these and other MPMs, please
  437.       see the MPM <a href="../mpm.html">documentation</a>.</p>
  438.  
  439.     
  440.  
  441.     <h3><a name="modules" id="modules">Modules</a></h3>
  442.  
  443.         
  444.  
  445.         <p>Since memory usage is such an important consideration in
  446.         performance, you should attempt to eliminate modules that youare
  447.         not actually using. If you have built the modules as <a href="../dso.html">DSOs</a>, eliminating modules is a simple
  448.         matter of commenting out the associated <code class="directive"><a href="../mod/so.html#loadmodule">LoadModule</a></code> directive for that module.
  449.         This allows you to experiment with removing modules, and seeing
  450.         if your site still functions in their absense.</p>
  451.  
  452.         <p>If, on the other hand, you have modules statically linked
  453.         into your Apache binary, you will need to recompile Apache in
  454.         order to remove unwanted modules.</p>
  455.  
  456.         <p>An associated question that arises here is, of course, what
  457.         modules you need, and which ones you don't. The answer here
  458.         will, of course, vary from one web site to another. However, the
  459.         <em>minimal</em> list of modules which you can get by with tends
  460.         to include <code class="module"><a href="../mod/mod_mime.html">mod_mime</a></code>, <code class="module"><a href="../mod/mod_dir.html">mod_dir</a></code>,
  461.         and <code class="module"><a href="../mod/mod_log_config.html">mod_log_config</a></code>. <code>mod_log_config</code> is,
  462.         of course, optional, as you can run a web site without log
  463.         files. This is, however, not recommended.</p>
  464.  
  465.     
  466.  
  467.     <h3>mod_status and ExtendedStatus On</h3>
  468.  
  469.       
  470.  
  471.       <p>If you include <code class="module"><a href="../mod/mod_status.html">mod_status</a></code> and you also set
  472.       <code>ExtendedStatus On</code> when building and running
  473.       Apache, then on every request Apache will perform two calls to
  474.       <code>gettimeofday(2)</code> (or <code>times(2)</code>
  475.       depending on your operating system), and (pre-1.3) several
  476.       extra calls to <code>time(2)</code>. This is all done so that
  477.       the status report contains timing indications. For highest
  478.       performance, set <code>ExtendedStatus off</code> (which is the
  479.       default).</p>
  480.  
  481.     
  482.  
  483.     <h3>accept Serialization - multiple sockets</h3>
  484.  
  485.       
  486.  
  487.       <p>This discusses a shortcoming in the Unix socket API. Suppose
  488.       your web server uses multiple <code class="directive"><a href="../mod/mpm_common.html#listen">Listen</a></code> statements to listen on either multiple
  489.       ports or multiple addresses. In order to test each socket
  490.       to see if a connection is ready Apache uses
  491.       <code>select(2)</code>. <code>select(2)</code> indicates that a
  492.       socket has <em>zero</em> or <em>at least one</em> connection
  493.       waiting on it. Apache's model includes multiple children, and
  494.       all the idle ones test for new connections at the same time. A
  495.       naive implementation looks something like this (these examples
  496.       do not match the code, they're contrived for pedagogical
  497.       purposes):</p>
  498.  
  499.       <div class="example"><p><code>
  500.         for (;;) {<br />
  501.         <span class="indent">
  502.           for (;;) {<br />
  503.           <span class="indent">
  504.             fd_set accept_fds;<br />
  505.             <br />
  506.             FD_ZERO (&accept_fds);<br />
  507.             for (i = first_socket; i <= last_socket; ++i) {<br />
  508.             <span class="indent">
  509.               FD_SET (i, &accept_fds);<br />
  510.             </span>
  511.             }<br />
  512.             rc = select (last_socket+1, &accept_fds, NULL, NULL, NULL);<br />
  513.             if (rc < 1) continue;<br />
  514.             new_connection = -1;<br />
  515.             for (i = first_socket; i <= last_socket; ++i) {<br />
  516.             <span class="indent">
  517.               if (FD_ISSET (i, &accept_fds)) {<br />
  518.               <span class="indent">
  519.                 new_connection = accept (i, NULL, NULL);<br />
  520.                 if (new_connection != -1) break;<br />
  521.               </span>
  522.               }<br />
  523.             </span>
  524.             }<br />
  525.             if (new_connection != -1) break;<br />
  526.           </span>
  527.           }<br />
  528.           process the new_connection;<br />
  529.         </span>
  530.         }
  531.       </code></p></div>
  532.  
  533.       <p>But this naive implementation has a serious starvation problem.
  534.       Recall that multiple children execute this loop at the same
  535.       time, and so multiple children will block at
  536.       <code>select</code> when they are in between requests. All
  537.       those blocked children will awaken and return from
  538.       <code>select</code> when a single request appears on any socket
  539.       (the number of children which awaken varies depending on the
  540.       operating system and timing issues). They will all then fall
  541.       down into the loop and try to <code>accept</code> the
  542.       connection. But only one will succeed (assuming there's still
  543.       only one connection ready), the rest will be <em>blocked</em>
  544.       in <code>accept</code>. This effectively locks those children
  545.       into serving requests from that one socket and no other
  546.       sockets, and they'll be stuck there until enough new requests
  547.       appear on that socket to wake them all up. This starvation
  548.       problem was first documented in <a href="http://bugs.apache.org/index/full/467">PR#467</a>. There
  549.       are at least two solutions.</p>
  550.  
  551.       <p>One solution is to make the sockets non-blocking. In this
  552.       case the <code>accept</code> won't block the children, and they
  553.       will be allowed to continue immediately. But this wastes CPU
  554.       time. Suppose you have ten idle children in
  555.       <code>select</code>, and one connection arrives. Then nine of
  556.       those children will wake up, try to <code>accept</code> the
  557.       connection, fail, and loop back into <code>select</code>,
  558.       accomplishing nothing. Meanwhile none of those children are
  559.       servicing requests that occurred on other sockets until they
  560.       get back up to the <code>select</code> again. Overall this
  561.       solution does not seem very fruitful unless you have as many
  562.       idle CPUs (in a multiprocessor box) as you have idle children,
  563.       not a very likely situation.</p>
  564.  
  565.       <p>Another solution, the one used by Apache, is to serialize
  566.       entry into the inner loop. The loop looks like this
  567.       (differences highlighted):</p>
  568.  
  569.       <div class="example"><p><code>
  570.         for (;;) {<br />
  571.         <span class="indent">
  572.           <strong>accept_mutex_on ();</strong><br />
  573.           for (;;) {<br />
  574.           <span class="indent">
  575.             fd_set accept_fds;<br />
  576.             <br />
  577.             FD_ZERO (&accept_fds);<br />
  578.             for (i = first_socket; i <= last_socket; ++i) {<br />
  579.             <span class="indent">
  580.               FD_SET (i, &accept_fds);<br />
  581.             </span>
  582.             }<br />
  583.             rc = select (last_socket+1, &accept_fds, NULL, NULL, NULL);<br />
  584.             if (rc < 1) continue;<br />
  585.             new_connection = -1;<br />
  586.             for (i = first_socket; i <= last_socket; ++i) {<br />
  587.             <span class="indent">
  588.               if (FD_ISSET (i, &accept_fds)) {<br />
  589.               <span class="indent">
  590.                 new_connection = accept (i, NULL, NULL);<br />
  591.                 if (new_connection != -1) break;<br />
  592.               </span>
  593.               }<br />
  594.             </span>
  595.             }<br />
  596.             if (new_connection != -1) break;<br />
  597.           </span>
  598.           }<br />
  599.           <strong>accept_mutex_off ();</strong><br />
  600.           process the new_connection;<br />
  601.         </span>
  602.         }
  603.       </code></p></div>
  604.  
  605.       <p><a id="serialize" name="serialize">The functions</a>
  606.       <code>accept_mutex_on</code> and <code>accept_mutex_off</code>
  607.       implement a mutual exclusion semaphore. Only one child can have
  608.       the mutex at any time. There are several choices for
  609.       implementing these mutexes. The choice is defined in
  610.       <code>src/conf.h</code> (pre-1.3) or
  611.       <code>src/include/ap_config.h</code> (1.3 or later). Some
  612.       architectures do not have any locking choice made, on these
  613.       architectures it is unsafe to use multiple
  614.       <code class="directive"><a href="../mod/mpm_common.html#listen">Listen</a></code>
  615.       directives.</p>
  616.  
  617.       <dl>
  618.         <dt><code>USE_FLOCK_SERIALIZED_ACCEPT</code></dt>
  619.  
  620.         <dd>
  621.           <p>This method uses the <code>flock(2)</code> system call to
  622.           lock a lock file (located by the <code class="directive"><a href="../mod/mpm_common.html#lockfile">LockFile</a></code> directive).</p>
  623.         </dd>
  624.  
  625.         <dt><code>USE_FCNTL_SERIALIZED_ACCEPT</code></dt>
  626.  
  627.         <dd>
  628.           <p>This method uses the <code>fcntl(2)</code> system call to
  629.           lock a lock file (located by the <code class="directive"><a href="../mod/mpm_common.html#lockfile">LockFile</a></code> directive).</p>
  630.         </dd>
  631.  
  632.         <dt><code>USE_SYSVSEM_SERIALIZED_ACCEPT</code></dt>
  633.  
  634.         <dd>
  635.           <p>(1.3 or later) This method uses SysV-style semaphores to
  636.           implement the mutex. Unfortunately SysV-style semaphores have
  637.           some bad side-effects. One is that it's possible Apache will
  638.           die without cleaning up the semaphore (see the
  639.           <code>ipcs(8)</code> man page). The other is that the
  640.           semaphore API allows for a denial of service attack by any
  641.           CGIs running under the same uid as the webserver
  642.           (<em>i.e.</em>, all CGIs, unless you use something like
  643.           <code>suexec</code> or <code>cgiwrapper</code>). For these
  644.           reasons this method is not used on any architecture except
  645.           IRIX (where the previous two are prohibitively expensive
  646.           on most IRIX boxes).</p>
  647.         </dd>
  648.  
  649.         <dt><code>USE_USLOCK_SERIALIZED_ACCEPT</code></dt>
  650.  
  651.         <dd>
  652.           <p>(1.3 or later) This method is only available on IRIX, and
  653.           uses <code>usconfig(2)</code> to create a mutex. While this
  654.           method avoids the hassles of SysV-style semaphores, it is not
  655.           the default for IRIX. This is because on single processor
  656.           IRIX boxes (5.3 or 6.2) the uslock code is two orders of
  657.           magnitude slower than the SysV-semaphore code. On
  658.           multi-processor IRIX boxes the uslock code is an order of
  659.           magnitude faster than the SysV-semaphore code. Kind of a
  660.           messed up situation. So if you're using a multiprocessor IRIX
  661.           box then you should rebuild your webserver with
  662.           <code>-DUSE_USLOCK_SERIALIZED_ACCEPT</code> on the
  663.           <code>EXTRA_CFLAGS</code>.</p>
  664.         </dd>
  665.  
  666.         <dt><code>USE_PTHREAD_SERIALIZED_ACCEPT</code></dt>
  667.  
  668.         <dd>
  669.           <p>(1.3 or later) This method uses POSIX mutexes and should
  670.           work on any architecture implementing the full POSIX threads
  671.           specification, however appears to only work on Solaris (2.5
  672.           or later), and even then only in certain configurations. If
  673.           you experiment with this you should watch out for your server
  674.           hanging and not responding. Static content only servers may
  675.           work just fine.</p>
  676.         </dd>
  677.       </dl>
  678.  
  679.       <p>If your system has another method of serialization which
  680.       isn't in the above list then it may be worthwhile adding code
  681.       for it (and submitting a patch back to Apache).</p>
  682.  
  683.       <p>Another solution that has been considered but never
  684.       implemented is to partially serialize the loop -- that is, let
  685.       in a certain number of processes. This would only be of
  686.       interest on multiprocessor boxes where it's possible multiple
  687.       children could run simultaneously, and the serialization
  688.       actually doesn't take advantage of the full bandwidth. This is
  689.       a possible area of future investigation, but priority remains
  690.       low because highly parallel web servers are not the norm.</p>
  691.  
  692.       <p>Ideally you should run servers without multiple
  693.       <code class="directive"><a href="../mod/mpm_common.html#listen">Listen</a></code>
  694.       statements if you want the highest performance.
  695.       But read on.</p>
  696.  
  697.     
  698.  
  699.     <h3>accept Serialization - single socket</h3>
  700.  
  701.       
  702.  
  703.       <p>The above is fine and dandy for multiple socket servers, but
  704.       what about single socket servers? In theory they shouldn't
  705.       experience any of these same problems because all children can
  706.       just block in <code>accept(2)</code> until a connection
  707.       arrives, and no starvation results. In practice this hides
  708.       almost the same "spinning" behaviour discussed above in the
  709.       non-blocking solution. The way that most TCP stacks are
  710.       implemented, the kernel actually wakes up all processes blocked
  711.       in <code>accept</code> when a single connection arrives. One of
  712.       those processes gets the connection and returns to user-space,
  713.       the rest spin in the kernel and go back to sleep when they
  714.       discover there's no connection for them. This spinning is
  715.       hidden from the user-land code, but it's there nonetheless.
  716.       This can result in the same load-spiking wasteful behaviour
  717.       that a non-blocking solution to the multiple sockets case
  718.       can.</p>
  719.  
  720.       <p>For this reason we have found that many architectures behave
  721.       more "nicely" if we serialize even the single socket case. So
  722.       this is actually the default in almost all cases. Crude
  723.       experiments under Linux (2.0.30 on a dual Pentium pro 166
  724.       w/128Mb RAM) have shown that the serialization of the single
  725.       socket case causes less than a 3% decrease in requests per
  726.       second over unserialized single-socket. But unserialized
  727.       single-socket showed an extra 100ms latency on each request.
  728.       This latency is probably a wash on long haul lines, and only an
  729.       issue on LANs. If you want to override the single socket
  730.       serialization you can define
  731.       <code>SINGLE_LISTEN_UNSERIALIZED_ACCEPT</code> and then
  732.       single-socket servers will not serialize at all.</p>
  733.  
  734.     
  735.  
  736.     <h3>Lingering Close</h3>
  737.  
  738.       
  739.  
  740.       <p>As discussed in <a href="http://www.ics.uci.edu/pub/ietf/http/draft-ietf-http-connection-00.txt">
  741.       draft-ietf-http-connection-00.txt</a> section 8, in order for
  742.       an HTTP server to <strong>reliably</strong> implement the
  743.       protocol it needs to shutdown each direction of the
  744.       communication independently (recall that a TCP connection is
  745.       bi-directional, each half is independent of the other). This
  746.       fact is often overlooked by other servers, but is correctly
  747.       implemented in Apache as of 1.2.</p>
  748.  
  749.       <p>When this feature was added to Apache it caused a flurry of
  750.       problems on various versions of Unix because of a
  751.       shortsightedness. The TCP specification does not state that the
  752.       <code>FIN_WAIT_2</code> state has a timeout, but it doesn't prohibit it.
  753.       On systems without the timeout, Apache 1.2 induces many sockets
  754.       stuck forever in the <code>FIN_WAIT_2</code> state. In many cases this
  755.       can be avoided by simply upgrading to the latest TCP/IP patches
  756.       supplied by the vendor. In cases where the vendor has never
  757.       released patches (<em>i.e.</em>, SunOS4 -- although folks with
  758.       a source license can patch it themselves) we have decided to
  759.       disable this feature.</p>
  760.  
  761.       <p>There are two ways of accomplishing this. One is the socket
  762.       option <code>SO_LINGER</code>. But as fate would have it, this
  763.       has never been implemented properly in most TCP/IP stacks. Even
  764.       on those stacks with a proper implementation (<em>i.e.</em>,
  765.       Linux 2.0.31) this method proves to be more expensive (cputime)
  766.       than the next solution.</p>
  767.  
  768.       <p>For the most part, Apache implements this in a function
  769.       called <code>lingering_close</code> (in
  770.       <code>http_main.c</code>). The function looks roughly like
  771.       this:</p>
  772.  
  773.       <div class="example"><p><code>
  774.         void lingering_close (int s)<br />
  775.         {<br />
  776.         <span class="indent">
  777.           char junk_buffer[2048];<br />
  778.           <br />
  779.           /* shutdown the sending side */<br />
  780.           shutdown (s, 1);<br />
  781.           <br />
  782.           signal (SIGALRM, lingering_death);<br />
  783.           alarm (30);<br />
  784.           <br />
  785.           for (;;) {<br />
  786.           <span class="indent">
  787.             select (s for reading, 2 second timeout);<br />
  788.             if (error) break;<br />
  789.             if (s is ready for reading) {<br />
  790.             <span class="indent">
  791.               if (read (s, junk_buffer, sizeof (junk_buffer)) <= 0) {<br />
  792.               <span class="indent">
  793.                 break;<br />
  794.               </span>
  795.               }<br />
  796.               /* just toss away whatever is here */<br />
  797.             </span>
  798.             }<br />
  799.           </span>
  800.           }<br />
  801.           <br />
  802.           close (s);<br />
  803.         </span>
  804.         }
  805.       </code></p></div>
  806.  
  807.       <p>This naturally adds some expense at the end of a connection,
  808.       but it is required for a reliable implementation. As HTTP/1.1
  809.       becomes more prevalent, and all connections are persistent,
  810.       this expense will be amortized over more requests. If you want
  811.       to play with fire and disable this feature you can define
  812.       <code>NO_LINGCLOSE</code>, but this is not recommended at all.
  813.       In particular, as HTTP/1.1 pipelined persistent connections
  814.       come into use <code>lingering_close</code> is an absolute
  815.       necessity (and <a href="http://www.w3.org/Protocols/HTTP/Performance/Pipeline.html">
  816.       pipelined connections are faster</a>, so you want to support
  817.       them).</p>
  818.  
  819.     
  820.  
  821.     <h3>Scoreboard File</h3>
  822.  
  823.       
  824.  
  825.       <p>Apache's parent and children communicate with each other
  826.       through something called the scoreboard. Ideally this should be
  827.       implemented in shared memory. For those operating systems that
  828.       we either have access to, or have been given detailed ports
  829.       for, it typically is implemented using shared memory. The rest
  830.       default to using an on-disk file. The on-disk file is not only
  831.       slow, but it is unreliable (and less featured). Peruse the
  832.       <code>src/main/conf.h</code> file for your architecture and
  833.       look for either <code>USE_MMAP_SCOREBOARD</code> or
  834.       <code>USE_SHMGET_SCOREBOARD</code>. Defining one of those two
  835.       (as well as their companions <code>HAVE_MMAP</code> and
  836.       <code>HAVE_SHMGET</code> respectively) enables the supplied
  837.       shared memory code. If your system has another type of shared
  838.       memory, edit the file <code>src/main/http_main.c</code> and add
  839.       the hooks necessary to use it in Apache. (Send us back a patch
  840.       too please.)</p>
  841.  
  842.       <div class="note">Historical note: The Linux port of Apache didn't start to
  843.       use shared memory until version 1.2 of Apache. This oversight
  844.       resulted in really poor and unreliable behaviour of earlier
  845.       versions of Apache on Linux.</div>
  846.  
  847.     
  848.  
  849.     <h3>DYNAMIC_MODULE_LIMIT</h3>
  850.  
  851.       
  852.  
  853.       <p>If you have no intention of using dynamically loaded modules
  854.       (you probably don't if you're reading this and tuning your
  855.       server for every last ounce of performance) then you should add
  856.       <code>-DDYNAMIC_MODULE_LIMIT=0</code> when building your
  857.       server. This will save RAM that's allocated only for supporting
  858.       dynamically loaded modules.</p>
  859.  
  860.     
  861.  
  862.   </div><div class="top"><a href="#page-header"><img alt="top" src="../images/up.gif" /></a></div>
  863. <div class="section">
  864. <h2><a name="trace" id="trace">Appendix: Detailed Analysis of a Trace</a></h2>
  865.  
  866.     
  867.  
  868.     <p>Here is a system call trace of Apache 2.0.38 with the worker MPM
  869.     on Solaris 8. This trace was collected using:</p>
  870.  
  871.     <div class="example"><p><code>
  872.       truss -l -p <var>httpd_child_pid</var>.
  873.     </code></p></div>
  874.  
  875.     <p>The <code>-l</code> option tells truss to log the ID of the
  876.     LWP (lightweight process--Solaris's form of kernel-level thread)
  877.     that invokes each system call.</p>
  878.  
  879.     <p>Other systems may have different system call tracing utilities
  880.     such as <code>strace</code>, <code>ktrace</code>, or <code>par</code>.
  881.     They all produce similar output.</p>
  882.  
  883.     <p>In this trace, a client has requested a 10KB static file
  884.     from the httpd. Traces of non-static requests or requests
  885.     with content negotiation look wildly different (and quite ugly
  886.     in some cases).</p>
  887.  
  888.     <div class="example"><pre>/67:    accept(3, 0x00200BEC, 0x00200C0C, 1) (sleeping...)
  889. /67:    accept(3, 0x00200BEC, 0x00200C0C, 1)            = 9</pre></div>
  890.  
  891.     <p>In this trace, the listener thread is running within LWP #67.</p>
  892.  
  893.     <div class="note">Note the lack of <code>accept(2)</code> serialization. On this
  894.     particular platform, the worker MPM uses an unserialized accept by
  895.     default unless it is listening on multiple ports.</div>
  896.  
  897.     <div class="example"><pre>/65:    lwp_park(0x00000000, 0)                         = 0
  898. /67:    lwp_unpark(65, 1)                               = 0</pre></div>
  899.  
  900.     <p>Upon accepting the connection, the listener thread wakes up
  901.     a worker thread to do the request processing. In this trace,
  902.     the worker thread that handles the request is mapped to LWP #65.</p>
  903.  
  904.     <div class="example"><pre>/65:    getsockname(9, 0x00200BA4, 0x00200BC4, 1)       = 0</pre></div>
  905.  
  906.     <p>In order to implement virtual hosts, Apache needs to know
  907.     the local socket address used to accept the connection. It
  908.     is possible to eliminate this call in many situations (such
  909.     as when there are no virtual hosts, or when
  910.     <code class="directive"><a href="../mod/mpm_common.html#listen">Listen</a></code> directives
  911.     are used which do not have wildcard addresses). But
  912.     no effort has yet been made to do these optimizations. </p>
  913.  
  914.     <div class="example"><pre>/65:    brk(0x002170E8)                                 = 0
  915. /65:    brk(0x002190E8)                                 = 0</pre></div>
  916.  
  917.     <p>The <code>brk(2)</code> calls allocate memory from the heap.
  918.     It is rare to see these in a system call trace, because the httpd
  919.     uses custom memory allocators (<code>apr_pool</code> and
  920.     <code>apr_bucket_alloc</code>) for most request processing.
  921.     In this trace, the httpd has just been started, so it must
  922.     call <code>malloc(3)</code> to get the blocks of raw memory
  923.     with which to create the custom memory allocators.</p>
  924.  
  925.     <div class="example"><pre>/65:    fcntl(9, F_GETFL, 0x00000000)                   = 2
  926. /65:    fstat64(9, 0xFAF7B818)                          = 0
  927. /65:    getsockopt(9, 65535, 8192, 0xFAF7B918, 0xFAF7B910, 2190656) = 0
  928. /65:    fstat64(9, 0xFAF7B818)                          = 0
  929. /65:    getsockopt(9, 65535, 8192, 0xFAF7B918, 0xFAF7B914, 2190656) = 0
  930. /65:    setsockopt(9, 65535, 8192, 0xFAF7B918, 4, 2190656) = 0
  931. /65:    fcntl(9, F_SETFL, 0x00000082)                   = 0</pre></div>
  932.  
  933.     <p>Next, the worker thread puts the connection to the client (file
  934.     descriptor 9) in non-blocking mode. The <code>setsockopt(2)</code>
  935.     and <code>getsockopt(2)</code> calls are a side-effect of how
  936.     Solaris's libc handles <code>fcntl(2)</code> on sockets.</p>
  937.  
  938.     <div class="example"><pre>/65:    read(9, " G E T   / 1 0 k . h t m".., 8000)     = 97</pre></div>
  939.  
  940.     <p>The worker thread reads the request from the client.</p>
  941.  
  942.     <div class="example"><pre>/65:    stat("/var/httpd/apache/httpd-8999/htdocs/10k.html", 0xFAF7B978) = 0
  943. /65:    open("/var/httpd/apache/httpd-8999/htdocs/10k.html", O_RDONLY) = 10</pre></div>
  944.  
  945.     <p>This httpd has been configured with <code>Options FollowSymLinks</code>
  946.     and <code>AllowOverride None</code>.  Thus it doesn't need to
  947.     <code>lstat(2)</code> each directory in the path leading up to the
  948.     requested file, nor check for <code>.htaccess</code> files.
  949.     It simply calls <code>stat(2)</code> to verify that the file:
  950.     1) exists, and 2) is a regular file, not a directory.</p>
  951.  
  952.     <div class="example"><pre>/65:    sendfilev(0, 9, 0x00200F90, 2, 0xFAF7B53C)      = 10269</pre></div>
  953.  
  954.     <p>In this example, the httpd is able to send the HTTP response
  955.     header and the requested file with a single <code>sendfilev(2)</code>
  956.     system call. Sendfile semantics vary among operating systems. On some other
  957.     systems, it is necessary to do a <code>write(2)</code> or
  958.     <code>writev(2)</code> call to send the headers before calling
  959.     <code>sendfile(2)</code>.</p>
  960.  
  961.     <div class="example"><pre>/65:    write(4, " 1 2 7 . 0 . 0 . 1   -  ".., 78)      = 78</pre></div>
  962.  
  963.     <p>This <code>write(2)</code> call records the request in the
  964.     access log. Note that one thing missing from this trace is a
  965.     <code>time(2)</code> call. Unlike Apache 1.3, Apache 2.0 uses
  966.     <code>gettimeofday(3)</code> to look up the time. On some operating
  967.     systems, like Linux or Solaris, <code>gettimeofday</code> has an
  968.     optimized implementation that doesn't require as much overhead
  969.     as a typical system call.</p>
  970.  
  971.     <div class="example"><pre>/65:    shutdown(9, 1, 1)                               = 0
  972. /65:    poll(0xFAF7B980, 1, 2000)                       = 1
  973. /65:    read(9, 0xFAF7BC20, 512)                        = 0
  974. /65:    close(9)                                        = 0</pre></div>
  975.  
  976.     <p>The worker thread does a lingering close of the connection.</p>
  977.  
  978.     <div class="example"><pre>/65:    close(10)                                       = 0
  979. /65:    lwp_park(0x00000000, 0)         (sleeping...)</pre></div>
  980.  
  981.     <p>Finally the worker thread closes the file that it has just delivered
  982.     and blocks until the listener assigns it another connection.</p>
  983.  
  984.     <div class="example"><pre>/67:    accept(3, 0x001FEB74, 0x001FEB94, 1) (sleeping...)</pre></div>
  985.  
  986.     <p>Meanwhile, the listener thread is able to accept another connection
  987.     as soon as it has dispatched this connection to a worker thread (subject
  988.     to some flow-control logic in the worker MPM that throttles the listener
  989.     if all the available workers are busy).  Though it isn't apparent from
  990.     this trace, the next <code>accept(2)</code> can (and usually does, under
  991.     high load conditions) occur in parallel with the worker thread's handling
  992.     of the just-accepted connection.</p>
  993.  
  994.   </div></div>
  995. <div id="footer">
  996. <p class="apache">Maintained by the <a href="http://httpd.apache.org/docs-project/">Apache HTTP Server Documentation Project</a></p>
  997. <p class="menu"><a href="../mod/">Modules</a> | <a href="../mod/directives.html">Directives</a> | <a href="../faq/">FAQ</a> | <a href="../glossary.html">Glossary</a> | <a href="../sitemap.html">Sitemap</a></p></div>
  998. </body></html>