queue<type>::queue(unsigned long qsz) {
/*initial value of queue*/
_qsize = roundup_power_of_two(qsz);
/*allocate the queue buffer*/
_queue = new void*[_qsize];
/*initialize the read&write wait flag*/
_rwflag = 1;
_wwflag = 0;
/*initialize the read&write position*/
_rpos = 0;
_wpos = 0;
/*initialize the condition variable*/
_cond1 = CreateEvent(NULL, FALSE, FALSE, NULL);
_cond2 = CreateEvent(NULL, FALSE, FALSE, NULL);
}
static int util_av_init(struct util_av *av, const struct fi_av_attr *attr,
const struct util_av_attr *util_attr)
{
int *entry, i, ret = 0;
atomic_initialize(&av->ref, 0);
fastlock_init(&av->lock);
av->count = attr->count ? attr->count : UTIL_DEFAULT_AV_SIZE;
av->count = roundup_power_of_two(av->count);
av->addrlen = util_attr->addrlen;
av->flags = util_attr->flags | attr->flags;
FI_INFO(av->prov, FI_LOG_AV, "AV size %zu\n", av->count);
/* TODO: Handle FI_READ */
/* TODO: Handle mmap - shared AV */
if (util_attr->flags & FI_SOURCE) {
av->hash.slots = av->count;
av->hash.total_count = av->count + util_attr->overhead;
FI_INFO(av->prov, FI_LOG_AV,
"FI_SOURCE requested, hash size %zu\n", av->hash.total_count);
}
av->data = malloc((av->count * util_attr->addrlen) +
(av->hash.total_count * sizeof(*av->hash.table)));
if (!av->data)
return -FI_ENOMEM;
for (i = 0; i < av->count - 1; i++) {
entry = util_av_get_data(av, i);
*entry = i + 1;
}
entry = util_av_get_data(av, av->count - 1);
*entry = UTIL_NO_ENTRY;
if (util_attr->flags & FI_SOURCE) {
av->hash.table = util_av_get_data(av, av->count);
util_av_hash_init(&av->hash);
}
return ret;
}
size_t sock_get_tx_size(size_t size)
{
return roundup_power_of_two(size * SOCK_EP_TX_ENTRY_SZ) /
SOCK_EP_TX_ENTRY_SZ;
}
int rxd_av_create(struct fid_domain *domain_fid, struct fi_av_attr *attr,
struct fid_av **av_fid, void *context)
{
int ret, i;
struct rxd_av *av;
struct rxd_domain *domain;
struct util_av_attr util_attr;
struct fi_av_attr av_attr;
if (!attr)
return -FI_EINVAL;
if (attr->name)
return -FI_ENOSYS;
attr->count = roundup_power_of_two(attr->count ?
attr->count : RXD_DEFAULT_AV_SIZE);
domain = container_of(domain_fid, struct rxd_domain, util_domain.domain_fid);
av = calloc(1, sizeof(*av));
if (!av)
return -FI_ENOMEM;
av->fi_addr_table = calloc(1, attr->count * sizeof(fi_addr_t));
av->rxd_addr_table = calloc(1, rxd_env.max_peers * sizeof(struct rxd_addr));
if (!av->fi_addr_table || !av->rxd_addr_table) {
ret = -FI_ENOMEM;
goto err1;
}
util_attr.addrlen = sizeof(fi_addr_t);
util_attr.flags = 0;
attr->type = domain->util_domain.av_type != FI_AV_UNSPEC ?
domain->util_domain.av_type : FI_AV_TABLE;
ret = ofi_av_init(&domain->util_domain, attr, &util_attr,
&av->util_av, context);
if (ret)
goto err1;
av->rbmap.compare = &rxd_tree_compare;
ofi_rbmap_init(&av->rbmap);
for (i = 0; i < attr->count; av->fi_addr_table[i++] = FI_ADDR_UNSPEC)
;
for (i = 0; i < rxd_env.max_peers; i++) {
av->rxd_addr_table[i].fi_addr = FI_ADDR_UNSPEC;
av->rxd_addr_table[i].dg_addr = FI_ADDR_UNSPEC;
}
av_attr = *attr;
av_attr.count = 0;
av_attr.flags = 0;
ret = fi_av_open(domain->dg_domain, &av_attr, &av->dg_av, context);
if (ret)
goto err2;
av->util_av.av_fid.fid.ops = &rxd_av_fi_ops;
av->util_av.av_fid.ops = &rxd_av_ops;
*av_fid = &av->util_av.av_fid;
return 0;
err2:
ofi_av_close(&av->util_av);
err1:
free(av->fi_addr_table);
free(av->rxd_addr_table);
free(av);
return ret;
}
