void uct_iface_mem_free(const uct_allocated_memory_t *mem)
{
if (mem->method != UCT_ALLOC_METHOD_MD) {
uct_md_mem_dereg(mem->md, mem->memh);
}
uct_mem_free(mem);
}
ucs_status_t ucp_mem_unmap(ucp_context_h context, ucp_mem_h memh)
{
uct_allocated_memory_t mem;
uct_mem_h alloc_pd_memh;
ucs_status_t status;
ucs_debug("unmapping buffer %p memh %p", memh->address, memh);
if (memh == &ucp_mem_dummy_handle) {
return UCS_OK;
}
/* Unregister from all protection domains */
status = ucp_memh_dereg_pds(context, memh, &alloc_pd_memh);
if (status != UCS_OK) {
return status;
}
/* If the memory was also allocated, release it */
if (memh->alloc_method != UCT_ALLOC_METHOD_LAST) {
mem.address = memh->address;
mem.length = memh->length;
mem.method = memh->alloc_method;
mem.pd = memh->alloc_pd; /* May be NULL if method is not PD */
mem.memh = alloc_pd_memh; /* May be INVALID if method is not PD */
status = uct_mem_free(&mem);
if (status != UCS_OK) {
return status;
}
}
ucs_free(memh);
return UCS_OK;
}
void uct_iface_mem_free(const uct_allocated_memory_t *mem)
{
if ((mem->method != UCT_ALLOC_METHOD_MD) &&
(mem->memh != UCT_MEM_HANDLE_NULL))
{
(void)uct_md_mem_dereg(mem->md, mem->memh);
}
uct_mem_free(mem);
}
static ucs_status_t ucp_mem_alloc(ucp_context_h context, size_t length,
const char *name, ucp_mem_h memh)
{
uct_allocated_memory_t mem;
uct_alloc_method_t method;
unsigned method_index, pd_index, num_pds;
ucs_status_t status;
uct_pd_h *pds;
pds = ucs_calloc(context->num_pds, sizeof(*pds), "temp pds");
if (pds == NULL) {
return UCS_ERR_NO_MEMORY;
}
for (method_index = 0; method_index < context->config.num_alloc_methods;
++method_index)
{
method = context->config.alloc_methods[method_index].method;
/* If we are trying PD method, gather all PDs which match the component
* name specified in the configuration.
*/
num_pds = 0;
if (method == UCT_ALLOC_METHOD_PD) {
for (pd_index = 0; pd_index < context->num_pds; ++pd_index) {
if (ucp_is_pd_selected_by_config(context, method_index, pd_index)) {
pds[num_pds++] = context->pds[pd_index];
}
}
}
status = uct_mem_alloc(length, &method, 1, pds, num_pds, name, &mem);
if (status == UCS_OK) {
goto allocated;
}
}
status = UCS_ERR_NO_MEMORY;
goto out;
allocated:
ucs_debug("allocated memory at %p with method %s, now registering it",
mem.address, uct_alloc_method_names[mem.method]);
memh->address = mem.address;
memh->length = mem.length;
memh->alloc_method = mem.method;
memh->alloc_pd = mem.pd;
status = ucp_memh_reg_pds(context, memh, mem.memh);
if (status != UCS_OK) {
uct_mem_free(&mem);
}
out:
ucs_free(pds);
return status;
}
ucs_status_t uct_iface_mem_alloc(uct_iface_h tl_iface, size_t length, unsigned flags,
const char *name, uct_allocated_memory_t *mem)
{
uct_base_iface_t *iface = ucs_derived_of(tl_iface, uct_base_iface_t);
uct_md_attr_t md_attr;
ucs_status_t status;
status = uct_mem_alloc(NULL, length, UCT_MD_MEM_ACCESS_ALL,
iface->config.alloc_methods,
iface->config.num_alloc_methods, &iface->md, 1,
name, mem);
if (status != UCS_OK) {
goto err;
}
/* If the memory was not allocated using MD, register it */
if (mem->method != UCT_ALLOC_METHOD_MD) {
status = uct_md_query(iface->md, &md_attr);
if (status != UCS_OK) {
goto err_free;
}
/* If MD does not support registration, allow only the MD method */
if ((md_attr.cap.flags & UCT_MD_FLAG_REG) &&
(md_attr.cap.reg_mem_types & UCS_BIT(mem->mem_type))) {
status = uct_md_mem_reg(iface->md, mem->address, mem->length, flags,
&mem->memh);
if (status != UCS_OK) {
goto err_free;
}
ucs_assert(mem->memh != UCT_MEM_HANDLE_NULL);
} else {
mem->memh = UCT_MEM_HANDLE_NULL;
}
mem->md = iface->md;
}
return UCS_OK;
err_free:
uct_mem_free(mem);
err:
return status;
}
ucs_status_t uct_iface_mem_alloc(uct_iface_h tl_iface, size_t length,
const char *name, uct_allocated_memory_t *mem)
{
uct_base_iface_t *iface = ucs_derived_of(tl_iface, uct_base_iface_t);
uct_md_attr_t md_attr;
ucs_status_t status;
status = uct_mem_alloc(length, iface->config.alloc_methods,
iface->config.num_alloc_methods, &iface->md, 1,
name, mem);
if (status != UCS_OK) {
goto err;
}
/* If the memory was not allocated using MD, register it */
if (mem->method != UCT_ALLOC_METHOD_MD) {
status = uct_md_query(iface->md, &md_attr);
if (status != UCS_OK) {
goto err_free;
}
/* If MD does not support registration, allow only the MD method */
if (!(md_attr.cap.flags & UCT_MD_FLAG_REG)) {
ucs_error("%s md does not support registration, so cannot use any allocation "
"method except 'md'", iface->md->component->name);
status = UCS_ERR_NO_MEMORY;
goto err_free;
}
status = uct_md_mem_reg(iface->md, mem->address, mem->length, &mem->memh);
if (status != UCS_OK) {
goto err_free;
}
ucs_assert(mem->memh != UCT_INVALID_MEM_HANDLE);
mem->md = iface->md;
}
return UCS_OK;
err_free:
uct_mem_free(mem);
err:
return status;
}
