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
79
80
81
82
83
84
85
86
87
88
89
90
91

/**
 * Copyright (C) 2021 NVIDIA CORPORATION & AFFILIATES. ALL RIGHTS RESERVED.
 *
 * See file LICENSE for terms.
 */

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

#include "ptr_map.inl"


static void ucs_ptr_hash_destroy(ucs_ptr_hash_t *ptr_hash)
{
    size_t size = kh_size(ptr_hash);
    if (size != 0) {
        ucs_warn("ptr hash %p contains %zd elements on destroy", ptr_hash,
                 size);
    }
    kh_destroy_inplace(ucs_ptr_map_impl, ptr_hash);
}

static ucs_status_t ucs_ptr_safe_hash_init(ucs_ptr_safe_hash_t *safe_hash)
{
    kh_init_inplace(ucs_ptr_map_impl, &safe_hash->hash);
    return ucs_spinlock_init(&safe_hash->lock, 0);
}

static void ucs_ptr_safe_hash_destroy(ucs_ptr_safe_hash_t *safe_hash)
{
    ucs_ptr_hash_destroy(&safe_hash->hash);
    ucs_spinlock_destroy(&safe_hash->lock);
}

ucs_status_t ucs_ptr_safe_hash_get(ucs_ptr_map_t *map, ucs_ptr_map_key_t key,
                                   int extract, void **ptr_p,
                                   ucs_ptr_safe_hash_t *safe_hash)
{
    ucs_status_t status;

    ucs_spin_lock(&safe_hash->lock);
    status = ucs_ptr_hash_get(&safe_hash->hash, key, 1, ptr_p);
    ucs_spin_unlock(&safe_hash->lock);

    if ((status == UCS_OK) && !extract) {
        ucs_ptr_hash_put(&map->hash, key, *ptr_p);
    }

    return status;
}

ucs_status_t ucs_ptr_safe_hash_put(ucs_ptr_map_t *map, void *ptr,
                                   ucs_ptr_map_key_t *key,
                                   ucs_ptr_safe_hash_t *safe_hash)
{
    ucs_status_t status;

    ucs_spin_lock(&safe_hash->lock);
    *key   = ucs_ptr_map_create_key(map);
    status = ucs_ptr_hash_put(&safe_hash->hash, *key, ptr);
    ucs_spin_unlock(&safe_hash->lock);

    return status;
}

ucs_status_t ucs_ptr_map_init(ucs_ptr_map_t *map, int is_put_thread_safe,
                              ucs_ptr_safe_hash_t *safe_hash)
{
    ucs_status_t status = UCS_OK;

    UCS_STATIC_ASSERT(!ucs_ptr_map_key_indirect(UCS_PTR_MAP_KEY_INVALID));
    map->next_id = 0;
    kh_init_inplace(ucs_ptr_map_impl, &map->hash);

    if (is_put_thread_safe) {
        status = ucs_ptr_safe_hash_init(safe_hash);
    }

    return status;
}

void ucs_ptr_map_destroy(ucs_ptr_map_t *map, int is_put_thread_safe,
                         ucs_ptr_safe_hash_t *safe_hash)
{
    ucs_ptr_hash_destroy(&map->hash);

    if (is_put_thread_safe) {
        ucs_ptr_safe_hash_destroy(safe_hash);
    }
}