Quelle  h2_workers.h

/* 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.
 */

#ifndef __mod_h2__h2_workers__
#define __mod_h2__h2_workers__

/* 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;

typedef struct 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.
 */
typedef struct 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.
 */
typedef void 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
 */
typedef void 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,
                                        const char *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);

#endif /* defined(__mod_h2__h2_workers__) */