myhandle

#ifndef my_handle_h
#define my_handle_h

#include <stdint.h>
#include "mydef.h"
#include "mem.h"

typedef struct tag_my_handle {
    int ref;
    int stack;
    intptr_t detached;
    void* ptr;
    free_t free;
} my_handle;

static inline my_handle* debug_handle_attach(void* ptr, free_t fp_free, const char* func, int line)
{
    my_handle* handle = (my_handle *) debug_malloc(sizeof(my_handle), func, line);
    if (handle != NULL) {
        handle->ref = 1;
        handle->stack = 1;

        handle->ptr = ptr;
        handle->free = fp_free;
        handle->detached = 0;
    }
    return handle;
}
#define handle_attach(ptr, fptr) debug_handle_attach(ptr, fptr, __FUNCTION__, __LINE__)

#define handle_put(handle) \
do { \
    int n = __sync_sub_and_fetch(&(handle)->stack, 1); \
    my_assert(n >= 0); \
    if (n == 0) { \
        void* handle_ptr = (void *) __sync_lock_test_and_set(&(handle)->ptr, NULL); \
        if ((handle)->free && handle_ptr) { \
            (handle)->free(handle_ptr); \
        } \
    } \
} while (0)

static inline void* handle_get_with(my_handle* handle, int detach, const char* func, int line)
{
    int n = __sync_add_and_fetch(&handle->stack, 1);
    int b = __sync_bool_compare_and_swap((void **) &handle->detached, (void *) 0, (void *) (intptr_t) detach);
    if (!b) {
        handle_put(handle);
        return NULL;
    }

    void* ptr = handle->ptr;
    my_assert2(n > 1 && ptr != NULL, "%d, %p, caller %d@%s", n, ptr, line, func);
    return ptr;
}
#define handle_get(handle) handle_get_with((handle), 0, __FUNCTION__, __LINE__)

static inline int handle_clone(my_handle* handle)
{
    int n = __sync_add_and_fetch(&handle->ref, 1);
    my_assert(n > 0);
    return n;
}

static inline int handle_release(my_handle* handle)
{
    int n = __sync_sub_and_fetch(&handle->ref, 1);
    my_assert2(n >= 0, "%p %d:%d", handle, handle->ref, handle->stack);
    if (n > 0) {
        return n;
    }

    // it should be safe to simplely check whether detached equals 0.
    // we know __sync_xxx functions have mb() semantics, and
    // if some one set handle->detached = 1, it only can be called in
    // handle_dettach while still holds a reference of handle.
    // ok, now we have seen handle->ref = 0 above, meaning
    // we have observed the latter handle_release in handle_dettach.
    // then, the mb() assure that
    // we have observed the earlier handle_get_with(handle, 1).
    if (handle->detached == 0) {
        handle_put(handle);
    }
    my_assert(handle->stack == 0);

    my_free(handle);
    return n;
}

static inline int debug_handle_dettach(my_handle* handle, const char* func, int line)
{
    void* ptr = handle_get_with(handle, 1, func, line);
    if (ptr != NULL) {
        __sync_sub_and_fetch(&handle->stack, 1);
        handle_put(handle);
    }
    return handle_release(handle);
}
#define handle_dettach(handle) debug_handle_dettach((handle), __FUNCTION__, __LINE__)

#endif