int psmx_wait_open(struct fid_domain *domain, struct fi_wait_attr *attr,
struct fid_wait **waitset)
{
struct psmx_fid_domain *domain_priv;
struct psmx_fid_wait *wait_priv;
int type = FI_WAIT_FD;
int err;
domain_priv = container_of(domain, struct psmx_fid_domain, domain);
if (attr) {
switch (attr->wait_obj) {
case FI_WAIT_UNSPEC:
break;
case FI_WAIT_FD:
case FI_WAIT_MUTEX_COND:
type = attr->wait_obj;
break;
default:
psmx_debug("%s: attr->wait_obj=%d, supported=%d,%d,%d\n",
__func__, attr->wait_obj, FI_WAIT_UNSPEC,
FI_WAIT_FD, FI_WAIT_MUTEX_COND);
return -FI_EINVAL;
}
}
wait_priv = calloc(1, sizeof(*wait_priv));
if (!wait_priv)
return -FI_ENOMEM;
err = psmx_wait_init(wait_priv, type);
if (err) {
free(wait_priv);
return err;
}
wait_priv->wait.fid.fclass = FI_CLASS_WAIT;
wait_priv->wait.fid.context = 0;
wait_priv->wait.fid.ops = &psmx_fi_ops;
wait_priv->wait.ops = &psmx_wait_ops;
wait_priv->domain = domain_priv;
*waitset = &wait_priv->wait;
return 0;
}
int psmx_av_open(struct fid_domain *domain, struct fi_av_attr *attr,
struct fid_av **av, void *context)
{
struct psmx_fid_domain *fid_domain;
struct psmx_fid_av *fid_av;
int type = FI_AV_MAP;
size_t count = 64;
fid_domain = container_of(domain, struct psmx_fid_domain, domain);
if (attr) {
switch (attr->type) {
case FI_AV_MAP:
case FI_AV_TABLE:
type = attr->type;
break;
default:
psmx_debug("%s: attr->type=%d, supported=%d %d\n",
__func__, attr->type, FI_AV_MAP, FI_AV_TABLE);
return -EINVAL;
}
count = attr->count;
}
fid_av = (struct psmx_fid_av *) calloc(1, sizeof *fid_av);
if (!fid_av)
return -ENOMEM;
fid_av->domain = fid_domain;
fid_av->type = type;
fid_av->addrlen = sizeof(psm_epaddr_t);
fid_av->count = count;
fid_av->av.fid.fclass = FID_CLASS_AV;
fid_av->av.fid.context = context;
fid_av->av.fid.ops = &psmx_fi_ops;
fid_av->av.ops = &psmx_av_ops;
*av = &fid_av->av;
return 0;
}
int psmx_eq_open(struct fid_domain *domain, struct fi_eq_attr *attr,
struct fid_eq **eq, void *context)
{
struct psmx_fid_domain *fid_domain;
struct psmx_fid_eq *fid_eq;
int format;
int entry_size;
if ((attr->wait_cond != FI_EQ_COND_NONE) ||
(attr->flags & FI_WRITE))
return -ENOSYS;
switch (attr->domain) {
case FI_EQ_DOMAIN_GENERAL:
case FI_EQ_DOMAIN_COMP:
break;
default:
psmx_debug("%s: attr->domain=%d, supported=%d,%d\n", __func__, attr->domain,
FI_EQ_DOMAIN_GENERAL, FI_EQ_DOMAIN_COMP);
return -ENOSYS;
}
switch (attr->format) {
case FI_EQ_FORMAT_UNSPEC:
format = FI_EQ_FORMAT_TAGGED;
entry_size = sizeof(struct fi_eq_tagged_entry);
break;
case FI_EQ_FORMAT_CONTEXT:
format = attr->format;
entry_size = sizeof(struct fi_eq_entry);
break;
case FI_EQ_FORMAT_COMP:
format = attr->format;
entry_size = sizeof(struct fi_eq_comp_entry);
break;
case FI_EQ_FORMAT_DATA:
format = attr->format;
entry_size = sizeof(struct fi_eq_data_entry);
break;
case FI_EQ_FORMAT_TAGGED:
format = attr->format;
entry_size = sizeof(struct fi_eq_tagged_entry);
break;
case FI_EQ_FORMAT_CM:
format = attr->format;
entry_size = sizeof(struct fi_eq_cm_entry);
break;
default:
psmx_debug("%s: attr->format=%d, supported=%d...%d\n", __func__, attr->format,
FI_EQ_FORMAT_UNSPEC, FI_EQ_FORMAT_CM);
return -EINVAL;
}
fid_domain = container_of(domain, struct psmx_fid_domain, domain);
fid_eq = (struct psmx_fid_eq *) calloc(1, sizeof *fid_eq);
if (!fid_eq)
return -ENOMEM;
fid_eq->domain = fid_domain;
fid_eq->format = format;
fid_eq->entry_size = entry_size;
fid_eq->eq.fid.fclass = FID_CLASS_EQ;
fid_eq->eq.fid.context = context;
fid_eq->eq.fid.ops = &psmx_fi_ops;
fid_eq->eq.ops = &psmx_eq_ops;
*eq = &fid_eq->eq;
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 psmx_fid_wait *wait = NULL;
struct fi_wait_attr wait_attr;
int events;
uint64_t flags;
int err;
events = FI_CNTR_EVENTS_COMP;
flags = 0;
switch (attr->events) {
case FI_CNTR_EVENTS_COMP:
events = attr->events;
break;
default:
psmx_debug("%s: attr->events=%d, supported=%d\n", __func__,
attr->events, FI_CNTR_EVENTS_COMP);
return -EINVAL;
}
switch (attr->wait_obj) {
case FI_WAIT_NONE:
case FI_WAIT_UNSPEC:
break;
case FI_WAIT_SET:
if (!attr->wait_set) {
psmx_debug("%s: FI_WAIT_SET is specified but attr->wait_set is NULL\n",
__func__);
return -FI_EINVAL;
}
wait = (struct psmx_fid_wait *)attr->wait_set;
break;
case FI_WAIT_FD:
case FI_WAIT_MUT_COND:
wait_attr.wait_obj = attr->wait_obj;
wait_attr.flags = 0;
err = psmx_wait_open(domain, &wait_attr, (struct fid_wait **)&wait);
if (err)
return err;
break;
default:
psmx_debug("%s: attr->wait_obj=%d, supported=%d...%d\n", __func__,
attr->wait_obj, FI_WAIT_NONE, FI_WAIT_MUT_COND);
return -FI_EINVAL;
}
domain_priv = container_of(domain, struct psmx_fid_domain, domain);
cntr_priv = (struct psmx_fid_cntr *) calloc(1, sizeof *cntr_priv);
if (!cntr_priv)
return -ENOMEM;
cntr_priv->domain = domain_priv;
cntr_priv->events = events;
cntr_priv->wait = wait;
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;
pthread_mutex_init(&cntr_priv->trigger_lock, NULL);
*cntr = &cntr_priv->cntr;
return 0;
}
void psmx_cntr_check_trigger(struct psmx_fid_cntr *cntr)
{
struct psmx_trigger *trigger;
if (!cntr->trigger)
return;
pthread_mutex_lock(&cntr->trigger_lock);
trigger = cntr->trigger;
while (trigger) {
if (cntr->counter < trigger->threshold)
break;
cntr->trigger = trigger->next;
switch (trigger->op) {
case PSMX_TRIGGERED_SEND:
_psmx_sendto(trigger->send.ep,
trigger->send.buf,
trigger->send.len,
trigger->send.desc,
trigger->send.dest_addr,
trigger->send.context,
trigger->send.flags);
break;
case PSMX_TRIGGERED_RECV:
_psmx_recvfrom(trigger->recv.ep,
trigger->recv.buf,
trigger->recv.len,
trigger->recv.desc,
trigger->recv.src_addr,
trigger->recv.context,
trigger->recv.flags);
break;
case PSMX_TRIGGERED_TSEND:
_psmx_tagged_sendto(trigger->tsend.ep,
trigger->tsend.buf,
trigger->tsend.len,
trigger->tsend.desc,
trigger->tsend.dest_addr,
trigger->tsend.tag,
trigger->tsend.context,
trigger->tsend.flags);
break;
case PSMX_TRIGGERED_TRECV:
_psmx_tagged_recvfrom(trigger->trecv.ep,
trigger->trecv.buf,
trigger->trecv.len,
trigger->trecv.desc,
trigger->trecv.src_addr,
trigger->trecv.tag,
trigger->trecv.ignore,
trigger->trecv.context,
trigger->trecv.flags);
break;
case PSMX_TRIGGERED_WRITE:
_psmx_writeto(trigger->write.ep,
trigger->write.buf,
trigger->write.len,
trigger->write.desc,
trigger->write.dest_addr,
trigger->write.addr,
trigger->write.key,
trigger->write.context,
trigger->write.flags,
trigger->write.data);
break;
case PSMX_TRIGGERED_READ:
_psmx_readfrom(trigger->read.ep,
trigger->read.buf,
trigger->read.len,
trigger->read.desc,
trigger->read.src_addr,
trigger->read.addr,
trigger->read.key,
trigger->read.context,
trigger->read.flags);
break;
case PSMX_TRIGGERED_ATOMIC_WRITE:
_psmx_atomic_writeto(trigger->atomic_write.ep,
trigger->atomic_write.buf,
trigger->atomic_write.count,
trigger->atomic_write.desc,
trigger->atomic_write.dest_addr,
trigger->atomic_write.addr,
trigger->atomic_write.key,
trigger->atomic_write.datatype,
trigger->atomic_write.atomic_op,
trigger->atomic_write.context,
trigger->atomic_write.flags);
break;
case PSMX_TRIGGERED_ATOMIC_READWRITE:
_psmx_atomic_readwriteto(trigger->atomic_readwrite.ep,
trigger->atomic_readwrite.buf,
trigger->atomic_readwrite.count,
trigger->atomic_readwrite.desc,
trigger->atomic_readwrite.result,
trigger->atomic_readwrite.result_desc,
trigger->atomic_readwrite.dest_addr,
trigger->atomic_readwrite.addr,
trigger->atomic_readwrite.key,
trigger->atomic_readwrite.datatype,
trigger->atomic_readwrite.atomic_op,
trigger->atomic_readwrite.context,
trigger->atomic_readwrite.flags);
break;
case PSMX_TRIGGERED_ATOMIC_COMPWRITE:
_psmx_atomic_compwriteto(trigger->atomic_compwrite.ep,
trigger->atomic_compwrite.buf,
trigger->atomic_compwrite.count,
trigger->atomic_compwrite.desc,
trigger->atomic_compwrite.compare,
trigger->atomic_compwrite.compare_desc,
trigger->atomic_compwrite.result,
trigger->atomic_compwrite.result_desc,
trigger->atomic_compwrite.dest_addr,
trigger->atomic_compwrite.addr,
trigger->atomic_compwrite.key,
trigger->atomic_compwrite.datatype,
trigger->atomic_compwrite.atomic_op,
trigger->atomic_compwrite.context,
trigger->atomic_compwrite.flags);
break;
default:
psmx_debug("%s: %d unsupported op\n", __func__, trigger->op);
break;
}
free(trigger);
}
pthread_mutex_unlock(&cntr->trigger_lock);
}
