ucx1-sys 0.1.0

Rust FFI bindings to UCX.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

/**
 * Copyright (C) Mellanox Technologies Ltd. 2001-2017.  ALL RIGHTS RESERVED.
 *
 * See file LICENSE for terms.
 */

#ifndef UCP_THREAD_H_
#define UCP_THREAD_H_

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#include <ucs/async/async.h>
#include <ucs/async/thread.h>
#include <ucs/type/spinlock.h>


/*
 * Multi-thread mode
 */
typedef enum ucp_mt_type {
    UCP_MT_TYPE_NONE = 0,
    UCP_MT_TYPE_SPINLOCK,
    UCP_MT_TYPE_MUTEX
} ucp_mt_type_t;


/**
 * Multi-thread lock
 */
typedef struct ucp_mt_lock {
    ucp_mt_type_t                 mt_type;
    union {
        /* Lock for multithreading support. Either spinlock or mutex is used at
           at one time. Spinlock is the default option. */
        pthread_mutex_t           mt_mutex;
        ucs_recursive_spinlock_t  mt_spinlock;
    } lock;
} ucp_mt_lock_t;


#define UCP_THREAD_IS_REQUIRED(_lock_ptr) \
    ((_lock_ptr)->mt_type)
#define UCP_THREAD_LOCK_INIT(_lock_ptr) \
    do { \
        if ((_lock_ptr)->mt_type == UCP_MT_TYPE_MUTEX) { \
            pthread_mutex_init(&((_lock_ptr)->lock.mt_mutex), NULL); \
        } else { \
            ucs_recursive_spinlock_init(&((_lock_ptr)->lock.mt_spinlock), 0); \
        } \
    } while (0)
#define UCP_THREAD_LOCK_FINALIZE(_lock_ptr)                                  \
    do { \
        if ((_lock_ptr)->mt_type == UCP_MT_TYPE_MUTEX) { \
            pthread_mutex_destroy(&((_lock_ptr)->lock.mt_mutex)); \
        } else { \
            ucs_recursive_spinlock_destroy(&((_lock_ptr)->lock.mt_spinlock)); \
        } \
    } while (0)
#define UCP_THREAD_CS_ENTER(_lock_ptr)                                  \
    {                                                                   \
        if ((_lock_ptr)->mt_type == UCP_MT_TYPE_MUTEX) {                \
            pthread_mutex_lock(&((_lock_ptr)->lock.mt_mutex));          \
        } else {                                                        \
            ucs_recursive_spin_lock(&((_lock_ptr)->lock.mt_spinlock));  \
        }                                                               \
    }
#define UCP_THREAD_CS_EXIT(_lock_ptr)                                   \
    {                                                                   \
        if ((_lock_ptr)->mt_type == UCP_MT_TYPE_MUTEX) {                \
            pthread_mutex_unlock(&((_lock_ptr)->lock.mt_mutex));        \
        } else {                                                        \
            ucs_recursive_spin_unlock(&((_lock_ptr)->lock.mt_spinlock));\
        }                                                               \
    }

#endif