Optimize DGLs of size = 1.

1 files changed, 56 insertions, 41 deletions

diff --git a/litmus/locking.c b/litmus/locking.c
index f7d33156cf49..4fe572c28aea 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -250,7 +250,7 @@ void select_next_lock(dgl_wait_state_t* dgl_wait /*, struct litmus_lock* prev_lo
                 /* loop around */
                 dgl_wait->last_primary = dgl_wait->size;
         }
-        
+
         // note reverse order
         for(dgl_wait->last_primary = dgl_wait->last_primary - 1;
                 dgl_wait->last_primary >= 0;
@@ -347,16 +347,16 @@ int __attempt_atomic_dgl_acquire(struct litmus_lock *cur_lock, dgl_wait_state_t
                         return -1;
                 }
         }
-        
+
         /* take the locks */
         for(i = 0; i < dgl_wait->size; ++i) {
                 struct litmus_lock *l = dgl_wait->locks[i];
-                
+
                 l->ops->dgl_quick_lock(l, cur_lock, dgl_wait->task, &dgl_wait->wq_nodes[i]);
-                
+
                 BUG_ON(dgl_wait->task != *(l->nest.owner_ptr));
         }
-        
+
         return 0; /* success */
 }
 
@@ -488,31 +488,38 @@ asmlinkage long sys_litmus_dgl_lock(void* __user usr_dgl_ods, int dgl_size)
                 goto out;
         }
 
-        for(i = 0; i < dgl_size; ++i) {
-                struct od_table_entry *entry = get_entry_for_od(dgl_ods[i]);
-                if(entry && is_lock(entry)) {
-                        dgl_wait_state.locks[i] = get_lock(entry);
-                        if(!supports_dgl(dgl_wait_state.locks[i])) {
-                                TRACE_CUR("Lock %d does not support all required DGL operations.\n",
-                                                  dgl_wait_state.locks[i]->ident);
+        if (dgl_size == 1) {
+                /* DGL size of 1. Just call regular singular lock. */
+                TRACE_CUR("DGL lock with size = 1. Treating as regular lock.\n");
+                err = sys_litmus_lock(dgl_ods[0]);
+        }
+        else {
+                for(i = 0; i < dgl_size; ++i) {
+                        struct od_table_entry *entry = get_entry_for_od(dgl_ods[i]);
+                        if(entry && is_lock(entry)) {
+                                dgl_wait_state.locks[i] = get_lock(entry);
+                                if(!supports_dgl(dgl_wait_state.locks[i])) {
+                                        TRACE_CUR("Lock %d does not support all required DGL operations.\n",
+                                                          dgl_wait_state.locks[i]->ident);
+                                        goto out;
+                                }
+                        }
+                        else {
+                                TRACE_CUR("Invalid lock identifier\n");
                                 goto out;
                         }
                 }
-                else {
-                        TRACE_CUR("Invalid lock identifier\n");
-                        goto out;
-                }
-        }
 
-        dgl_wait_state.task = t;
-        dgl_wait_state.size = dgl_size;
+                dgl_wait_state.task = t;
+                dgl_wait_state.size = dgl_size;
 
-        TS_DGL_LOCK_START;
-        err = do_litmus_dgl_lock(&dgl_wait_state);
+                TS_DGL_LOCK_START;
+                err = do_litmus_dgl_lock(&dgl_wait_state);
 
-        /* Note: task my have been suspended or preempted in between!  Take
-         * this into account when computing overheads. */
-        TS_DGL_LOCK_END;
+                /* Note: task my have been suspended or preempted in between!  Take
+                 * this into account when computing overheads. */
+                TS_DGL_LOCK_END;
+        }
 
 out:
         return err;
@@ -567,28 +574,36 @@ asmlinkage long sys_litmus_dgl_unlock(void* __user usr_dgl_ods, int dgl_size)
         if(__copy_from_user(&dgl_ods, usr_dgl_ods, dgl_size*(sizeof(int))))
                 goto out;
 
-        for(i = 0; i < dgl_size; ++i) {
-                entry = get_entry_for_od(dgl_ods[i]);
-                if(entry && is_lock(entry)) {
-                        dgl_locks[i] = get_lock(entry);
-                        if(!supports_dgl(dgl_locks[i])) {
-                                TRACE_CUR("Lock %d does not support all required DGL operations.\n",
-                                                  dgl_locks[i]->ident);
+
+        if (dgl_size == 1) {
+                /* DGL size of 1. Just call regular singular lock. */
+                TRACE_CUR("DGL unlock with size = 1. Treating as regular unlock.\n");
+                err = sys_litmus_unlock(dgl_ods[0]);
+        }
+        else {
+                for(i = 0; i < dgl_size; ++i) {
+                        entry = get_entry_for_od(dgl_ods[i]);
+                        if(entry && is_lock(entry)) {
+                                dgl_locks[i] = get_lock(entry);
+                                if(!supports_dgl(dgl_locks[i])) {
+                                        TRACE_CUR("Lock %d does not support all required DGL operations.\n",
+                                                          dgl_locks[i]->ident);
+                                        goto out;
+                                }
+                        }
+                        else {
+                                TRACE_CUR("Invalid lock identifier\n");
                                 goto out;
                         }
                 }
-                else {
-                        TRACE_CUR("Invalid lock identifier\n");
-                        goto out;
-                }
-        }
 
-        TS_DGL_UNLOCK_START;
-        err = do_litmus_dgl_unlock(dgl_locks, dgl_size);
+                TS_DGL_UNLOCK_START;
+                err = do_litmus_dgl_unlock(dgl_locks, dgl_size);
 
-        /* Note: task my have been suspended or preempted in between!  Take
-         * this into account when computing overheads. */
-        TS_DGL_UNLOCK_END;
+                /* Note: task my have been suspended or preempted in between!  Take
+                 * this into account when computing overheads. */
+                TS_DGL_UNLOCK_END;
+        }
 
 out:
         return err;