void sep_atomic_rw(int index)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe = { (void *) -1, UINT_MAX, UINT_MAX,
(void *) -1, UINT_MAX, UINT_MAX };
uint64_t operand = SOURCE_DATA;
uint64_t w[NUMEPS] = {0}, r[NUMEPS] = {0}, w_e[NUMEPS] = {0};
uint64_t r_e[NUMEPS] = {0};
/* u64 */
*((uint64_t *)source) = FETCH_SOURCE_DATA;
*((uint64_t *)target) = TARGET_DATA;
sz = fi_fetch_atomic(tx_ep[0][index], &operand, 1, NULL, source,
loc_mr[0], rx_addr[index], (uint64_t)target,
mr_key[1], FI_UINT64, FI_SUM, target);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(tx_cq[0][index], &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
sep_check_tcqe(&cqe, target, FI_ATOMIC | FI_READ, 0);
r[0] = 1;
sep_check_cntrs(w, r, w_e, r_e);
ret = *((uint64_t *)target) == (SOURCE_DATA + TARGET_DATA);
cr_assert(ret, "Data mismatch");
ret = *((uint64_t *)source) == TARGET_DATA;
cr_assert(ret, "Fetch data mismatch");
}
void do_writedata(int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe, dcqe;
#define WRITE_DATA 0x5123da1a145
init_data(source, len, 0x23);
init_data(target, len, 0);
sz = fi_writedata(ep[0], source, len, loc_mr, WRITE_DATA,
gni_addr[1], (uint64_t)target, mr_key,
target);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0);
rdm_rma_check_cntrs(1, 0, 0, 0);
dbg_printf("got write context event!\n");
cr_assert(check_data(source, target, len), "Data mismatch");
while ((ret = fi_cq_read(recv_cq, &dcqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert(ret != FI_SUCCESS, "Missing remote data");
rdm_rma_check_tcqe(&dcqe, NULL,
(FI_RMA | FI_REMOTE_WRITE | FI_REMOTE_CQ_DATA),
WRITE_DATA);
}
void cm_basic_send(void)
{
int ret;
int source_done = 0, dest_done = 0;
struct fi_cq_tagged_entry cqe;
ssize_t sz;
uint64_t source = 0xa4321234a4321234,
target = 0xb5678901b5678901;
sz = fi_send(cli_ep, &source, 8, 0, 0, &target);
cr_assert_eq(sz, 0);
sz = fi_recv(srv_ep, &target, 8, 0, 0, &source);
cr_assert_eq(sz, 0);
/* need to progress both CQs simultaneously for rendezvous */
do {
ret = fi_cq_read(cli_cq, &cqe, 1);
if (ret == 1) {
cr_assert_eq(cqe.op_context, &target);
source_done = 1;
}
ret = fi_cq_read(srv_cq, &cqe, 1);
if (ret == 1) {
cr_assert_eq(cqe.op_context, &source);
dest_done = 1;
}
} while (!source_done || !dest_done);
cr_assert_eq(source, target);
dbg_printf("Basic send/recv complete! (0x%lx, 0x%lx)\n",
source, target);
}
static void
_assert_control_command_eq(ControlCommand *cmd, ControlCommand *cmd_other)
{
cr_assert_eq(cmd->func, cmd_other->func);
cr_assert_str_eq(cmd->command_name, cmd_other->command_name);
cr_assert_eq(cmd->user_data, cmd_other->user_data);
}
void sep_writev(int index, int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe = { (void *) -1, UINT_MAX, UINT_MAX,
(void *) -1, UINT_MAX, UINT_MAX };
struct iovec iov;
uint64_t w[2] = {0}, r[2] = {0}, w_e[2] = {0}, r_e[2] = {0};
iov.iov_base = source;
iov.iov_len = len;
sep_init_data(source, len, 0x25 + index);
sep_init_data(target, len, 0);
sz = fi_writev(tx_ep[0][index], &iov, (void **)loc_mr, 1,
gni_addr[1], (uint64_t)target, mr_key[1],
target);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(tx_cq[0][index], &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
sep_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0);
w[0] = 1;
sep_check_cntrs(w, r, w_e, r_e);
cr_assert(sep_check_data(source, target, len), "Data mismatch");
}
Test(gnix_freelist, freelist_zero_refill_test)
{
struct gnix_freelist fl;
int i, ret;
const int num_elems = 71;
struct dlist_entry *elems[num_elems + 1];
const int refill_size = 0;
/* non-optimized code may not zero structures */
memset(&fl, 0x0, sizeof(struct gnix_freelist));
ret = _gnix_fl_init(sizeof(struct dlist_entry), 0,
num_elems, refill_size, 0, 0, &fl);
cr_assert_eq(ret, FI_SUCCESS, "Failed to initialize freelist");
for (i = 0; i < num_elems; i++) {
ret = _gnix_fl_alloc(&elems[i], &fl);
cr_assert_eq(ret, FI_SUCCESS, "Failed to obtain dlist_entry");
}
cr_assert(_gnix_fl_empty(&fl), "Freelist not empty");
ret = _gnix_fl_alloc(&elems[num_elems], &fl);
cr_assert_eq(ret, -FI_ECANCELED, "Unexpected return code from "
"_gnix_fl_alloc");
for (i = num_elems-1; i >= 0 ; i--)
_gnix_fl_free(elems[i], &fl);
_gnix_fl_destroy(&fl);
}
void sep_read(int index, int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe = { (void *) -1, UINT_MAX, UINT_MAX,
(void *) -1, UINT_MAX, UINT_MAX };
uint64_t w[2] = {0}, r[2] = {0}, w_e[2] = {0}, r_e[2] = {0};
#define READ_CTX 0x4e3dda1aULL
sep_init_data(source, len, 0);
sep_init_data(target, len, 0xad);
sz = fi_read(tx_ep[0][index], source, len,
loc_mr[0], rx_addr[index], (uint64_t)target, mr_key[1],
(void *)READ_CTX);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(tx_cq[0][index], &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
sep_check_tcqe(&cqe, (void *)READ_CTX, FI_RMA | FI_READ, 0);
r[0] = 1;
sep_check_cntrs(w, r, w_e, r_e);
cr_assert(sep_check_data(source, target, len), "Data mismatch");
}
Test(vc_management_auto, vc_alloc_simple)
{
int ret;
struct gnix_vc *vc[2];
struct gnix_fid_ep *ep_priv;
ep_priv = container_of(ep[0], struct gnix_fid_ep, ep_fid);
ret = _gnix_vc_alloc(ep_priv, gnix_addr[0], &vc[0]);
cr_assert_eq(ret, FI_SUCCESS);
ret = _gnix_vc_alloc(ep_priv, gnix_addr[1], &vc[1]);
cr_assert_eq(ret, FI_SUCCESS);
/*
* vc_id's have to be different since the
* vc's were allocated using the same ep.
*/
cr_assert_neq(vc[0]->vc_id, vc[1]->vc_id);
ret = _gnix_vc_destroy(vc[0]);
cr_assert_eq(ret, FI_SUCCESS);
ret = _gnix_vc_destroy(vc[1]);
cr_assert_eq(ret, FI_SUCCESS);
}
static void lookup_test(void)
{
int ret;
int i;
fi_addr_t addresses[SIMPLE_ADDR_COUNT];
fi_addr_t *compare;
struct gnix_ep_name found;
size_t addrlen = sizeof(struct gnix_ep_name);
/* insert addresses */
ret = fi_av_insert(av, (void *) simple_ep_names, SIMPLE_ADDR_COUNT,
addresses, 0, NULL);
cr_assert_eq(ret, SIMPLE_ADDR_COUNT);
/* check address contents */
for (i = 0; i < SIMPLE_ADDR_COUNT; i++) {
if (gnix_av->type == FI_AV_MAP) {
compare = (fi_addr_t *) &simple_ep_names[i].gnix_addr;
cr_assert_eq(*compare, addresses[i]);
} else {
cr_assert_eq(i, addresses[i]);
}
}
for (i = 0; i < SIMPLE_ADDR_COUNT; i++) {
ret = fi_av_lookup(av, addresses[i], &found, &addrlen);
cr_assert_eq(ret, FI_SUCCESS);
}
}
void rdm_sr_setup_common(void)
{
int ret = 0, i = 0;
rdm_sr_setup_common_eps();
for (i = 0; i < NUMEPS; i++) {
ret = fi_mr_reg(dom[i], target, 3 * BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, rem_mr + i, &target);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom[i], source, BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, loc_mr + i, &source);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom[i], iov_dest_buf, IOV_CNT * BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, iov_dest_buf_mr + i,
&iov_dest_buf);
cr_assert_eq(ret, 0);
ret = fi_mr_reg(dom[i], iov_src_buf, IOV_CNT * BUF_SZ,
FI_REMOTE_WRITE, 0, 0, 0, iov_src_buf_mr + i,
&iov_src_buf);
cr_assert_eq(ret, 0);
mr_key[i] = fi_mr_key(rem_mr[i]);
iov_dest_buf_mr_key[i] = fi_mr_key(iov_dest_buf_mr[i]);
}
}
void do_multirecv(int len)
{
int i, ret;
ssize_t sz;
struct fi_cq_tagged_entry s_cqe, d_cqe;
struct iovec iov;
struct fi_msg msg;
uint64_t s[NUMEPS] = {0}, r[NUMEPS] = {0}, s_e[NUMEPS] = {0};
uint64_t r_e[NUMEPS] = {0};
uint64_t flags;
int nrecvs = 3;
rdm_sr_init_data(source, len, 0xab);
rdm_sr_init_data(target, len, 0);
/* Post receives first to force matching in SMSG callback. */
iov.iov_base = target;
iov.iov_len = len * nrecvs + 63;
msg.msg_iov = &iov;
msg.desc = (void **)rem_mr;
msg.iov_count = 1;
msg.addr = gni_addr[0];
msg.context = source;
msg.data = (uint64_t)source;
sz = fi_recvmsg(ep[1], &msg, FI_MULTI_RECV);
cr_assert_eq(sz, 0);
for (i = 0; i < nrecvs; i++) {
sz = fi_send(ep[0], source, len, loc_mr[0], gni_addr[1],
target);
cr_assert_eq(sz, 0);
}
/* need to progress both CQs simultaneously for rendezvous */
do {
ret = fi_cq_read(msg_cq[0], &s_cqe, 1);
if (ret == 1) {
rdm_sr_check_cqe(&s_cqe, target, (FI_MSG|FI_SEND),
0, 0, 0, false);
s[0]++;
}
ret = fi_cq_read(msg_cq[1], &d_cqe, 1);
flags = (r[1] < (nrecvs -1 )) ? FI_MSG | FI_RECV :
FI_MSG | FI_RECV | FI_MULTI_RECV;
if (ret == 1) {
rdm_sr_check_cqe(&d_cqe, source,
flags,
target + (r[1] * len), len, 0, true);
cr_assert(rdm_sr_check_data(source, d_cqe.buf, len),
"Data mismatch");
r[1]++;
}
} while (s[0] < nrecvs || r[1] < nrecvs);
rdm_sr_check_cntrs(s, r, s_e, r_e);
dbg_printf("got context events!\n");
}
void do_write_autoreg_uncached(int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe;
init_data(uc_source, len, 0xab);
init_data(target, len, 0);
sz = fi_write(ep[0], uc_source, len,
NULL, gni_addr[1], (uint64_t)target, mr_key,
target);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0);
rdm_rma_check_cntrs(1, 0, 0, 0);
dbg_printf("got write context event!\n");
cr_assert(check_data(uc_source, target, len), "Data mismatch");
}
void do_read(int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe;
#define READ_CTX 0x4e3dda1aULL
init_data(source, len, 0);
init_data(target, len, 0xad);
sz = fi_read(ep[0], source, len,
loc_mr, gni_addr[1], (uint64_t)target, mr_key,
(void *)READ_CTX);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
rdm_rma_check_tcqe(&cqe, (void *)READ_CTX, FI_RMA | FI_READ, 0);
rdm_rma_check_cntrs(0, 1, 0, 0);
dbg_printf("got read context event!\n");
cr_assert(check_data(source, target, len), "Data mismatch");
}
static void remove_addr_test(void)
{
int ret;
int i;
fi_addr_t addresses[SIMPLE_ADDR_COUNT];
fi_addr_t *compare;
/* insert addresses */
ret = fi_av_insert(av, (void *) simple_ep_names, SIMPLE_ADDR_COUNT,
addresses, 0, NULL);
cr_assert_eq(ret, SIMPLE_ADDR_COUNT);
/* check address contents */
for (i = 0; i < SIMPLE_ADDR_COUNT; i++) {
if (gnix_av->type == FI_AV_MAP) {
compare = (fi_addr_t *) &simple_ep_names[i].gnix_addr;
cr_assert_eq(*compare, addresses[i]);
} else {
cr_assert_eq(i, addresses[i]);
}
}
/* remove addresses */
ret = fi_av_remove(av, addresses, SIMPLE_ADDR_COUNT, 0);
cr_assert_eq(ret, FI_SUCCESS);
}
static void lookup_invalid_test(void)
{
int ret;
struct gnix_ep_name addr;
size_t addrlen = sizeof(struct gnix_ep_name);
/* test null addrlen */
ret = fi_av_lookup(av, 0xdeadbeef, (void *) 0xdeadbeef, NULL);
cr_assert_eq(ret, -FI_EINVAL);
/* test null addr */
ret = fi_av_lookup(av, 0xdeadbeef, NULL, &addrlen);
cr_assert_eq(ret, -FI_EINVAL);
/* test invalid lookup */
if (gnix_av->type == FI_AV_TABLE) {
ret = fi_av_lookup(av, 2000, &addr, &addrlen);
cr_assert_eq(ret, -FI_EINVAL);
/* test within range, but not inserted case */
ret = fi_av_lookup(av, 1, &addr, &addrlen);
cr_assert_eq(ret, -FI_EINVAL);
} else {
ret = fi_av_lookup(av, 0xdeadbeef, &addr, &addrlen);
cr_assert_eq(ret, -FI_ENOENT);
}
}
Test(endpoint_info, info)
{
int ret;
hints = fi_allocinfo();
cr_assert(hints, "fi_allocinfo");
hints->fabric_attr->prov_name = strdup("gni");
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
cr_assert_eq(fi->ep_attr->type, FI_EP_RDM);
cr_assert_eq(fi->next->ep_attr->type, FI_EP_DGRAM);
cr_assert_eq(fi->next->next->ep_attr->type, FI_EP_MSG);
fi_freeinfo(fi);
hints->ep_attr->type = FI_EP_RDM;
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
cr_assert_eq(fi->ep_attr->type, FI_EP_RDM);
fi_freeinfo(fi);
hints->ep_attr->type = FI_EP_DGRAM;
ret = fi_getinfo(FI_VERSION(1, 0), NULL, 0, 0, hints, &fi);
cr_assert(!ret, "fi_getinfo");
cr_assert_eq(fi->ep_attr->type, FI_EP_DGRAM);
fi_freeinfo(fi);
fi_freeinfo(hints);
}
static void av_full_table_setup(void)
{
struct fi_av_attr av_table_attr = {
.type = FI_AV_TABLE,
.count = 16,
};
int ret;
av_setup();
ret = fi_av_open(dom, &av_table_attr, &av, NULL);
cr_assert_eq(ret, FI_SUCCESS, "failed to open av");
gnix_av = container_of(av, struct gnix_fid_av, av_fid);
}
static void av_full_table_teardown(void)
{
int ret;
ret = fi_close(&av->fid);
cr_assert_eq(ret, FI_SUCCESS, "failed to close av");
av_teardown();
}
void do_tinject(int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe;
rdm_tagged_sr_init_data(source, len, 0x23);
rdm_tagged_sr_init_data(target, len, 0);
sz = fi_tinject(ep[0], source, len, gni_addr[1], len);
cr_assert_eq(sz, 0);
sz = fi_trecv(ep[1], target, len, rem_mr, gni_addr[0], len, 0, source);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(msg_cq[1], &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
cr_assert_eq((uint64_t)cqe.op_context, (uint64_t)source);
dbg_printf("got recv context event!\n");
cr_assert(rdm_tagged_sr_check_data(source, target, len), "Data mismatch");
}
/*
ssize_t fi_tsenddata(struct fid_ep *ep, void *buf, size_t len,
void *desc, uint64_t data, fi_addr_t dest_addr, void *context);
*/
void do_tsenddata(int len)
{
int ret;
ssize_t sz;
int source_done = 0, dest_done = 0;
struct fi_cq_tagged_entry s_cqe, d_cqe;
rdm_tagged_sr_init_data(source, len, 0xab);
rdm_tagged_sr_init_data(target, len, 0);
sz = fi_tsenddata(ep[0], source, len, loc_mr, (uint64_t)source,
gni_addr[1], len, target);
cr_assert_eq(sz, 0);
sz = fi_trecv(ep[1], target, len, rem_mr, gni_addr[0], len, 0, source);
cr_assert_eq(sz, 0);
/* need to progress both CQs simultaneously for rendezvous */
do {
ret = fi_cq_read(msg_cq[0], &s_cqe, 1);
if (ret == 1) {
source_done = 1;
}
ret = fi_cq_read(msg_cq[1], &d_cqe, 1);
if (ret == 1) {
dest_done = 1;
}
} while (!(source_done && dest_done));
dbg_printf("got context events!\n");
cr_assert(rdm_tagged_sr_check_data(source, target, len), "Data mismatch");
}
void do_readv(int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe;
struct iovec iov;
iov.iov_base = source;
iov.iov_len = len;
init_data(target, len, 0x25);
init_data(source, len, 0);
sz = fi_readv(ep[0], &iov, (void **)&loc_mr, 1,
gni_addr[1], (uint64_t)target, mr_key,
target);
cr_assert_eq(sz, 0);
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_READ, 0);
rdm_rma_check_cntrs(0, 1, 0, 0);
dbg_printf("got write context event!\n");
cr_assert(check_data(source, target, len), "Data mismatch");
}
Test(auth_key, race_create)
{
#define __AUTH_KEY_THREAD_COUNT 47
int i;
int thread_count = __AUTH_KEY_THREAD_COUNT;
int ret;
pthread_t threads[__AUTH_KEY_THREAD_COUNT];
pthread_barrier_t barrier;
#undef __AUTH_KEY_THREAD_COUNT
ret = pthread_barrier_init(&barrier, NULL, thread_count);
cr_assert_eq(ret, 0, "failed to initialize barrier");
for (i = 0; i < thread_count; i++) {
ret = pthread_create(&threads[i], NULL,
race_create_func, &barrier);
cr_assert_eq(ret, 0, "failed to create pthread");
}
for (i = 0; i < thread_count; i++) {
ret = pthread_join(threads[i], NULL);
cr_assert_eq(ret, 0);
}
ret = pthread_barrier_destroy(&barrier);
cr_assert_eq(ret, 0);
}
void sep_senddata(int index, int len)
{
ssize_t sz;
struct fi_cq_tagged_entry s_cqe = { (void *) -1, UINT_MAX, UINT_MAX,
(void *) -1, UINT_MAX, UINT_MAX };
struct fi_cq_tagged_entry d_cqe = { (void *) -1, UINT_MAX, UINT_MAX,
(void *) -1, UINT_MAX, UINT_MAX };
uint64_t s[NUMEPS] = {0}, r[NUMEPS] = {0}, s_e[NUMEPS] = {0};
uint64_t r_e[NUMEPS] = {0};
sep_init_data(source, len, 0xab + index);
sep_init_data(target, len, 0);
sz = fi_senddata(tx_ep[0][index], source, len, loc_mr[0],
(uint64_t)source, rx_addr[index], target);
cr_assert_eq(sz, 0);
sz = fi_recv(rx_ep[1][index], target, len, rem_mr[0],
FI_ADDR_UNSPEC, source);
cr_assert_eq(sz, 0);
wait_for_cqs(tx_cq[0][index], rx_cq[1][index], &s_cqe, &d_cqe);
sep_check_cqe(&s_cqe, target, (FI_MSG|FI_SEND), 0, 0, 0, false);
sep_check_cqe(&d_cqe, source, (FI_MSG|FI_RECV|FI_REMOTE_CQ_DATA),
target, len, (uint64_t)source, false);
s[0] = 1; r[1] = 1;
sep_check_cntrs(s, r, s_e, r_e);
cr_assert(sep_check_data(source, target, len), "Data mismatch");
}
Test(Player, look_empty)
{
player_t *pl = player_create_at((vector2d_t){9, 9});
game_t *gm = game_create(20, 20, 7, 5);
cr_assert(pl);
cr_assert(gm);
game_add_team(gm, "pandas");
pl->p_teamname = strdup("pandas");
cr_assert_neq(game_register_player(gm, pl), -1);
dynbuf_t *buf = player_look(pl, gm);
cr_assert(buf);
cr_log_info(buf->b_data);
cr_assert(strstr(buf->b_data, "player"));
cr_assert_eq(count_char(buf->b_data, ','), 3);
pl->p_lvl = 2;
dynbuf_delete(buf);
buf = player_look(pl, gm);
cr_log_info(buf->b_data);
cr_assert(strstr(buf->b_data, "player"));
cr_assert_eq(count_char(buf->b_data, ','), 8);
dynbuf_delete(buf);
pl->p_lvl = 3;
buf = player_look(pl, gm);
cr_log_info(buf->b_data);
cr_assert(strstr(buf->b_data, "player"));
cr_assert_eq(count_char(buf->b_data, ','), 15);
dynbuf_delete(buf);
game_delete(gm);
}
/*
ssize_t fi_sendv(struct fid_ep *ep, const struct iovec *iov, void **desc,
size_t count, fi_addr_t dest_addr, void *context);
*/
void do_sendv(int len)
{
int i, ret, iov_cnt;
int source_done = 0, dest_done = 0;
struct fi_cq_tagged_entry s_cqe, d_cqe;
ssize_t sz;
uint64_t s[NUMEPS] = {0}, r[NUMEPS] = {0}, s_e[NUMEPS] = {0};
uint64_t r_e[NUMEPS] = {0};
sz = fi_sendv(ep[0], src_iov, NULL, 0, gni_addr[1], iov_dest_buf);
cr_assert_eq(sz, -FI_EINVAL);
for (iov_cnt = 1; iov_cnt <= IOV_CNT; iov_cnt++) {
for (i = 0; i < iov_cnt; i++) {
rdm_sr_init_data(src_iov[i].iov_base, len, 0x25);
src_iov[i].iov_len = len;
}
rdm_sr_init_data(iov_dest_buf, len * iov_cnt, 0);
/*
* TODO: Register src_iov and dest_iov.
* Using NULL descriptor for now so that _gnix_send auto registers
* the buffers for rndzv messages.
*/
sz = fi_sendv(ep[0], src_iov, NULL, iov_cnt, gni_addr[1], iov_dest_buf);
cr_assert_eq(sz, 0);
sz = fi_recv(ep[1], iov_dest_buf, len * iov_cnt, iov_dest_buf_mr[1],
gni_addr[0], src_iov);
cr_assert_eq(sz, 0);
/* need to progress both CQs simultaneously for rendezvous */
do {
ret = fi_cq_read(msg_cq[0], &s_cqe, 1);
if (ret == 1) {
source_done = 1;
}
ret = fi_cq_read(msg_cq[1], &d_cqe, 1);
if (ret == 1) {
dest_done = 1;
}
} while (!(source_done && dest_done));
rdm_sr_check_cqe(&s_cqe, iov_dest_buf, (FI_MSG|FI_SEND), 0, 0, 0,
false);
rdm_sr_check_cqe(&d_cqe, src_iov, (FI_MSG|FI_RECV), iov_dest_buf,
len * iov_cnt, 0, false);
s[0] = 1; r[1] = 1;
rdm_sr_check_cntrs(s, r, s_e, r_e);
dbg_printf("got context events!\n");
cr_assert(rdm_sr_check_iov_data(src_iov, iov_dest_buf, iov_cnt, len * iov_cnt),
"Data mismatch");
source_done = dest_done = 0;
}
}
void do_write_fence(int len)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe;
struct iovec iov;
struct fi_msg_rma msg;
struct fi_rma_iov rma_iov;
iov.iov_base = source;
iov.iov_len = len;
rma_iov.addr = (uint64_t)target;
rma_iov.len = sizeof(target);
rma_iov.key = mr_key;
msg.msg_iov = &iov;
msg.desc = (void **)&loc_mr;
msg.iov_count = 1;
msg.addr = gni_addr[1];
msg.rma_iov = &rma_iov;
msg.rma_iov_count = 1;
msg.context = target;
msg.data = (uint64_t)target;
init_data(source, len, 0xef);
init_data(target, len, 0);
/* write A */
sz = fi_writemsg(ep[0], &msg, 0);
cr_assert_eq(sz, 0);
/* write B */
sz = fi_writemsg(ep[0], &msg, FI_FENCE);
cr_assert_eq(sz, 0);
/* event A */
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0);
/* event B */
while ((ret = fi_cq_read(send_cq, &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
rdm_rma_check_tcqe(&cqe, target, FI_RMA | FI_WRITE, 0);
rdm_rma_check_cntrs(2, 0, 0, 0);
dbg_printf("got write context event!\n");
cr_assert(check_data(source, target, len), "Data mismatch");
}
/*
ssize_t (*recvv)(struct fid_ep *ep, const struct iovec *iov, void **desc,
size_t count, fi_addr_t src_addr, void *context);
*/
void do_recvv(int len)
{
int i, ret, iov_cnt;
ssize_t sz;
int source_done = 0, dest_done = 0;
struct fi_cq_tagged_entry s_cqe, d_cqe;
uint64_t s[NUMEPS] = {0}, r[NUMEPS] = {0}, s_e[NUMEPS] = {0};
uint64_t r_e[NUMEPS] = {0};
sz = fi_recvv(ep[1], NULL, NULL, IOV_CNT, gni_addr[0], iov_src_buf);
cr_assert_eq(sz, -FI_EINVAL);
sz = fi_recvv(ep[1], dest_iov, NULL, IOV_CNT + 1, gni_addr[0], iov_src_buf);
cr_assert_eq(sz, -FI_EINVAL);
for (iov_cnt = 1; iov_cnt <= IOV_CNT; iov_cnt++) {
rdm_sr_init_data(iov_src_buf, len * iov_cnt, 0xab);
for (i = 0; i < iov_cnt; i++) {
rdm_sr_init_data(dest_iov[i].iov_base, len, 0);
dest_iov[i].iov_len = len;
}
sz = fi_send(ep[0], iov_src_buf, len * iov_cnt, NULL, gni_addr[1],
dest_iov);
cr_assert_eq(sz, 0);
sz = fi_recvv(ep[1], dest_iov, NULL, iov_cnt, gni_addr[0], iov_src_buf);
cr_assert_eq(sz, 0);
/* need to progress both CQs simultaneously for rendezvous */
do {
ret = fi_cq_read(msg_cq[0], &s_cqe, 1);
if (ret == 1) {
source_done = 1;
}
ret = fi_cq_read(msg_cq[1], &d_cqe, 1);
if (ret == 1) {
dest_done = 1;
}
} while (!(source_done && dest_done));
rdm_sr_check_cqe(&s_cqe, dest_iov, (FI_MSG|FI_SEND), 0, 0, 0, false);
rdm_sr_check_cqe(&d_cqe, iov_src_buf, (FI_MSG|FI_RECV), dest_iov,
len * iov_cnt, 0, false);
s[0] = 1; r[1] = 1;
rdm_sr_check_cntrs(s, r, s_e, r_e);
dbg_printf("got context events!\n");
cr_assert(rdm_sr_check_iov_data(dest_iov, iov_src_buf, iov_cnt, len * iov_cnt),
"Data mismatch");
source_done = dest_done = 0;
}
}
void do_sendrecvv_alignment(int slen, int dlen, int offset)
{
int i, ret, iov_cnt;
ssize_t sz;
int source_done = 0, dest_done = 0;
struct fi_cq_tagged_entry s_cqe, d_cqe;
uint64_t s[NUMEPS] = {0}, r[NUMEPS] = {0}, s_e[NUMEPS] = {0};
uint64_t r_e[NUMEPS] = {0};
uint64_t iov_s_buf = (uint64_t) iov_src_buf;
iov_s_buf += offset;
for (iov_cnt = 1; iov_cnt <= IOV_CNT; iov_cnt++) {
for (i = 0; i < iov_cnt; i++) {
d_iov[i].iov_base = dest_iov[i].iov_base;
d_iov[i].iov_base = (void *) ((uint64_t)d_iov[i].iov_base + offset);
rdm_sr_init_data(d_iov[i].iov_base, dlen - offset, 0);
d_iov[i].iov_len = dlen - offset;
}
rdm_sr_init_data((void *) iov_s_buf, (slen - offset) * iov_cnt, 0xab);
sz = fi_send(ep[0], (void *) iov_s_buf, (slen - offset) * iov_cnt, NULL, gni_addr[1],
d_iov);
cr_assert_eq(sz, 0);
sz = fi_recvv(ep[1], d_iov, NULL, iov_cnt, gni_addr[0], (void *) iov_s_buf);
cr_assert_eq(sz, 0);
/* need to progress both CQs simultaneously for rendezvous */
do {
ret = fi_cq_read(msg_cq[0], &s_cqe, 1);
if (ret == 1) {
source_done = 1;
}
ret = fi_cq_read(msg_cq[1], &d_cqe, 1);
if (ret == 1) {
dest_done = 1;
}
} while (!(source_done && dest_done));
rdm_sr_check_cqe(&s_cqe, d_iov, (FI_MSG|FI_SEND), 0, 0, 0, false);
rdm_sr_check_cqe(&d_cqe, (void *) iov_s_buf, (FI_MSG|FI_RECV), d_iov,
MIN((slen - offset) * iov_cnt, (dlen - offset) * iov_cnt), 0, false);
s[0] = 1; r[1] = 1;
rdm_sr_check_cntrs(s, r, s_e, r_e);
dbg_printf("got context events!\n");
cr_assert(rdm_sr_check_iov_data(d_iov, (void *) iov_s_buf,
iov_cnt, (slen - offset) * iov_cnt),
"Data mismatch");
source_done = dest_done = 0;
}
}
static void setup_reverse( void ){
rb.inverse = true;
DPA_ringbuffer_reset(&rb.super);
cr_assert_eq(rb.size,4,"Ringbuffer size should be 4");
cr_assert_eq(rb.range.offset,4,"Ringbuffer offset should be 4");
cr_assert_eq(rb.range.size,0,"Ringbuffer content size should be 0");
cr_assert(rb.inverse,"Ringbuffer should be inversed");
cr_assert_eq(rb.type_size,sizeof(int),"Ringbuffer entry size is wrong");
cr_assert(rb.buffer,"Ringbuffer buffer must be set");
}
void sep_atomic_compwritemsg(int index)
{
int ret;
ssize_t sz;
struct fi_cq_tagged_entry cqe = { (void *) -1, UINT_MAX, UINT_MAX,
(void *) -1, UINT_MAX, UINT_MAX };
uint64_t operand = SOURCE_DATA, op2 = TARGET_DATA;
struct fi_msg_atomic msg;
struct fi_ioc msg_iov, res_iov, cmp_iov;
struct fi_rma_ioc rma_iov;
uint64_t w[NUMEPS] = {0}, r[NUMEPS] = {0}, w_e[NUMEPS] = {0};
uint64_t r_e[NUMEPS] = {0};
msg_iov.count = 1;
msg.msg_iov = &msg_iov;
msg.desc = (void **)loc_mr;
msg.iov_count = 1;
msg.addr = gni_addr[1];
rma_iov.addr = (uint64_t)target;
rma_iov.count = 1;
rma_iov.key = mr_key[1];
msg.rma_iov = &rma_iov;
msg.context = target;
msg.op = FI_CSWAP;
res_iov.count = 1;
cmp_iov.count = 1;
/* i64 */
*((uint64_t *)source) = FETCH_SOURCE_DATA;
*((uint64_t *)target) = TARGET_DATA;
msg_iov.addr = &operand;
msg.datatype = FI_INT64;
res_iov.addr = source;
cmp_iov.addr = &op2;
sz = fi_compare_atomicmsg(tx_ep[0][index], &msg, &cmp_iov, NULL, 1,
&res_iov, (void **)loc_mr, 1, 0);
cr_assert_eq(sz, 0);
/* reset cqe */
cqe.op_context = cqe.buf = (void *) -1;
cqe.flags = cqe.len = cqe.data = cqe.tag = UINT_MAX;
while ((ret = fi_cq_read(tx_cq[0][index], &cqe, 1)) == -FI_EAGAIN) {
pthread_yield();
}
cr_assert_eq(ret, 1);
sep_check_tcqe(&cqe, target, FI_ATOMIC | FI_READ, 0);
r[0] = 1;
sep_check_cntrs(w, r, w_e, r_e);
ret = *((uint64_t *)target) == SOURCE_DATA;
cr_assert(ret, "Data mismatch");
ret = *((uint64_t *)source) == TARGET_DATA;
cr_assert(ret, "Fetch data mismatch");
}
static void av_teardown(void)
{
int ret = 0;
ret = fi_close(&dom->fid);
cr_assert_eq(ret, FI_SUCCESS, "failure in closing domain.");
ret = fi_close(&fab->fid);
cr_assert_eq(ret, FI_SUCCESS, "failure in closing fabric.");
fi_freeinfo(fi);
fi_freeinfo(hints);
}
