static void *continuous_remove(void *data)
{
int pos, n, ret;
int expected_state;
fi_addr_t *addresses = ((fi_addr_t **) data)[0];
atomic_t *fe = ((atomic_t **) data)[1];
int num_addrs = (int) ((uint64_t *) data)[2];
atomic_t *done = ((atomic_t **) data)[3];
ret = pthread_barrier_wait(&mtbar);
if ((ret != PTHREAD_BARRIER_SERIAL_THREAD) && (ret != 0)) {
pthread_exit((void *) 1UL);
}
pos = 0;
while (!atomic_get(done)) {
n = (pos++)%num_addrs;
expected_state = state_full;
if (atomic_cas_weak(&fe[n], &expected_state, state_locked)) {
av_lock();
ret = fi_av_remove(av, &addresses[n], 1, 0);
av_unlock();
if (ret != FI_SUCCESS) {
/* flag shutdown to avoid deadlock */
atomic_set(done, 1);
pthread_exit((void *) 1UL);
}
atomic_set(&fe[n], state_empty);
}
}
pthread_exit((void *) NULL);
}
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 continuous_lookup(void)
{
int i, ret;
pthread_t thread;
fi_addr_t addresses[MT_ADDR_COUNT];
atomic_t done;
void *info[2];
const int iters = 17;
ret = pthread_barrier_init(&mtbar, NULL, 2);
cr_assert_eq(ret, 0);
init_av_lock();
atomic_initialize(&done, 0);
memset(addresses, 0, MT_ADDR_COUNT*sizeof(fi_addr_t));
info[0] = (void *) addresses;
info[1] = (void *) &done;
ret = pthread_create(&thread, NULL, lookup_random, info);
cr_assert_eq(ret, 0);
ret = pthread_barrier_wait(&mtbar);
cr_assert((ret == PTHREAD_BARRIER_SERIAL_THREAD) || (ret == 0));
for (i = 0; i < iters; i++) {
for (i = 0; i < MT_ADDR_COUNT; i++) {
ret = fi_av_insert(av, (void *) &simple_ep_names[i], 1,
&addresses[i], 0, NULL);
cr_assert_eq(ret, 1);
}
for (i = 0; i < MT_ADDR_COUNT; i++) {
ret = fi_av_remove(av, &addresses[i], 1, 0);
cr_assert_eq(ret, FI_SUCCESS);
}
}
atomic_set(&done, 1);
ret = pthread_join(thread, NULL);
cr_assert_eq(ret, 0);
ret = pthread_barrier_destroy(&mtbar);
cr_assert_eq(ret, 0);
}
static int rxd_av_remove(struct fid_av *av_fid, fi_addr_t *fi_addr, size_t count,
uint64_t flags)
{
int ret = 0;
size_t i, addrlen;
fi_addr_t rxd_addr;
struct rxd_av *av;
uint8_t addr[RXD_NAME_LENGTH];
struct ofi_rbnode *node;
av = container_of(av_fid, struct rxd_av, util_av.av_fid);
fastlock_acquire(&av->util_av.lock);
for (i = 0; i < count; i++) {
rxd_addr = av->fi_addr_table[fi_addr[i]];
addrlen = RXD_NAME_LENGTH;
ret = fi_av_lookup(av->dg_av, av->rxd_addr_table[rxd_addr].dg_addr,
addr, &addrlen);
if (ret)
goto err;
node = ofi_rbmap_find(&av->rbmap, (void *) addr);
if (!node)
goto err;
ofi_rbmap_delete(&av->rbmap, node);
ret = fi_av_remove(av->dg_av, &av->rxd_addr_table[rxd_addr].dg_addr,
1, flags);
if (ret)
goto err;
av->fi_addr_table[fi_addr[i]] = FI_ADDR_UNSPEC;
av->rxd_addr_table[rxd_addr].fi_addr = FI_ADDR_UNSPEC;
av->rxd_addr_table[rxd_addr].dg_addr = FI_ADDR_UNSPEC;
av->dg_av_used--;
}
err:
if (ret)
FI_WARN(&rxd_prov, FI_LOG_AV, "Unable to remove address from AV\n");
fastlock_release(&av->util_av.lock);
return ret;
}
static int rxd_av_remove(struct fid_av *av_fid, fi_addr_t *fi_addr, size_t count,
uint64_t flags)
{
int ret = 0;
size_t i;
fi_addr_t dg_idx;
struct rxd_av *av;
av = container_of(av_fid, struct rxd_av, util_av.av_fid);
for (i = 0; i < count; i++) {
dg_idx = rxd_av_get_dg_addr(av, fi_addr[i]);
ret = fi_av_remove(av->dg_av, &dg_idx, 1, flags);
if (ret)
break;
av->dg_av_used--;
}
return ret;
}
static void *remove_single(void *data)
{
int ret;
fi_addr_t *addr = (fi_addr_t *) data;
ret = pthread_barrier_wait(&mtbar);
if ((ret != PTHREAD_BARRIER_SERIAL_THREAD) && (ret != 0)) {
pthread_exit((void *) 1UL);
}
av_lock();
ret = fi_av_remove(av, addr, 1, 0);
av_unlock();
if (ret != FI_SUCCESS) {
pthread_exit((void *) 2UL);
}
pthread_exit((void *) 0UL);
}
static int rxd_av_remove(struct fid_av *av_fid, fi_addr_t *fi_addr, size_t count,
uint64_t flags)
{
int ret = 0;
size_t i;
fi_addr_t dg_fiaddr;
struct rxd_av *av;
av = container_of(av_fid, struct rxd_av, util_av.av_fid);
fastlock_acquire(&av->util_av.lock);
for (i = 0; i < count; i++) {
dg_fiaddr = rxd_av_dg_addr(av, fi_addr[i]);
ret = fi_av_remove(av->dg_av, &dg_fiaddr, 1, flags);
if (ret)
break;
av->dg_av_used--;
}
fastlock_release(&av->util_av.lock);
return ret;
}
int rxd_av_insert_dg_addr(struct rxd_av *av, const void *addr,
fi_addr_t *rxd_addr, uint64_t flags,
void *context)
{
fi_addr_t dg_addr;
int ret;
ret = fi_av_insert(av->dg_av, addr, 1, &dg_addr,
flags, context);
if (ret != 1)
return -FI_EINVAL;
*rxd_addr = rxd_set_rxd_addr(av, dg_addr);
ret = ofi_rbmap_insert(&av->rbmap, (void *) addr, (void *) (*rxd_addr));
if (ret && ret != -FI_EALREADY) {
fi_av_remove(av->dg_av, &dg_addr, 1, flags);
return ret;
}
return 0;
}
static void addr_insert_test(void)
{
int i, ret;
fi_addr_t addresses[SIMPLE_ADDR_COUNT];
int err[SIMPLE_ADDR_COUNT] = {0};
cr_log_info("check for sync err flag but no context\n");
ret = fi_av_insert(av, (void *) simple_ep_names, SIMPLE_ADDR_COUNT,
addresses, FI_SYNC_ERR, NULL);
cr_assert_eq(ret, -FI_EINVAL, "%d", ret);
ret = fi_av_insert(av, (void *) simple_ep_names, SIMPLE_ADDR_COUNT,
addresses, FI_SYNC_ERR, err);
cr_assert_eq(ret, SIMPLE_ADDR_COUNT);
cr_log_info("check for errors\n");
for (i = 0; i < SIMPLE_ADDR_COUNT; i++) {
cr_assert_eq(err[i], 0);
}
ret = fi_av_remove(av, addresses, SIMPLE_ADDR_COUNT, 0);
cr_assert_eq(ret, FI_SUCCESS);
}
static int av_removal_test(void)
{
int ret;
fprintf(stdout, "AV address removal: ");
hints = fi_dupinfo(base_hints);
if (!hints)
return -FI_ENOMEM;
ret = ft_init_fabric();
if (ret)
goto out;
if (opts.dst_addr) {
ret = ft_tx(ep, remote_fi_addr, opts.transfer_size, &tx_ctx);
if (ret) {
FT_PRINTERR("ft_tx", -ret);
goto out;
}
ret = fi_av_remove(av, &remote_fi_addr, 1, 0);
if (ret) {
FT_PRINTERR("fi_av_remove", ret);
goto out;
}
ret = ft_sync();
if (ret)
goto out;
ret = ft_init_av();
if (ret) {
FT_PRINTERR("ft_init_av", -ret);
goto out;
}
ret = ft_rx(ep, opts.transfer_size);
if (ret) {
FT_PRINTERR("ft_rx", -ret);
goto out;
}
} else {
ret = ft_rx(ep, opts.transfer_size);
if (ret) {
FT_PRINTERR("ft_rx", -ret);
goto out;
}
ret = fi_av_remove(av, &remote_fi_addr, 1, 0);
if (ret) {
FT_PRINTERR("fi_av_remove", ret);
goto out;
}
ret = ft_sync();
if (ret)
goto out;
ret = ft_init_av();
if (ret) {
FT_PRINTERR("ft_init_av", -ret);
goto out;
}
ret = ft_tx(ep, remote_fi_addr, opts.transfer_size, &tx_ctx);
if (ret) {
FT_PRINTERR("ft_tx", -ret);
goto out;
}
}
fprintf(stdout, "PASS\n");
(void) ft_sync();
out:
ft_free_res();
return ret;
}
