lock

#ifndef lock_h
#define lock_h

#include <stdint.h>
#include <string.h>
#include "mydef.h"
#include "now.h"
#define debug_lock 1

typedef struct {
    intptr_t lck;
    uintptr_t tid;
    uintptr_t nr;
#if debug_lock
    const char* file;
    uintptr_t line;
#endif
} lock_t;

#define lock_initial {0}
#define lock_initial_locked {1, 0, 1}
static __attribute__((unused)) lock_t lock_val = lock_initial;

#if (debug_lock == 2)
#define locktrace_begin() uintptr_t tms = now();
#define lock_backtrace(lkp) do {     uintptr_t current = now();     if (tms == 0) {         tms = current;     }         if (current > tms + 3000) {         tms = current - 2000;         logmsg("locktrace: %d %s:%d\n", (int) lkp->lck, lkp->file, (int) lkp->line);     } } while (0)
#else
#define locktrace_begin() (void) 0
#define lock_backtrace(x) (void) 0
#endif

#if debug_lock
    #define log_lock(ptr, l, f) do {ptr->line = l; ptr->file = f;} while (0)
    #define log_unlock(ptr) do {ptr->line = -1; ptr->file = "";} while (0)
#else
    #define log_lock(ptr, l, f) (void) (0)
    #define log_unlock(ptr) (void) (0)
#endif

#ifdef __linux__
    #ifndef _GNU_SOURCE
    #define _GNU_SOURCE
    #endif

    #define my_lock(lkp, re)     do {          lock_t* ptr = lkp;         if (!__sync_bool_compare_and_swap(&ptr->lck, 0, 1)) {             if (ptr->lck == 2) {                 syscall(__NR_futex, &ptr->lck, FUTEX_WAIT, 2, NULL, NULL, 0);             }                         locktrace_begin();             while (0 != __sync_lock_test_and_set(&ptr->lck, 2)) {                 syscall(__NR_futex, &ptr->lck, FUTEX_WAIT, 2, NULL, NULL, 0);                 lock_backtrace(ptr);             }         }         my_assert2(ptr->lck != 0, "lck = %d", ptr->lck);         my_assert2(ptr->nr == 0, "lck = %d, nr = %d, %d@%s", ptr->lck, ptr->nr, ptr->line, ptr->file);         log_lock(ptr, __LINE__, __FILE__);                 my_assert(ptr->tid == 0);         if (re) {             ptr->tid = systid();         }         ++ptr->nr;     } while (0)

    #define unlock(lkp)     do {         lock_t* ptr = lkp;         my_assert2(ptr->lck != 0, "lck = %d, nr = %d", ptr->lck, ptr->nr);         --ptr->nr;         wmb();         if (ptr->nr > 0) {             my_assert2(ptr->tid != 0, "tid != 0, ptr->nr = %d, lck = %d, %d@%s", ptr->nr, ptr->lck, ptr->line, ptr->file);         } else {             ptr->tid = 0;             /* wmb(); */             log_unlock(ptr);             if (2 == __sync_lock_test_and_set(&ptr->lck, 0)) {                 while (-1 == syscall(__NR_futex, &ptr->lck, FUTEX_WAKE, 1, NULL, NULL, 0));             }         }     } while (0)

#else
    #define my_lock(lkp, re)     do {          lock_t* ptr = lkp;         locktrace_begin();         while (!__sync_bool_compare_and_swap((void **) &ptr->lck, (void *) 0, (void *) 1)) {             sched_yield();              lock_backtrace(ptr);         }         log_lock(ptr, __LINE__, __FILE__);                 my_assert(ptr->tid == 0);         if (re) {             ptr->tid = systid();         }         ++ptr->nr;     } while (0)

    #define unlock(lkp)     do {         lock_t* ptr = lkp;         my_assert(ptr->lck != 0);         --ptr->nr;         wmb();         if (ptr->nr > 0) {             my_assert(ptr->tid != 0);         } else {             ptr->tid = 0;             /* wmb(); */             log_unlock(ptr);             ptr->lck = 0;         }     } while (0)
#endif

#define lock(lkp) my_lock(lkp, 0)

#define relock(lkp) do {      lock_t* ptr = lkp;     /* this rmb() is here to assure to see ptr->tid = 0 in unlock */     /* if thread exit after unlock(), then another thread is spwaned with same tid */     /* on another cpu core and then call lock_recursive. */     /* all the above happens so quickly that the other cpu core does not see ptr->tid = 0 */     /* it is so impossible to happen that I comment the "correct" implemention. */     /* rmb(); */         if (ptr->tid == systid()) {         /* if true, it‘s same thread, event in another cpu core, no mb() is needed. */         ++ptr->nr;     } else {         my_lock(lkp, 1);     } } while (0)

static __attribute__((unused)) inline intptr_t my_try_lock(lock_t* lkp, uintptr_t re, uintptr_t line, const char* file)
{
    if (!__sync_bool_compare_and_swap((void **) &((lkp)->lck), (void *) 0, (void *) 1)) {
        return -1;
    }
    log_lock(lkp, line, file);

    my_assert(lkp->tid == 0);
    if (re) {
        lkp->tid = systid();
    }
    ++lkp->nr;
    return 0;
}

#define try_lock(lkp) my_try_lock(lkp, 0, __LINE__, __FILE__)
#define retry_lock(lkp) my_try_lock(lkp, 1, __LINE__, __FILE__)

typedef struct {
    intptr_t nr;
} rwlock_t;

#define read_write_max 8000
#define rw_lock_initial {read_write_max}
static __attribute__((unused)) rwlock_t rw_lock_val = rw_lock_initial;

#define read_write_lock(lckp, val) do {     rwlock_t* lck = lckp;     do {         intptr_t n = __sync_sub_and_fetch(&lck->nr, val);         if (n >= 0) {             break;         }         __sync_add_and_fetch(&lck->nr, val);         sched_yield();     } while (1); } while (0)

#define read_write_unlock(lckp, val) do {     rwlock_t* lck = lckp;     __sync_add_and_fetch(&lck->nr, val); } while (0)

#define read_lock(lckp) read_write_lock(lckp, 1)
#define write_lock(lckp) read_write_lock(lckp, read_write_max)
#define read_unlock(lckp) read_write_unlock(lckp, 1)
#define write_unlock(lckp) read_write_unlock(lckp, read_write_max)

#endif