rofisys 0.5.0

This system crate provides Rust language bindings (via the use of Bindgen) to the Rust-OFI library.
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

/*
 * Copyright (c) 2013-2017 Intel Corporation.  All rights reserved.
 * Copyright (c) 2014-2017, Cisco Systems, Inc. All rights reserved.
 *
 * This software is available to you under the BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef _TRANSPORT_H_
#define _TRANSPORT_H_

#if HAVE_CONFIG_H
#include <config.h>
#endif /* HAVE_CONFIG_H */

#include <inttypes.h>
#include <netinet/tcp.h>
#include <stdbool.h>
#include <stdlib.h>
#include <sys/uio.h>

#include <rdma/fabric.h>
#include <rdma/fi_domain.h>
#include <rdma/fi_rma.h>

#define ROFI_TRANSPORT_ERR_MSG(call, retv)                                               \
    do {                                                                                 \
        fprintf(stderr, "[ROFI TRANSPORT ERR][PE: %d][TID: %d][%s:%d] " call " failed: %s (%d)\n", \
                rt_get_rank(), syscall(__NR_gettid), __FILE__, __LINE__, fi_strerror(retv), (int)(retv));      \
    } while (0)

#define MIN(a, b) \
    ({ __typeof__ (a) _a = (a); \
       __typeof__ (b) _b = (b); \
     _a < _b ? _a : _b; })

#define MAX(a, b) \
    ({ __typeof__ (a) _a = (a); \
       __typeof__ (b) _b = (b); \
     _a > _b ? _a : _b; })

int rofi_transport_fini(rofi_transport_t *rofi);
int rofi_transport_init(struct fi_info *hints, rofi_transport_t *rofi, rofi_names_t *prov_names, rofi_names_t *domain_names);
int rofi_transport_init_fabric_resources(rofi_transport_t *rofi);
int rofi_transport_init_endpoint_resources(rofi_transport_t *rofi);
int rofi_transport_init_av(rofi_transport_t *rofi);

int rofi_transport_progress(rofi_transport_t *rofi);
int rofi_transport_ctx_check_err(rofi_transport_t *rofi, int err);
int rofi_transport_check_rma_err(rofi_transport_t *rofi, int ret);
int rofi_transport_wait_on_cntr(rofi_transport_t *rofi, _Atomic uint64_t *pending_cntr, struct fid_cntr *cntr);
int rofi_transport_wait_on_context_comp(rofi_transport_t *rofi, void *context);
int rofi_transport_wait_on_event(rofi_transport_t *rofi, uint32_t event, void *context);

int rofi_transport_put_inject(rofi_transport_t *rofi, struct fi_rma_iov *rma_iov, uint64_t pe, const void *src_addr, size_t len);
int rofi_transport_put_large(rofi_transport_t *rofi, struct fi_rma_iov *rma_iov, uint64_t pe, const void *src_addr, size_t len, void *desc, void *context);
int rofi_transport_put(rofi_transport_t *rofi, struct fi_rma_iov *rma_iov, uint64_t pe, const void *src_addr, size_t len, void *desc, void *context);
int rofi_transport_put_wait_all(rofi_transport_t *rofi);

int rofi_transport_get_small(rofi_transport_t *rofi, struct fi_rma_iov *rma_iov, uint64_t pe, void *dst_addr, size_t len, void *desc, void *context);
int rofi_transport_get_large(rofi_transport_t *rofi, struct fi_rma_iov *rma_iov, uint64_t pe, void *dst_addr, size_t len, void *desc, void *context);
int rofi_transport_get(rofi_transport_t *rofi, struct fi_rma_iov *rma_iov, uint64_t pe, void *dst_addr, size_t len, void *desc, void *context);
int rofi_transport_get_wait_all(rofi_transport_t *rofi);

int rofi_transport_atomic(rofi_transport_t *rofi, struct fi_rma_iov *rma_iov, uint64_t pe, const void *value, size_t count, enum fi_datatype datatype, enum fi_op op, void *value_desc, void *context);
int rofi_transport_atomic_fetch(rofi_transport_t *rofi, struct fi_rma_iov *rma_iov, uint64_t pe, const void *value, void *result, size_t count, enum fi_datatype datatype, enum fi_op op, void *value_desc, void *result_desc, void *context);
int rofi_transport_compare_atomic(rofi_transport_t *rofi, struct fi_rma_iov *rma_iov, uint64_t pe, const void *value, const void *compare, void *result, size_t count, enum fi_datatype datatype, enum fi_op op, void *value_desc, void *compare_desc, void *result_desc, void *context);

int rofi_transport_send(rofi_transport_t *rofi, void *buf, size_t len, uint64_t pe);
int rofi_transport_recv(rofi_transport_t *rofi, void *buf, size_t len);

int rofi_transport_exchange_init_mr_info(rofi_transport_t *rofi, rofi_mr_desc *mr);
int rofi_transport_exchange_mr_info(rofi_transport_t *rofi, rofi_mr_desc *mr);
int rofi_transport_sub_exchange_mr_info(rofi_transport_t *rofi, rofi_mr_desc *mr, uint64_t *pes, uint64_t num_pes);
int rofi_transport_sub_exchange_mr_info_manual(rofi_transport_t *rofi, rofi_mr_desc *mr, uint64_t *pes, uint64_t num_pes);
int rofi_transport_inner_barrier(rofi_transport_t *rofi, uint64_t *barrier_id, uint64_t *barrier_buf, uint64_t *pes, uint64_t me, uint64_t num_pes);
int rofi_transport_barrier(rofi_transport_t *rofi);


// CXI uses a message-based barrier at the end of rofi_init_internal
// This requires using at least the Rx completion queue
// So here we have the barrier and the completion counter wait (blocking on 
// number of entries)
#ifdef __OFI_PROV_CXI__
int rofi_transport_wait_on_cq(struct fid_cq *cq, struct fi_cq_entry *cqe, const int expected_num_entries); // blocking!
int rofi_transport_barrier_msg(rofi_transport_t *rofi);
#endif

#endif /* _TRANSPORT_H_ */