httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ic...@apache.org
Subject svn commit: r1735444 - in /httpd/httpd/trunk/modules/http2: h2_conn.c h2_conn.h h2_io.h h2_mplx.c h2_mplx.h h2_task.c h2_task.h h2_task_input.c h2_task_output.c h2_worker.c h2_worker.h h2_workers.c
Date Thu, 17 Mar 2016 15:22:09 GMT
Author: icing
Date: Thu Mar 17 15:22:09 2016
New Revision: 1735444

URL: http://svn.apache.org/viewvc?rev=1735444&view=rev
Log:
mod_http2: pushing slave conn setup outside of lock area

Modified:
    httpd/httpd/trunk/modules/http2/h2_conn.c
    httpd/httpd/trunk/modules/http2/h2_conn.h
    httpd/httpd/trunk/modules/http2/h2_io.h
    httpd/httpd/trunk/modules/http2/h2_mplx.c
    httpd/httpd/trunk/modules/http2/h2_mplx.h
    httpd/httpd/trunk/modules/http2/h2_task.c
    httpd/httpd/trunk/modules/http2/h2_task.h
    httpd/httpd/trunk/modules/http2/h2_task_input.c
    httpd/httpd/trunk/modules/http2/h2_task_output.c
    httpd/httpd/trunk/modules/http2/h2_worker.c
    httpd/httpd/trunk/modules/http2/h2_worker.h
    httpd/httpd/trunk/modules/http2/h2_workers.c

Modified: httpd/httpd/trunk/modules/http2/h2_conn.c
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/modules/http2/h2_conn.c?rev=1735444&r1=1735443&r2=1735444&view=diff
==============================================================================
--- httpd/httpd/trunk/modules/http2/h2_conn.c (original)
+++ httpd/httpd/trunk/modules/http2/h2_conn.c Thu Mar 17 15:22:09 2016
@@ -284,8 +284,7 @@ conn_rec *h2_slave_create(conn_rec *mast
     c->clogging_input_filters = 1;
     c->log                    = NULL;
     c->log_id                 = NULL;
-    /* Simulate that we had already a request on this connection. */
-    c->keepalives             = 1;
+    c->keepalives             = 0;
     /* We cannot install the master connection socket on the slaves, as
      * modules mess with timeouts/blocking of the socket, with
      * unwanted side effects to the master connection processing.
@@ -326,6 +325,13 @@ void h2_slave_destroy(conn_rec *slave, a
 
 apr_status_t h2_slave_run_pre_connection(conn_rec *slave, apr_socket_t *csd)
 {
+    /* We always start slaves with 1 */
+    slave->keepalives = 1;
     return ap_run_pre_connection(slave, csd);
 }
 
+apr_status_t h2_slave_needs_pre_run(conn_rec *slave)
+{
+    return slave->keepalives == 0;
+}
+

Modified: httpd/httpd/trunk/modules/http2/h2_conn.h
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/modules/http2/h2_conn.h?rev=1735444&r1=1735443&r2=1735444&view=diff
==============================================================================
--- httpd/httpd/trunk/modules/http2/h2_conn.h (original)
+++ httpd/httpd/trunk/modules/http2/h2_conn.h Thu Mar 17 15:22:09 2016
@@ -70,6 +70,7 @@ conn_rec *h2_slave_create(conn_rec *mast
                           apr_allocator_t *allocator);
 void h2_slave_destroy(conn_rec *slave, apr_allocator_t **pallocator);
 
+apr_status_t h2_slave_needs_pre_run(conn_rec *slave);
 apr_status_t h2_slave_run_pre_connection(conn_rec *slave, apr_socket_t *csd);
 void h2_slave_run_connection(conn_rec *slave);
 

Modified: httpd/httpd/trunk/modules/http2/h2_io.h
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/modules/http2/h2_io.h?rev=1735444&r1=1735443&r2=1735444&view=diff
==============================================================================
--- httpd/httpd/trunk/modules/http2/h2_io.h (original)
+++ httpd/httpd/trunk/modules/http2/h2_io.h Thu Mar 17 15:22:09 2016
@@ -40,7 +40,7 @@ struct h2_io {
     apr_pool_t *pool;                /* stream pool */
     apr_bucket_alloc_t *bucket_alloc;
     
-    const struct h2_request *request;/* request on this io */
+    struct h2_request *request;      /* request on this io */
     struct h2_response *response;    /* response to request */
     int rst_error;                   /* h2 related stream abort error */
 

Modified: httpd/httpd/trunk/modules/http2/h2_mplx.c
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/modules/http2/h2_mplx.c?rev=1735444&r1=1735443&r2=1735444&view=diff
==============================================================================
--- httpd/httpd/trunk/modules/http2/h2_mplx.c (original)
+++ httpd/httpd/trunk/modules/http2/h2_mplx.c Thu Mar 17 15:22:09 2016
@@ -299,15 +299,16 @@ static void io_destroy(h2_mplx *m, h2_io
     }
 
     if (io->task) {
-        conn_rec *slave = io->task->c;
+        conn_rec *slave = h2_task_detach(io->task);
         h2_task_destroy(io->task);
         io->task = NULL;
-        
-        if (m->spare_slaves->nelts < m->spare_slaves->nalloc) {
-            APR_ARRAY_PUSH(m->spare_slaves, conn_rec*) = slave;
-        }
-        else {
-            h2_slave_destroy(slave, NULL);
+        if (slave) {
+            if (m->spare_slaves->nelts < m->spare_slaves->nalloc) {
+                APR_ARRAY_PUSH(m->spare_slaves, conn_rec*) = slave;
+            }
+            else {
+                h2_slave_destroy(slave, NULL);
+            }
         }
     }
 
@@ -1050,14 +1051,15 @@ apr_status_t h2_mplx_process(h2_mplx *m,
     return status;
 }
 
-static h2_task *pop_task(h2_mplx *m)
+static h2_request *pop_request(h2_mplx *m)
 {
-    h2_task *task = NULL;
-    int sid;
-    while (!m->aborted && !task 
+    h2_request *req = NULL;
+    int stream_id;
+    
+    while (!m->aborted && !req 
         && (m->workers_busy < m->workers_limit)
-        && (sid = h2_iq_shift(m->q)) > 0) {
-        h2_io *io = h2_io_set_get(m->stream_ios, sid);
+        && (stream_id = h2_iq_shift(m->q)) > 0) {
+        h2_io *io = h2_io_set_get(m->stream_ios, stream_id);
         if (io && io->orphaned) {
             io_destroy(m, io, 0);
             if (m->join_wait) {
@@ -1065,35 +1067,45 @@ static h2_task *pop_task(h2_mplx *m)
             }
         }
         else if (io) {
-            conn_rec *slave, **pslave;
-            
-            pslave = (conn_rec **)apr_array_pop(m->spare_slaves);
-            if (pslave) {
-                slave = *pslave;
-            }
-            else {
-                slave = h2_slave_create(m->c, m->pool, NULL);
-                h2_slave_run_pre_connection(slave, ap_get_conn_socket(slave));
-            }
-            
-            
-            io->task = task = h2_task_create(m->id, io->request, slave, m);
-            apr_table_setn(slave->notes, H2_TASK_ID_NOTE, task->id);
-            
-            io->worker_started = 1;
+            req = io->request;
             io->started_at = apr_time_now();
-            if (sid > m->max_stream_started) {
-                m->max_stream_started = sid;
+            if (stream_id > m->max_stream_started) {
+                m->max_stream_started = stream_id;
             }
+            io->worker_started = 1;
             ++m->workers_busy;
         }
     }
-    return task;
+    return req;
+}
+
+static conn_rec *get_slave(h2_mplx *m) 
+{
+    conn_rec **pslave = (conn_rec **)apr_array_pop(m->spare_slaves);
+    if (pslave) {
+        return *pslave;
+    }
+    else {
+        return h2_slave_create(m->c, m->pool, NULL);
+    }
+}
+
+conn_rec *h2_mplx_get_slave(h2_mplx *m) 
+{
+    conn_rec *slave = NULL;
+    int acquired;
+
+    AP_DEBUG_ASSERT(m);
+    if (enter_mutex(m, &acquired) == APR_SUCCESS) {
+        slave = get_slave(m);
+        leave_mutex(m, acquired);
+    }
+    return slave;    
 }
 
-h2_task *h2_mplx_pop_task(h2_mplx *m, int *has_more)
+h2_request *h2_mplx_pop_request(h2_mplx *m, int *has_more)
 {
-    h2_task *task = NULL;
+    h2_request *req = NULL;
     apr_status_t status;
     int acquired;
     
@@ -1103,16 +1115,16 @@ h2_task *h2_mplx_pop_task(h2_mplx *m, in
             *has_more = 0;
         }
         else {
-            task = pop_task(m);
+            req = pop_request(m);
             *has_more = !h2_iq_empty(m->q);
         }
         
-        if (has_more && !task) {
+        if (!req && has_more) {
             m->need_registration = 1;
         }
         leave_mutex(m, acquired);
     }
-    return task;
+    return req;
 }
 
 static void task_done(h2_mplx *m, h2_task *task, h2_req_engine *ngn)
@@ -1130,7 +1142,7 @@ static void task_done(h2_mplx *m, h2_tas
             apr_thread_cond_broadcast(m->task_thawed);
         }
         else {
-            h2_io *io = h2_io_set_get(m->stream_ios, task->stream_id);
+            h2_io *io = h2_io_set_get(m->stream_ios, task->request->id);
             
             ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, m->c,
                           "h2_mplx(%ld): task(%s) done", m->id, task->id);
@@ -1139,7 +1151,7 @@ static void task_done(h2_mplx *m, h2_tas
             /* TODO: this will keep a worker attached to this h2_mplx as
              * long as it has requests to handle. Might no be fair to
              * other mplx's. Perhaps leave after n requests? */
-            h2_mplx_out_close(m, task->stream_id, NULL);
+            h2_mplx_out_close(m, task->request->id, NULL);
             
             if (ngn && io) {
                 apr_off_t bytes = io->output_consumed + h2_io_out_length(io);
@@ -1216,16 +1228,16 @@ static void task_done(h2_mplx *m, h2_tas
     }
 }
 
-void h2_mplx_task_done(h2_mplx *m, h2_task *task, h2_task **ptask)
+void h2_mplx_task_done(h2_mplx *m, h2_task *task, h2_request **preq)
 {
     int acquired;
     
     if (enter_mutex(m, &acquired) == APR_SUCCESS) {
         task_done(m, task, NULL);
         --m->workers_busy;
-        if (ptask) {
+        if (preq) {
             /* caller wants another task */
-            *ptask = pop_task(m);
+            *preq = pop_request(m);
         }
         leave_mutex(m, acquired);
     }
@@ -1419,11 +1431,12 @@ apr_status_t h2_mplx_req_engine_push(con
     task->r = r;
     
     if ((status = enter_mutex(m, &acquired)) == APR_SUCCESS) {
-        h2_io *io = h2_io_set_get(m->stream_ios, task->stream_id);
+        h2_io *io = h2_io_set_get(m->stream_ios, task->request->id);
         if (!io || io->orphaned) {
             status = APR_ECONNABORTED;
         }
         else {
+            io->task = task;
             status = h2_ngn_shed_push_task(m->ngn_shed, ngn_type, task, einit);
         }
         leave_mutex(m, acquired);

Modified: httpd/httpd/trunk/modules/http2/h2_mplx.h
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/modules/http2/h2_mplx.h?rev=1735444&r1=1735443&r2=1735444&view=diff
==============================================================================
--- httpd/httpd/trunk/modules/http2/h2_mplx.h (original)
+++ httpd/httpd/trunk/modules/http2/h2_mplx.h Thu Mar 17 15:22:09 2016
@@ -141,9 +141,10 @@ apr_status_t h2_mplx_release_and_join(h2
  */
 void h2_mplx_abort(h2_mplx *mplx);
 
-struct h2_task *h2_mplx_pop_task(h2_mplx *mplx, int *has_more);
+struct h2_request *h2_mplx_pop_request(h2_mplx *mplx, int *has_more);
 
-void h2_mplx_task_done(h2_mplx *m, struct h2_task *task, struct h2_task **ptask);
+void h2_mplx_task_done(h2_mplx *m, struct h2_task *task, 
+                       struct h2_request **prequest);
 
 /**
  * Get the highest stream identifier that has been passed on to processing.
@@ -153,6 +154,8 @@ void h2_mplx_task_done(h2_mplx *m, struc
  */
 int h2_mplx_get_max_stream_started(h2_mplx *m);
 
+conn_rec *h2_mplx_get_slave(h2_mplx *m);
+
 /*******************************************************************************
  * IO lifetime of streams.
  ******************************************************************************/

Modified: httpd/httpd/trunk/modules/http2/h2_task.c
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/modules/http2/h2_task.c?rev=1735444&r1=1735443&r2=1735444&view=diff
==============================================================================
--- httpd/httpd/trunk/modules/http2/h2_task.c (original)
+++ httpd/httpd/trunk/modules/http2/h2_task.c Thu Mar 17 15:22:09 2016
@@ -123,49 +123,59 @@ apr_status_t h2_task_init(apr_pool_t *po
     return APR_SUCCESS;
 }
 
-h2_task *h2_task_create(long session_id, const h2_request *req, 
-                        conn_rec *c, h2_mplx *mplx)
+h2_task *h2_task_create(apr_pool_t *pool, const h2_request *req, h2_mplx *mplx)
 {
-    apr_pool_t *pool;
-    h2_task *task;
-    
-    apr_pool_create(&pool, c->pool);
-    task = apr_pcalloc(pool, sizeof(h2_task));
+    h2_task *task = apr_pcalloc(pool, sizeof(h2_task));
     if (task == NULL) {
-        ap_log_cerror(APLOG_MARK, APLOG_ERR, APR_ENOMEM, c,
+        ap_log_perror(APLOG_MARK, APLOG_ERR, APR_ENOMEM, pool,
                       APLOGNO(02941) "h2_task(%ld-%d): create stream task", 
-                      session_id, req->id);
+                      mplx->id, req->id);
         h2_mplx_out_close(mplx, req->id, NULL);
         return NULL;
     }
-    
-    task->id          = apr_psprintf(pool, "%ld-%d", session_id, req->id);
-    task->stream_id   = req->id;
-    task->c           = c;
-    task->mplx        = mplx;
+    task->id          = apr_psprintf(pool, "%ld-%d", mplx->id, req->id);
     task->pool        = pool;
+    task->mplx        = mplx;
     task->request     = req;
     task->input_eos   = !req->body;
     task->ser_headers = req->serialize;
     task->blocking    = 1;
-
-    h2_ctx_create_for(c, task);
-    /* Add our own, network level in- and output filters. */
-    ap_add_input_filter("H2_TO_H1", task, NULL, c);
-    ap_add_output_filter("H1_TO_H2", task, NULL, c);
-
     return task;
 }
 
+conn_rec *h2_task_detach(h2_task *task)
+{
+    conn_rec *c = task->c;
+    if (c) {
+        task->c = NULL;
+        ap_remove_input_filter_byhandle(c->output_filters, "H2_TO_H1");
+        ap_remove_output_filter_byhandle(c->output_filters, "H1_TO_H2");
+        apr_table_setn(c->notes, H2_TASK_ID_NOTE, NULL);
+    }
+    return c;
+}
+
 void h2_task_destroy(h2_task *task)
 {
-    ap_remove_input_filter_byhandle(task->c->output_filters, "H2_TO_H1");
-    ap_remove_output_filter_byhandle(task->c->output_filters, "H1_TO_H2");
+    h2_task_detach(task);
     if (task->pool) {
         apr_pool_destroy(task->pool);
+        /* memory gone */
     }
 }
 
+void h2_task_attach(h2_task *task, conn_rec *c)
+{
+    if (task->c) {
+        h2_task_detach(task);
+    }
+    task->c = c;
+    h2_ctx_create_for(c, task);
+    apr_table_setn(c->notes, H2_TASK_ID_NOTE, task->id);
+    ap_add_input_filter("H2_TO_H1", task, NULL, c);
+    ap_add_output_filter("H1_TO_H2", task, NULL, c);
+}
+
 void h2_task_set_io_blocking(h2_task *task, int blocking)
 {
     task->blocking = blocking;

Modified: httpd/httpd/trunk/modules/http2/h2_task.h
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/modules/http2/h2_task.h?rev=1735444&r1=1735443&r2=1735444&view=diff
==============================================================================
--- httpd/httpd/trunk/modules/http2/h2_task.h (original)
+++ httpd/httpd/trunk/modules/http2/h2_task.h Thu Mar 17 15:22:09 2016
@@ -50,11 +50,10 @@ typedef struct h2_task h2_task;
 
 struct h2_task {
     const char *id;
-    int stream_id;
-    conn_rec *c;
-    struct h2_mplx *mplx;
     apr_pool_t *pool;
+    struct h2_mplx *mplx;
     const struct h2_request *request;
+    conn_rec *c;
     
     unsigned int filters_set : 1;
     unsigned int input_eos   : 1;
@@ -72,11 +71,21 @@ struct h2_task {
     request_rec *r;                 /* request being processed in this task */
 };
 
-h2_task *h2_task_create(long session_id, const struct h2_request *req, 
-                        conn_rec *c, struct h2_mplx *mplx);
+h2_task *h2_task_create(apr_pool_t *pool, const struct h2_request *req, 
+                        struct h2_mplx *mplx);
 
 void h2_task_destroy(h2_task *task);
 
+/**
+ * Attach the task to the given connection, install filter etc.
+ */
+void h2_task_attach(h2_task *task, conn_rec *c);
+/**
+ * Remove any attachments to the connection again, if still attached.
+ * Return the connection or NULL if none was attached.
+ */
+conn_rec *h2_task_detach(h2_task *task);
+
 apr_status_t h2_task_do(h2_task *task, struct apr_thread_cond_t *cond);
 
 void h2_task_register_hooks(void);

Modified: httpd/httpd/trunk/modules/http2/h2_task_input.c
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/modules/http2/h2_task_input.c?rev=1735444&r1=1735443&r2=1735444&view=diff
==============================================================================
--- httpd/httpd/trunk/modules/http2/h2_task_input.c (original)
+++ httpd/httpd/trunk/modules/http2/h2_task_input.c Thu Mar 17 15:22:09 2016
@@ -90,6 +90,9 @@ apr_status_t h2_task_input_read(h2_task_
     apr_status_t status = APR_SUCCESS;
     apr_off_t bblen = 0;
     
+    AP_DEBUG_ASSERT(input);
+    AP_DEBUG_ASSERT(input->task);
+    AP_DEBUG_ASSERT(f->c);
     ap_log_cerror(APLOG_MARK, APLOG_TRACE1, 0, f->c,
                   "h2_task_input(%s): read, block=%d, mode=%d, readbytes=%ld", 
                   input->task->id, block, mode, (long)readbytes);
@@ -133,7 +136,7 @@ apr_status_t h2_task_input_read(h2_task_
          * setting. 
          */
         status = h2_mplx_in_read(input->task->mplx, block,
-                                 input->task->stream_id, input->bb, 
+                                 input->task->request->id, input->bb, 
                                  f->r? f->r->trailers_in : NULL, 
                                  input->task->io);
         ap_log_cerror(APLOG_MARK, APLOG_TRACE1, status, f->c,

Modified: httpd/httpd/trunk/modules/http2/h2_task_output.c
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/modules/http2/h2_task_output.c?rev=1735444&r1=1735443&r2=1735444&view=diff
==============================================================================
--- httpd/httpd/trunk/modules/http2/h2_task_output.c (original)
+++ httpd/httpd/trunk/modules/http2/h2_task_output.c Thu Mar 17 15:22:09 2016
@@ -39,7 +39,7 @@ h2_task_output *h2_task_output_create(h2
     h2_task_output *output = apr_pcalloc(task->pool, sizeof(h2_task_output));
     if (output) {
         output->task = task;
-        output->from_h1 = h2_from_h1_create(task->stream_id, task->pool);
+        output->from_h1 = h2_from_h1_create(task->request->id, task->pool);
     }
     return output;
 }
@@ -96,7 +96,7 @@ static apr_status_t open_response(h2_tas
                   output->task->id, output->task->request->method, 
                   output->task->request->authority, 
                   output->task->request->path);
-    return h2_mplx_out_open(output->task->mplx, output->task->stream_id, 
+    return h2_mplx_out_open(output->task->mplx, output->task->request->id,

                             response, f, bb, output->task->io);
 }
 
@@ -111,7 +111,7 @@ static apr_status_t write_brigade_raw(h2
                   "h2_task(%s): write response body (%ld bytes)", 
                   output->task->id, (long)written);
     
-    status = h2_mplx_out_write(output->task->mplx, output->task->stream_id, 
+    status = h2_mplx_out_write(output->task->mplx, output->task->request->id,

                                f, output->task->blocking, bb, 
                                get_trailers(output), output->task->io);
     if (status == APR_INCOMPLETE) {
@@ -145,7 +145,7 @@ apr_status_t h2_task_output_write(h2_tas
     }
     
     if (output->task->frozen) {
-        h2_util_bb_log(output->task->c, output->task->stream_id, APLOG_TRACE2,
+        h2_util_bb_log(output->task->c, output->task->request->id, APLOG_TRACE2,
                        "frozen task output write, ignored", bb);
         return APR_SUCCESS;
     }

Modified: httpd/httpd/trunk/modules/http2/h2_worker.c
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/modules/http2/h2_worker.c?rev=1735444&r1=1735443&r2=1735444&view=diff
==============================================================================
--- httpd/httpd/trunk/modules/http2/h2_worker.c (original)
+++ httpd/httpd/trunk/modules/http2/h2_worker.c Thu Mar 17 15:22:09 2016
@@ -34,14 +34,27 @@
 static void* APR_THREAD_FUNC execute(apr_thread_t *thread, void *wctx)
 {
     h2_worker *worker = (h2_worker *)wctx;
+    h2_mplx *mplx;
+    h2_request *req;
     int sticky;
     
     while (!worker->aborted) {
-        h2_task *task;
         
         /* Get a h2_task from the main workers queue. */
-        worker->get_next(worker, worker->ctx, &task, &sticky);
-        while (task) {
+        worker->get_next(worker, worker->ctx, &mplx, &req, &sticky);
+        while (req) {
+            h2_task *task;
+            apr_pool_t *pool;
+            conn_rec *slave;
+            
+            slave = h2_mplx_get_slave(mplx);
+            if (h2_slave_needs_pre_run(slave)) {
+                h2_slave_run_pre_connection(slave, ap_get_conn_socket(slave));
+            }
+            
+            apr_pool_create(&pool, slave->pool);
+            task = h2_task_create(pool, req, mplx);
+            h2_task_attach(task, slave);
             h2_task_do(task, worker->io);
             
             /* if someone was waiting on this task, time to wake up */
@@ -49,13 +62,14 @@ static void* APR_THREAD_FUNC execute(apr
             /* report the task done and maybe get another one from the same
              * mplx (= master connection), if we can be sticky. 
              */
+            req = NULL;
             if (sticky && !worker->aborted) {
-                h2_mplx_task_done(task->mplx, task, &task);
+                h2_mplx_task_done(mplx, task, &req);
             }
             else {
-                h2_mplx_task_done(task->mplx, task, NULL);
-                task = NULL;
+                h2_mplx_task_done(mplx, task, NULL);
             }
+            task = NULL;
         }
     }
 

Modified: httpd/httpd/trunk/modules/http2/h2_worker.h
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/modules/http2/h2_worker.h?rev=1735444&r1=1735443&r2=1735444&view=diff
==============================================================================
--- httpd/httpd/trunk/modules/http2/h2_worker.h (original)
+++ httpd/httpd/trunk/modules/http2/h2_worker.h Thu Mar 17 15:22:09 2016
@@ -31,7 +31,8 @@ typedef struct h2_worker h2_worker;
  * gets aborted (idle timeout, for example). */
 typedef apr_status_t h2_worker_mplx_next_fn(h2_worker *worker,
                                             void *ctx,
-                                            struct h2_task **ptask,
+                                            struct h2_mplx **pmplx,
+                                            struct h2_request **prequest,
                                             int *psticky);
 
 /* Invoked just before the worker thread exits. */

Modified: httpd/httpd/trunk/modules/http2/h2_workers.c
URL: http://svn.apache.org/viewvc/httpd/httpd/trunk/modules/http2/h2_workers.c?rev=1735444&r1=1735443&r2=1735444&view=diff
==============================================================================
--- httpd/httpd/trunk/modules/http2/h2_workers.c (original)
+++ httpd/httpd/trunk/modules/http2/h2_workers.c Thu Mar 17 15:22:09 2016
@@ -61,9 +61,9 @@ static void cleanup_zombies(h2_workers *
     }
 }
 
-static h2_task *next_task(h2_workers *workers)
+static h2_request *next_request(h2_workers *workers, h2_mplx **pmplx)
 {
-    h2_task *task = NULL;
+    h2_request *req = NULL;
     h2_mplx *last = NULL;
     int has_more;
     
@@ -76,7 +76,7 @@ static h2_task *next_task(h2_workers *wo
      * new mplx to arrive. Depending on how many workers do exist,
      * we do a timed wait or block indefinitely.
      */
-    while (!task && !H2_MPLX_LIST_EMPTY(&workers->mplxs)) {
+    while (!req && !H2_MPLX_LIST_EMPTY(&workers->mplxs)) {
         h2_mplx *m = H2_MPLX_LIST_FIRST(&workers->mplxs);
         
         if (last == m) {
@@ -85,7 +85,7 @@ static h2_task *next_task(h2_workers *wo
         H2_MPLX_REMOVE(m);
         --workers->mplx_count;
         
-        task = h2_mplx_pop_task(m, &has_more);
+        req = h2_mplx_pop_request(m, &has_more);
         if (has_more) {
             H2_MPLX_LIST_INSERT_TAIL(&workers->mplxs, m);
             ++workers->mplx_count;
@@ -93,8 +93,13 @@ static h2_task *next_task(h2_workers *wo
                 last = m;
             }
         }
+        
+        if (req) {
+            *pmplx = m;
+            return req;
+        }
     }
-    return task;
+    return req;
 }
 
 /**
@@ -102,14 +107,17 @@ static h2_task *next_task(h2_workers *wo
  * or the max_wait timer expires and more than min workers exist.
  */
 static apr_status_t get_mplx_next(h2_worker *worker, void *ctx, 
-                                  h2_task **ptask, int *psticky)
+                                  h2_mplx **pmplx, h2_request **preq, 
+                                  int *psticky)
 {
     apr_status_t status;
     apr_time_t wait_until = 0, now;
     h2_workers *workers = ctx;
-    h2_task *task = NULL;
+    h2_request *req = NULL;
+    h2_mplx *mplx = NULL;
     
-    *ptask = NULL;
+    *preq = NULL;
+    *pmplx = NULL;
     *psticky = 0;
     
     status = apr_thread_mutex_lock(workers->lock);
@@ -119,7 +127,7 @@ static apr_status_t get_mplx_next(h2_wor
                      "h2_worker(%d): looking for work", h2_worker_get_id(worker));
         
         while (!h2_worker_is_aborted(worker) && !workers->aborted
-               && !(task = next_task(workers))) {
+               && !(req = next_request(workers, &mplx))) {
         
             /* Need to wait for a new tasks to arrive. If we are above
              * minimum workers, we do a timed wait. When timeout occurs
@@ -161,10 +169,10 @@ static apr_status_t get_mplx_next(h2_wor
             }
         }
         
-        /* Here, we either have gotten task or decided to shut down
+        /* Here, we either have gotten a request or decided to shut down
          * the calling worker.
          */
-        if (task) {
+        if (req) {
             /* Ok, we got something to give back to the worker for execution. 
              * If we have more idle workers than h2_mplx in our queue, then
              * we let the worker be sticky, e.g. making it poll the task's
@@ -174,7 +182,8 @@ static apr_status_t get_mplx_next(h2_wor
              * has no new tasks to process, so the worker will get back here
              * eventually.
              */
-            *ptask = task;
+            *preq = req;
+            *pmplx = mplx;
             *psticky = (workers->max_workers >= workers->mplx_count);
             
             if (workers->mplx_count && workers->idle_workers > 1) {
@@ -186,7 +195,7 @@ static apr_status_t get_mplx_next(h2_wor
         apr_thread_mutex_unlock(workers->lock);
     }
     
-    return *ptask? APR_SUCCESS : APR_EOF;
+    return *preq? APR_SUCCESS : APR_EOF;
 }
 
 static void worker_done(h2_worker *worker, void *ctx)



Mime
View raw message