LU-5548 ptlrpc: avoid list scan in ptlrpcd_check

ptlrpcd_check() always scan all requests on ptlrpc_request_set
and try to finish completed requests, this is low efficiency.
Even worse, l_wait_event() always checks condition for twice
before sleeping and one more time after waking up, which means
it will call ptlrpcd_check() for three times in each loop.

This patch will move completed requests at the head of list
in ptlrpc_check_set(), with this change ptlrpcd_check doesn't
need to scan all requests anymore.

Signed-off-by: Liang Zhen <liang.zhen@intel.com>
Change-Id: I84ef477717b53be9e508a596594f176c9de476bb
Reviewed-on: http://review.whamcloud.com/11513
Tested-by: Maloo <hpdd-maloo@intel.com>
Tested-by: Jenkins
Reviewed-by: Bobi Jam <bobijam@gmail.com>
Reviewed-by: Andreas Dilger <andreas.dilger@intel.com>
Reviewed-by: Johann Lombardi <johann.lombardi@intel.com>
Reviewed-by: Oleg Drokin <oleg.drokin@intel.com>

diff --git a/lustre/ptlrpc/client.c b/lustre/ptlrpc/client.c
index 8c2a833..87f1c6a 100644 (file)
--- a/lustre/ptlrpc/client.c
+++ b/lustre/ptlrpc/client.c
@@ -1521,12 +1521,14 @@ static inline int ptlrpc_set_producer(struct ptlrpc_request_set *set)
 int ptlrpc_check_set(const struct lu_env *env, struct ptlrpc_request_set *set)
 {
        struct list_head *tmp, *next;
-        int force_timer_recalc = 0;
-        ENTRY;
+       struct list_head  comp_reqs;
+       int force_timer_recalc = 0;
+       ENTRY;
 
        if (atomic_read(&set->set_remaining) == 0)
-                RETURN(1);
+               RETURN(1);
 
+       INIT_LIST_HEAD(&comp_reqs);
        list_for_each_safe(tmp, next, &set->set_requests) {
                struct ptlrpc_request *req =
                        list_entry(tmp, struct ptlrpc_request,
@@ -1601,8 +1603,10 @@ int ptlrpc_check_set(const struct lu_env *env, struct ptlrpc_request_set *set)
                         ptlrpc_rqphase_move(req, req->rq_next_phase);
                 }
 
-                if (req->rq_phase == RQ_PHASE_COMPLETE)
+                if (req->rq_phase == RQ_PHASE_COMPLETE) {
+                       list_move_tail(&req->rq_set_chain, &comp_reqs);
                         continue;
+               }
 
                 if (req->rq_phase == RQ_PHASE_INTERPRET)
                         GOTO(interpret, req->rq_status);
@@ -1889,9 +1893,15 @@ int ptlrpc_check_set(const struct lu_env *env, struct ptlrpc_request_set *set)
                        if (req->rq_status != 0)
                                set->set_rc = req->rq_status;
                        ptlrpc_req_finished(req);
+               } else {
+                       list_move_tail(&req->rq_set_chain, &comp_reqs);
                }
        }
 
+       /* move completed request at the head of list so it's easier for
+        * caller to find them */
+       list_splice(&comp_reqs, &set->set_requests);
+
        /* If we hit an error, we want to recover promptly. */
        RETURN(atomic_read(&set->set_remaining) == 0 || force_timer_recalc);
 }

diff --git a/lustre/ptlrpc/ptlrpcd.c b/lustre/ptlrpc/ptlrpcd.c
index 8f7fa9d..aa09f15 100644 (file)
--- a/lustre/ptlrpc/ptlrpcd.c
+++ b/lustre/ptlrpc/ptlrpcd.c
@@ -306,21 +306,16 @@ static int ptlrpcd_check(struct lu_env *env, struct ptlrpcd_ctl *pc)
        if (atomic_read(&set->set_remaining))
                rc |= ptlrpc_check_set(env, set);
 
-       if (!list_empty(&set->set_requests)) {
-               /*
-                * XXX: our set never completes, so we prune the completed
-                * reqs after each iteration. boy could this be smarter.
-                */
-               list_for_each_safe(pos, tmp, &set->set_requests) {
-                       req = list_entry(pos, struct ptlrpc_request,
-                                        rq_set_chain);
-                       if (req->rq_phase != RQ_PHASE_COMPLETE)
-                               continue;
+       /* NB: ptlrpc_check_set has already moved complted request at the
+        * head of seq::set_requests */
+       list_for_each_safe(pos, tmp, &set->set_requests) {
+               req = list_entry(pos, struct ptlrpc_request, rq_set_chain);
+               if (req->rq_phase != RQ_PHASE_COMPLETE)
+                       break;
 
-                       list_del_init(&req->rq_set_chain);
-                       req->rq_set = NULL;
-                       ptlrpc_req_finished(req);
-               }
+               list_del_init(&req->rq_set_chain);
+               req->rq_set = NULL;
+               ptlrpc_req_finished(req);
        }
 
        if (rc == 0) {