glusterfs: Use gcc builtin ATOMIC operator to increase/decreate refcount.

Problem: In glusterfs code base we call mutex_lock/unlock to take
         reference/dereference for a object.Sometime it could be
         reason for lock contention also.

Solution: There is no need to use mutex to increase/decrease ref
          counter, instead of using mutex use gcc builtin ATOMIC
          operation.

Test:   I have not observed yet how much performance gain after apply
        this patch specific to glusterfs but i have tested same
        with below small program(mutex and atomic both) and
        get good difference.

static int numOuterLoops;
static void *
threadFunc(void *arg)
{
    int j;

    for (j = 0; j < numOuterLoops; j++) {
            __atomic_add_fetch (&glob, 1,__ATOMIC_ACQ_REL);
    }
    return NULL;
}

int
main(int argc, char *argv[])
{
    int opt, s, j;
    int numThreads;
    pthread_t *thread;
    int verbose;
    int64_t n = 0;

    if (argc < 2 ) {
     printf(" Please provide 2 args Num of threads && Outer Loop\n");
     exit (-1);
    }
    numThreads = atoi(argv[1]);
    numOuterLoops = atoi (argv[2]);

    if (1) {
        printf("\tthreads: %d; outer loops: %d;\n",
                numThreads, numOuterLoops);
    }

    thread = calloc(numThreads, sizeof(pthread_t));
    if (thread == NULL) {
        printf ("calloc error so exit\n");
        exit (-1);
    }

    __atomic_store (&glob, &n, __ATOMIC_RELEASE);
    for (j = 0; j < numThreads; j++) {
        s = pthread_create(&thread[j], NULL, threadFunc, NULL);
        if (s != 0) {
            printf ("pthread_create failed so exit\n");
            exit (-1);
        }
    }

    for (j = 0; j < numThreads; j++) {
        s = pthread_join(thread[j], NULL);
        if (s != 0) {
            printf ("pthread_join failed so exit\n");
            exit (-1);
        }
    }
    printf("glob value is %ld\n",__atomic_load_n (&glob,__ATOMIC_RELAXED));

    exit(0);
}

   time ./thr_count 800 800000
   threads: 800; outer loops: 800000;
   glob value is 640000000

real	1m10.288s
user	0m57.269s
sys	3m31.565s

time ./thr_count_atomic 800 800000
     threads: 800; outer loops: 800000;
glob value is 640000000

real	0m20.313s
user	1m20.558s
sys	0m0.028

Change-Id: Ie5030a52ea264875e002e108dd4b207b15ab7cc7
Signed-off-by: Mohit Agrawal <moagrawa@redhat.com>

1 files changed, 7 insertions, 52 deletions

diff --git a/libglusterfs/src/fd-lk.c b/libglusterfs/src/fd-lk.c
index 358cf3b616a..e516f64bff6 100644
--- a/libglusterfs/src/fd-lk.c
+++ b/libglusterfs/src/fd-lk.c
@@ -65,15 +65,11 @@ fd_lk_ctx_unref (fd_lk_ctx_t *lk_ctx)
 
         GF_VALIDATE_OR_GOTO ("fd-lk", lk_ctx, err);
 
-        LOCK (&lk_ctx->lock);
-        {
-                ref = --lk_ctx->ref;
-                if (ref < 0)
-                        GF_ASSERT (!ref);
-                if (ref == 0)
-                        _fd_lk_destroy_lock_list (lk_ctx);
-        }
-        UNLOCK (&lk_ctx->lock);
+        ref = GF_ATOMIC_DEC (lk_ctx->ref);
+        if (ref < 0)
+                GF_ASSERT (!ref);
+        if (ref == 0)
+                _fd_lk_destroy_lock_list (lk_ctx);
 
         if (ref == 0) {
                 LOCK_DESTROY (&lk_ctx->lock);
@@ -86,58 +82,17 @@ err:
 }
 
 fd_lk_ctx_t *
-_fd_lk_ctx_ref (fd_lk_ctx_t *lk_ctx)
-{
-        if (!lk_ctx) {
-                gf_msg_callingfn ("fd-lk", GF_LOG_WARNING, EINVAL,
-                                  LG_MSG_INVALID_ARG, "invalid argument");
-                return NULL;
-        }
-
-        ++lk_ctx->ref;
-
-        return lk_ctx;
-}
-
-fd_lk_ctx_t *
 fd_lk_ctx_ref (fd_lk_ctx_t *lk_ctx)
 {
-        fd_lk_ctx_t *new_lk_ctx = NULL;
-
         if (!lk_ctx) {
                 gf_msg_callingfn ("fd-lk", GF_LOG_WARNING, EINVAL,
                                   LG_MSG_INVALID_ARG, "invalid argument");
                 return NULL;
         }
 
-        LOCK (&lk_ctx->lock);
-        {
-                new_lk_ctx = _fd_lk_ctx_ref (lk_ctx);
-        }
-        UNLOCK (&lk_ctx->lock);
-
-        return new_lk_ctx;
-}
-
-fd_lk_ctx_t *
-fd_lk_ctx_try_ref (fd_lk_ctx_t *lk_ctx)
-{
-        int         ret         = -1;
-        fd_lk_ctx_t *new_lk_ctx = NULL;
-
-        if (!lk_ctx) {
-                goto out;
-        }
-
-        ret = TRY_LOCK (&lk_ctx->lock);
-        if (ret)
-                goto out;
+        GF_ATOMIC_INC (lk_ctx->ref);
 
-        new_lk_ctx = _fd_lk_ctx_ref (lk_ctx);
-        UNLOCK (&lk_ctx->lock);
-
-out:
-        return new_lk_ctx;
+        return lk_ctx;
 }
 
 fd_lk_ctx_t *