void setup_wait_type(enum fi_wait_obj wait_obj)
{
int ret;
wait_setup();
wait_attr.wait_obj = wait_obj;
ret = fi_wait_open(fab, &wait_attr, &wait_set);
cr_assert(!ret, "fi_wait_open");
wait_priv = container_of(wait_set, struct gnix_fid_wait, wait);
}
static int alloc_ep_res(struct fi_info *fi)
{
struct fi_wait_attr wait_attr;
int ret;
memset(&wait_attr, 0, sizeof wait_attr);
wait_attr.wait_obj = FI_WAIT_UNSPEC;
ret = fi_wait_open(fabric, &wait_attr, &waitset);
if (ret) {
FT_PRINTERR("fi_wait_open", ret);
return ret;
}
ret = ft_alloc_active_res(fi);
if (ret)
return ret;
return 0;
}
static int util_eq_init(struct fid_fabric *fabric, struct util_eq *eq,
const struct fi_eq_attr *attr)
{
struct fi_wait_attr wait_attr;
struct fid_wait *wait;
int ret;
ofi_atomic_initialize32(&eq->ref, 0);
slist_init(&eq->list);
fastlock_init(&eq->lock);
switch (attr->wait_obj) {
case FI_WAIT_NONE:
break;
case FI_WAIT_UNSPEC:
case FI_WAIT_FD:
case FI_WAIT_MUTEX_COND:
memset(&wait_attr, 0, sizeof wait_attr);
wait_attr.wait_obj = attr->wait_obj;
eq->internal_wait = 1;
ret = fi_wait_open(fabric, &wait_attr, &wait);
if (ret)
return ret;
eq->wait = container_of(wait, struct util_wait, wait_fid);
break;
case FI_WAIT_SET:
eq->wait = container_of(attr->wait_set, struct util_wait,
wait_fid);
break;
default:
assert(0);
return -FI_EINVAL;
}
return 0;
}
int psmx_cntr_open(struct fid_domain *domain, struct fi_cntr_attr *attr,
struct fid_cntr **cntr, void *context)
{
struct psmx_fid_domain *domain_priv;
struct psmx_fid_cntr *cntr_priv;
struct fid_wait *wait = NULL;
struct fi_wait_attr wait_attr;
int wait_is_local = 0;
int events;
uint64_t flags;
int err;
events = FI_CNTR_EVENTS_COMP;
flags = 0;
domain_priv = container_of(domain, struct psmx_fid_domain,
util_domain.domain_fid);
switch (attr->events) {
case FI_CNTR_EVENTS_COMP:
events = attr->events;
break;
default:
FI_INFO(&psmx_prov, FI_LOG_CQ,
"attr->events=%d, supported=%d\n",
attr->events, FI_CNTR_EVENTS_COMP);
return -FI_EINVAL;
}
switch (attr->wait_obj) {
case FI_WAIT_NONE:
case FI_WAIT_UNSPEC:
break;
case FI_WAIT_SET:
if (!attr->wait_set) {
FI_INFO(&psmx_prov, FI_LOG_CQ,
"FI_WAIT_SET is specified but attr->wait_set is NULL\n");
return -FI_EINVAL;
}
wait = attr->wait_set;
break;
case FI_WAIT_FD:
case FI_WAIT_MUTEX_COND:
wait_attr.wait_obj = attr->wait_obj;
wait_attr.flags = 0;
err = fi_wait_open(&domain_priv->fabric->util_fabric.fabric_fid,
&wait_attr, (struct fid_wait **)&wait);
if (err)
return err;
wait_is_local = 1;
break;
default:
FI_INFO(&psmx_prov, FI_LOG_CQ,
"attr->wait_obj=%d, supported=%d...%d\n",
attr->wait_obj, FI_WAIT_NONE, FI_WAIT_MUTEX_COND);
return -FI_EINVAL;
}
cntr_priv = (struct psmx_fid_cntr *) calloc(1, sizeof *cntr_priv);
if (!cntr_priv) {
err = -FI_ENOMEM;
goto fail;
}
cntr_priv->domain = domain_priv;
cntr_priv->events = events;
if (wait)
cntr_priv->wait = container_of(wait, struct util_wait, wait_fid);
cntr_priv->wait_is_local = wait_is_local;
cntr_priv->flags = flags;
cntr_priv->cntr.fid.fclass = FI_CLASS_CNTR;
cntr_priv->cntr.fid.context = context;
cntr_priv->cntr.fid.ops = &psmx_fi_ops;
cntr_priv->cntr.ops = &psmx_cntr_ops;
ofi_atomic_initialize64(&cntr_priv->counter, 0);
ofi_atomic_initialize64(&cntr_priv->error_counter, 0);
pthread_mutex_init(&cntr_priv->trigger_lock, NULL);
if (wait)
fi_poll_add(&cntr_priv->wait->pollset->poll_fid,
&cntr_priv->cntr.fid, 0);
psmx_domain_acquire(domain_priv);
*cntr = &cntr_priv->cntr;
return 0;
fail:
if (wait && wait_is_local)
fi_close(&wait->fid);
return err;
}
