/* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License.
*/
/* Thread pool specific to executing secondary connections. * Has a minimum and maximum number of workers it creates. * Starts with minimum workers and adds some on load, * reduces the number again when idle.
*/ struct apr_thread_mutex_t; struct apr_thread_cond_t; struct h2_mplx; struct h2_request; struct h2_fifo;
typedefstruct h2_workers h2_workers;
/** * Create a worker set with a maximum number of 'slots', e.g. worker * threads to run. Always keep `min_active` workers running. Shutdown * any additional workers after `idle_secs` seconds of doing nothing. * * @oaram s the base server * @param pool for allocations * @param min_active minimum number of workers to run * @param max_slots maximum number of worker slots * @param idle_limit upper duration of idle after a non-minimal slots shuts down
*/
h2_workers *h2_workers_create(server_rec *s, apr_pool_t *pool, int max_slots, int min_active, apr_time_t idle_limit);
/** * Shut down processing.
*/ void h2_workers_shutdown(h2_workers *workers, int graceful);
/** * Get the maximum number of workers.
*/
apr_uint32_t h2_workers_get_max_workers(h2_workers *workers);
/** * ap_conn_producer_t is the source of connections (conn_rec*) to run. * * Active producers are queried by idle workers for connections. * If they do not hand one back, they become inactive and are not * queried further. `h2_workers_activate()` places them on the active * list again. * * A producer finishing MUST call `h2_workers_join()` which removes * it completely from workers processing and waits for all ongoing * work for this producer to be done.
*/ typedefstruct ap_conn_producer_t ap_conn_producer_t;
/** * Ask a producer for the next connection to process. * @param baton value from producer registration * @param pconn holds the connection to process on return * @param pmore if the producer has more connections that may be retrieved * @return APR_SUCCESS for a connection to process, APR_EAGAIN for no * connection being available at the time.
*/ typedef conn_rec *ap_conn_producer_next(void *baton, int *pmore);
/** * Tell the producer that processing the connection is done. * @param baton value from producer registration * @param conn the connection that has been processed.
*/ typedefvoid ap_conn_producer_done(void *baton, conn_rec *conn);
/** * Tell the producer that the workers are shutting down. * @param baton value from producer registration * @param graceful != 0 iff shutdown is graceful
*/ typedefvoid ap_conn_producer_shutdown(void *baton, int graceful);
/** * Register a new producer with the given `baton` and callback functions. * Will allocate internal structures from the given pool (but make no use * of the pool after registration). * Producers are inactive on registration. See `h2_workers_activate()`. * @param producer_pool to allocate the producer from * @param name descriptive name of the producer, must not be unique * @param fn_next callback for retrieving connections to process * @param fn_done callback for processed connections * @param baton provided value passed on in callbacks * @return the producer instance created
*/
ap_conn_producer_t *h2_workers_register(h2_workers *workers,
apr_pool_t *producer_pool, constchar *name,
ap_conn_producer_next *fn_next,
ap_conn_producer_done *fn_done,
ap_conn_producer_shutdown *fn_shutdown, void *baton);
/** * Stop retrieving more connection from the producer and wait * for all ongoing for from that producer to be done.
*/
apr_status_t h2_workers_join(h2_workers *workers, ap_conn_producer_t *producer);
/** * Activate a producer. A worker will query the producer for a connection * to process, once a worker is available. * This may be called, irregardless of the producers active/inactive.
*/
apr_status_t h2_workers_activate(h2_workers *workers, ap_conn_producer_t *producer);
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
